default to useful things, tests null things out on their own

drops/src/lib.rs

@@ -279,21 +279,6 @@ impl DropTableBuilder {
     }
 }
 
-struct NullDropTable;
-
-impl DropTable for NullDropTable {
-    fn get_drop(&mut self, _map_area: &MapArea, _monster: &MonsterType) -> Option<ItemDropType> {
-        None
-    }
-    fn get_box_drop(&mut self, _map_area: &MapArea, _object: &MapObject) -> Option<ItemDropType> {
-        None
-    }
-}
-
-pub fn null_drop_table(_episode: Episode, _difficult: Difficulty, _section_id: SectionID) -> Box<dyn DropTable + Send + Sync> {
-    Box::new(NullDropTable)
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

src/bin/main.rs

@@ -367,10 +367,6 @@ fn main() {
             .ip(Ipv4Addr::new(127,0,0,1))
             .port(elseware::ship::ship::SHIP_PORT)
             .event(Holiday::Halloween)
-            .standard_quest_builder(Box::new(quests::load_standard_quests))
-            .government_quest_builder(Box::new(quests::load_government_quests))
-            .drop_table_builder(Box::new(StandardDropTable::new))
-            .map_builder(Box::new(generate_free_roam_maps))
             .gateway(entity_gateway.clone())
             .build();
         let sub_ship_state = ship_state.clone();
@@ -387,10 +383,6 @@ fn main() {
             .ip(Ipv4Addr::new(127,0,0,1))
             .port(elseware::ship::ship::SHIP_PORT+2000)
             .event(Holiday::Christmas)
-            .standard_quest_builder(Box::new(quests::load_standard_quests))
-            .government_quest_builder(Box::new(quests::load_government_quests))
-            .drop_table_builder(Box::new(StandardDropTable::new))
-            .map_builder(Box::new(generate_free_roam_maps))
             .gateway(entity_gateway.clone())
             .build();
         let sub_ship_state = ship_state.clone();
@@ -406,10 +398,6 @@ fn main() {
             .name("JP/Thalarion".into())
             .ip(Ipv4Addr::new(127,0,0,1))
             .port(elseware::ship::ship::SHIP_PORT+3000)
-            .standard_quest_builder(Box::new(quests::load_standard_quests))
-            .government_quest_builder(Box::new(quests::load_government_quests))
-            .drop_table_builder(Box::new(StandardDropTable::new))
-            .map_builder(Box::new(generate_free_roam_maps))
             .gateway(entity_gateway.clone())
             .build();
         let sub_ship_state = ship_state.clone();

src/bin/ship.rs

@@ -45,10 +45,6 @@ fn main() {
         .port(elseware::ship::ship::SHIP_PORT)
         .gateway(entity_gateway)
         .auth_token(AuthToken(shipgate_token))
-        .standard_quest_builder(Box::new(quests::load_standard_quests))
-        .government_quest_builder(Box::new(quests::load_government_quests))
-        .drop_table_builder(Box::new(StandardDropTable::new))
-        .map_builder(Box::new(generate_free_roam_maps))
         .build();
 
     let shipgate_ip = std::env::var("SHIPGATE_IP").unwrap().parse().unwrap();

src/ship/ship.rs

@@ -22,15 +22,15 @@ use entity::gateway::{EntityGateway, GatewayError};
 use entity::character::SectionID;
 use entity::room::RoomNote;
 use location::{ClientLocation, RoomLobby, ClientLocationError, RoomId};
-use drops::{DropTable, null_drop_table};
+use drops::{DropTable, StandardDropTable};
 use items;
 use room;
 use maps::room::{RoomMode, Episode, Difficulty};
-//use quests::{load_standard_quests, load_government_quests};
+use quests::{load_standard_quests, load_government_quests};
 use quests::{QuestList, QuestLoadError};
 use maps::Holiday;
 use maps::area::MapAreaError;
-use maps::maps::{Maps, MapsError, null_free_roam_maps};
+use maps::maps::{Maps, MapsError, generate_free_roam_maps};
 use crate::ship::packet::handler;
 use shops::{WeaponShop, ToolShop, ArmorShop};
 use trade::TradeState;
@@ -434,10 +434,10 @@ impl<EG: EntityGateway + Clone + 'static> ShipServerStateBuilder<EG> {
             shops: ItemShops::default(),
             blocks: Blocks(blocks),
             event: self.event.unwrap_or(Holiday::None),
-            map_builder: Arc::new(self.map_builder.unwrap_or(Box::new(null_free_roam_maps))),
-            drop_table_builder: Arc::new(self.drop_table_builder.unwrap_or(Box::new(null_drop_table))),
-            standard_quest_builder: Arc::new(self.standard_quest_builder.unwrap_or(Box::new(|_| Ok(QuestList::new())))),
-            government_quest_builder: Arc::new(self.government_quest_builder.unwrap_or(Box::new(|_| Ok(QuestList::new())))),
+            map_builder: Arc::new(self.map_builder.unwrap_or(Box::new(generate_free_roam_maps))),
+            drop_table_builder: Arc::new(self.drop_table_builder.unwrap_or(Box::new(StandardDropTable::new))),
+            standard_quest_builder: Arc::new(self.standard_quest_builder.unwrap_or(Box::new(load_standard_quests))),
+            government_quest_builder: Arc::new(self.government_quest_builder.unwrap_or(Box::new(load_government_quests))),
 
             auth_token: self.auth_token.unwrap_or_else(|| AuthToken("".into())),
             ship_list: Arc::new(RwLock::new(Vec::new())),

tests/common.rs

@@ -3,10 +3,16 @@
 use networking::serverstate::{ClientId, ServerState};
 use entity::gateway::EntityGateway;
 use entity::account::{UserAccountEntity, NewUserAccountEntity, NewUserSettingsEntity};
-use entity::character::{CharacterEntity, NewCharacterEntity};
+use entity::character::{CharacterEntity, NewCharacterEntity, SectionID};
 use entity::item::{Meseta, BankIdentifier};
-use elseware::ship::ship::{ShipServerState, RecvShipPacket};
-use maps::room::Difficulty;
+use elseware::ship::ship::{ShipServerState, ShipServerStateBuilder, RecvShipPacket};
+use maps::room::{RoomMode, Difficulty, Episode};
+use maps::area::MapArea;
+use maps::maps::null_free_roam_maps;
+use maps::object::MapObject;
+use maps::monster::MonsterType;
+use quests::{QuestList, QuestLoadError};
+use drops::{DropTable, ItemDropType};
 
 use entity::item;
 
@@ -14,6 +20,43 @@ use libpso::packet::ship::*;
 use libpso::packet::login::{Login, Session};
 use libpso::{utf8_to_array, utf8_to_utf16_array};
 
+fn null_quest_builder(_mode: RoomMode) -> Result<QuestList, QuestLoadError> {
+    Ok(Default::default())
+}
+
+struct NullDropTable;
+
+impl DropTable for NullDropTable {
+    fn get_drop(&mut self, _map_area: &MapArea, _monster: &MonsterType) -> Option<ItemDropType> {
+        None
+    }
+    fn get_box_drop(&mut self, _map_area: &MapArea, _object: &MapObject) -> Option<ItemDropType> {
+        None
+    }
+}
+
+pub fn null_drop_table_builder(_episode: Episode, _difficult: Difficulty, _section_id: SectionID) -> Box<dyn DropTable + Send + Sync> {
+    Box::new(NullDropTable)
+}
+
+pub fn standard_ship_buildable<EG: EntityGateway + Clone>(gateway: EG) ->  ShipServerStateBuilder<EG> {
+    ShipServerState::builder()
+        .gateway(gateway)
+        .standard_quest_builder(Box::new(null_quest_builder))
+        .government_quest_builder(Box::new(null_quest_builder))
+        .drop_table_builder(Box::new(null_drop_table_builder))
+        .map_builder(Box::new(null_free_roam_maps))
+}
+
+pub fn standard_ship<EG: EntityGateway + Clone>(gateway: EG) ->  ShipServerState<EG> {
+    ShipServerState::builder()
+        .gateway(gateway)
+        .standard_quest_builder(Box::new(null_quest_builder))
+        .government_quest_builder(Box::new(null_quest_builder))
+        .drop_table_builder(Box::new(null_drop_table_builder))
+        .map_builder(Box::new(null_free_roam_maps))
+        .build()
+}
 
 //TODO: remove kb_conf_preset
 pub async fn new_user_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, username: &str, password: &str, kb_conf_preset: usize) -> (UserAccountEntity, CharacterEntity) {

tests/test_bank.rs

@@ -33,9 +33,7 @@ async fn test_bank_items_sent_in_character_login() {
 
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
 
     let packets = ship.handle(ClientId(1), RecvShipPacket::MenuSelect(MenuSelect {
@@ -71,9 +69,7 @@ async fn test_request_bank_items() {
 
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -115,9 +111,7 @@ async fn test_request_stacked_bank_items() {
 
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -180,9 +174,7 @@ async fn test_request_bank_items_sorted() {
     let bank = vec![item::BankItemEntity::Individual(item1), vec![monomate].into(), item2.into()];
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -237,9 +229,7 @@ async fn test_deposit_individual_item() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![item0, item1])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -303,9 +293,7 @@ async fn test_deposit_stacked_item() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -364,9 +352,7 @@ async fn test_deposit_partial_stacked_item() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -445,9 +431,7 @@ async fn test_deposit_stacked_item_with_stack_already_in_bank() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -518,9 +502,7 @@ async fn test_deposit_stacked_item_with_full_stack_in_bank() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -596,9 +578,7 @@ async fn test_deposit_individual_item_in_full_bank() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -668,9 +648,7 @@ async fn test_deposit_stacked_item_in_full_bank() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(full_bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -754,9 +732,7 @@ async fn test_deposit_stacked_item_in_full_bank_with_partial_stack() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(almost_full_bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -794,9 +770,7 @@ async fn test_deposit_meseta() {
     let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -831,9 +805,7 @@ async fn test_deposit_too_much_meseta() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(999980)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -870,9 +842,7 @@ async fn test_deposit_meseta_when_bank_is_maxed() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -925,9 +895,7 @@ async fn test_withdraw_individual_item() {
 
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -985,9 +953,7 @@ async fn test_withdraw_stacked_item() {
 
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1044,9 +1010,7 @@ async fn test_withdraw_partial_stacked_item() {
     }
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1122,9 +1086,7 @@ async fn test_withdraw_stacked_item_with_stack_already_in_inventory() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1197,9 +1159,7 @@ async fn test_withdraw_stacked_item_with_full_stack_in_inventory() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![inventory_monomates])).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![bank_monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1275,9 +1235,7 @@ async fn test_withdraw_individual_item_in_full_inventory() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(bank), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1343,9 +1301,7 @@ async fn test_withdraw_stacked_item_in_full_inventory() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1430,9 +1386,7 @@ async fn test_withdraw_stacked_item_in_full_inventory_with_partial_stack() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1473,9 +1427,7 @@ async fn test_withdraw_meseta() {
     let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1510,9 +1462,7 @@ async fn test_withdraw_too_much_meseta() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999980)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1549,9 +1499,7 @@ async fn test_withdraw_meseta_inventory_is_maxed() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1590,9 +1538,7 @@ async fn test_withdraw_meseta_and_buy_a_few_monomates_with_it() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(100)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Character, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1649,9 +1595,7 @@ async fn test_deposit_items_into_shared_banks() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![item0, item1, item2, item3, item4, item5])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1765,9 +1709,7 @@ async fn test_deposit_meseta_into_shared_banks() {
     let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1852,9 +1794,7 @@ async fn test_withdraw_items_from_shared_banks() {
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item2, item3]), &item::BankIdentifier::Shared(item::BankName("asdf".into()))).await.unwrap();
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![item4, item5]), &item::BankIdentifier::Shared(item::BankName("qwer".into()))).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -1956,9 +1896,7 @@ async fn test_withdraw_meseta_from_shared_banks() {
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("asdf".into())), item::Meseta(300)).await.unwrap();
     entity_gateway.set_bank_meseta(&char1.id, &item::BankIdentifier::Shared(item::BankName("qwer".into())), item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;

tests/test_character.rs

@@ -15,9 +15,7 @@ async fn test_save_options() {
 
     let (user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
 
@@ -37,9 +35,7 @@ async fn test_change_keyboard_mappings() {
 
     let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 2).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
 

tests/test_exp_gain.rs

@@ -21,16 +21,15 @@ async fn test_character_gains_exp() {
 
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -57,16 +56,15 @@ async fn test_character_levels_up() {
     char1.exp = 49;
     entity_gateway.save_character(&char1).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -94,16 +92,15 @@ async fn test_character_levels_up_multiple_times() {
 
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::DarkFalz, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::DarkFalz2, MapArea::DarkFalz))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::DarkFalz, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::DarkFalz2, MapArea::DarkFalz))],
+                Vec::new(),
+            )
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -131,16 +128,15 @@ async fn test_one_character_gets_full_exp_and_other_attacker_gets_partial() {
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 

tests/test_item_actions.rs

@@ -56,9 +56,7 @@ async fn test_equip_unit_from_equip_menu() {
     entity_gateway.set_character_equips(&char1.id, &equipped).await.unwrap();
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -133,9 +131,7 @@ async fn test_unequip_armor_with_units() {
     entity_gateway.set_character_equips(&char1.id, &equipped).await.unwrap();
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -193,9 +189,7 @@ async fn test_sort_items() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;

tests/test_item_drop.rs

@@ -22,32 +22,31 @@ async fn test_enemy_drops_item() {
     let mut entity_gateway = InMemoryGateway::default();
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .drop_table_builder(Box::new(|episode, difficulty, section_id| {
-                                StandardDropTable::builder()
-                                    .monster_stat(MonsterType::Hildebear, MonsterDropStats {
-                                        dar: 100,
-                                        drop_type: MonsterDropType::Weapon,
-                                        min_meseta: 0,
-                                        max_meseta: 0,
-                                    })
-                                    .rare_table(RareDropTable::builder()
-                                                .rate(MonsterType::Hildebear, RareDropRate {
-                                                    rate: 1.0,
-                                                    item: RareDropItem::Weapon(WeaponType::DarkFlow)
-                                                })
-                                                .build(episode, difficulty, section_id))
-                                    .build(episode, difficulty, section_id)
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .drop_table_builder(Box::new(|episode, difficulty, section_id| {
+            StandardDropTable::builder()
+                .monster_stat(MonsterType::Hildebear, MonsterDropStats {
+                    dar: 100,
+                    drop_type: MonsterDropType::Weapon,
+                    min_meseta: 0,
+                    max_meseta: 0,
+                })
+                .rare_table(RareDropTable::builder()
+                            .rate(MonsterType::Hildebear, RareDropRate {
+                                rate: 1.0,
+                                item: RareDropItem::Weapon(WeaponType::DarkFlow)
+                            })
+                            .build(episode, difficulty, section_id))
+                .build(episode, difficulty, section_id)
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -78,32 +77,31 @@ async fn test_enemy_drops_item_for_two_players() {
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .drop_table_builder(Box::new(|episode, difficulty, section_id| {
-                                StandardDropTable::builder()
-                                    .monster_stat(MonsterType::Hildebear, MonsterDropStats {
-                                        dar: 100,
-                                        drop_type: MonsterDropType::Weapon,
-                                        min_meseta: 0,
-                                        max_meseta: 0,
-                                    })
-                                    .rare_table(RareDropTable::builder()
-                                                .rate(MonsterType::Hildebear, RareDropRate {
-                                                    rate: 1.0,
-                                                    item: RareDropItem::Weapon(WeaponType::DarkFlow)
-                                                })
-                                                .build(episode, difficulty, section_id))
-                                    .build(episode, difficulty, section_id)
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .drop_table_builder(Box::new(|episode, difficulty, section_id| {
+            StandardDropTable::builder()
+                .monster_stat(MonsterType::Hildebear, MonsterDropStats {
+                    dar: 100,
+                    drop_type: MonsterDropType::Weapon,
+                    min_meseta: 0,
+                    max_meseta: 0,
+                })
+                .rare_table(RareDropTable::builder()
+                            .rate(MonsterType::Hildebear, RareDropRate {
+                                rate: 1.0,
+                                item: RareDropItem::Weapon(WeaponType::DarkFlow)
+                            })
+                            .build(episode, difficulty, section_id))
+                .build(episode, difficulty, section_id)
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -146,32 +144,31 @@ async fn test_enemy_drops_item_for_two_players_and_pick_up() {
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-                            .gateway(entity_gateway.clone())
-                            .map_builder(Box::new(|_room_mode, _event| {
-                                Maps::new(
-                                    vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
-                                    vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
-                                    Vec::new(),
-                                )
-                            }))
-                            .drop_table_builder(Box::new(|episode, difficulty, section_id| {
-                                StandardDropTable::builder()
-                                    .monster_stat(MonsterType::Hildebear, MonsterDropStats {
-                                        dar: 100,
-                                        drop_type: MonsterDropType::Weapon,
-                                        min_meseta: 0,
-                                        max_meseta: 0,
-                                    })
-                                    .rare_table(RareDropTable::builder()
-                                                .rate(MonsterType::Hildebear, RareDropRate {
-                                                    rate: 1.0,
-                                                    item: RareDropItem::Weapon(WeaponType::DarkFlow)
-                                                })
-                                                .build(episode, difficulty, section_id))
-                                    .build(episode, difficulty, section_id)
-                            }))
-                            .build());
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
+        .map_builder(Box::new(|_room_mode, _event| {
+            Maps::new(
+                vec![MapVariant::new(MapArea::Forest2, MapVariantMode::Online)],
+                vec![Some(MapEnemy::new(MonsterType::Hildebear, MapArea::Forest2))],
+                Vec::new(),
+            )
+        }))
+        .drop_table_builder(Box::new(|episode, difficulty, section_id| {
+            StandardDropTable::builder()
+                .monster_stat(MonsterType::Hildebear, MonsterDropStats {
+                    dar: 100,
+                    drop_type: MonsterDropType::Weapon,
+                    min_meseta: 0,
+                    max_meseta: 0,
+                })
+                .rare_table(RareDropTable::builder()
+                            .rate(MonsterType::Hildebear, RareDropRate {
+                                rate: 1.0,
+                                item: RareDropItem::Weapon(WeaponType::DarkFlow)
+                            })
+                            .build(episode, difficulty, section_id))
+                .build(episode, difficulty, section_id)
+        }))
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;

tests/test_item_id.rs

@@ -53,9 +53,7 @@ async fn test_use_monomate_after_leaving_and_rejoining_room() {
 
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -167,9 +165,7 @@ async fn test_using_some_monomates_after_a_convoluted_series_of_leaves_and_joins
     }
     entity_gateway.set_character_inventory(&char3.id, &item::InventoryEntity::new(p3_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     log_in_char(&mut ship, ClientId(3), "a3", "a").await;
@@ -330,9 +326,7 @@ async fn test_depositing_a_full_stack_then_withdrawing_part() {
     }
     entity_gateway.set_character_bank(&char1.id, &item::BankEntity::new(vec![monomates]), &item::BankIdentifier::Character).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;

tests/test_item_pickup.rs

@@ -34,9 +34,7 @@ async fn test_pick_up_individual_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -117,9 +115,7 @@ async fn test_pick_up_item_stack_of_items_already_in_inventory() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_monomate])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -176,9 +172,7 @@ async fn test_pick_up_item_stack_of_items_not_already_held() {
 
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_monomate])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -242,9 +236,7 @@ async fn test_pick_up_meseta_when_inventory_full() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_items)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -334,9 +326,7 @@ async fn test_pick_up_partial_stacked_item_when_inventory_is_otherwise_full() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_monomates])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -412,9 +402,7 @@ async fn test_can_not_pick_up_item_when_inventory_full() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -470,9 +458,7 @@ async fn test_can_not_drop_more_meseta_than_is_held() {
 
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
 
     join_lobby(&mut ship, ClientId(1)).await;
@@ -535,9 +521,7 @@ async fn test_pick_up_stack_that_would_exceed_stack_limit() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_monomates])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_monomates])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -586,9 +570,7 @@ async fn test_can_not_pick_up_meseta_when_full() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -641,9 +623,7 @@ async fn test_meseta_caps_at_999999_when_trying_to_pick_up_more() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999998)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, item::Meseta(300)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -706,9 +686,7 @@ async fn test_player_drops_partial_stack_and_other_player_picks_it_up() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![monomates])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 

tests/test_item_use.rs

@@ -36,9 +36,7 @@ async fn test_use_monomate() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -83,9 +81,7 @@ async fn test_use_monomate_twice() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -131,9 +127,7 @@ async fn test_use_last_monomate() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -171,9 +165,7 @@ async fn test_use_nonstackable_tool() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_items)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -212,9 +204,7 @@ async fn test_use_materials() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -277,9 +267,7 @@ async fn test_jackolantern() {
             ])];
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -346,9 +334,7 @@ async fn test_use_barta_1() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -417,9 +403,7 @@ async fn test_use_monogrinder() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![item::InventoryItemEntity::Individual(saber),
                                                                                        item::InventoryItemEntity::Stacked(grinders)])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;

tests/test_mags.rs

@@ -50,9 +50,7 @@ async fn test_mag_feed() {
     inventory.push(item::InventoryItemEntity::Stacked(monomates));
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(inventory)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -105,9 +103,7 @@ async fn test_mag_change_owner() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![mag])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -191,9 +187,7 @@ async fn test_mag_cell() {
     entity_gateway.set_character_equips(&char1.id, &equipped).await.unwrap();
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![mag, mag_cell])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;

tests/test_rooms.rs

@@ -14,11 +14,10 @@ use common::*;
 async fn test_set_valid_quest_group() {
     let mut entity_gateway = InMemoryGateway::default();
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
         .standard_quest_builder(Box::new(quests::load_standard_quests))
         .government_quest_builder(Box::new(quests::load_government_quests))
-        .build());
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -36,11 +35,10 @@ async fn test_set_valid_quest_group() {
 async fn test_set_invalid_quest_group() {
     let mut entity_gateway = InMemoryGateway::default();
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
+    let mut ship = standard_ship_buildable(entity_gateway.clone())
         .standard_quest_builder(Box::new(quests::load_standard_quests))
         .government_quest_builder(Box::new(quests::load_government_quests))
-        .build());
+        .build();
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room(&mut ship, ClientId(1), "room", "").await;
@@ -63,9 +61,7 @@ async fn test_get_room_info() {
     _char1.name = String::from("GODmar");
     entity_gateway.save_character(&_char1).await.unwrap();
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -84,9 +80,7 @@ async fn test_cannot_get_room_info_after_room_is_closed() {
     let mut entity_gateway = InMemoryGateway::default();
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -106,9 +100,7 @@ async fn test_cannot_join_room_after_its_closed() {
     let mut entity_gateway = InMemoryGateway::default();
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;

tests/test_shops.rs

@@ -20,9 +20,7 @@ async fn test_player_opens_weapon_shop() {
     char1.exp = 80000000;
     entity_gateway.save_character(&char1).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -50,9 +48,7 @@ async fn test_player_opens_tool_shop() {
     char1.exp = 80000000;
     entity_gateway.save_character(&char1).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -80,9 +76,7 @@ async fn test_player_opens_armor_shop() {
     char1.exp = 80000000;
     entity_gateway.save_character(&char1).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -111,9 +105,7 @@ async fn test_player_buys_from_weapon_shop() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -149,9 +141,7 @@ async fn test_player_buys_from_tool_shop() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -186,9 +176,7 @@ async fn test_player_buys_multiple_from_tool_shop() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -227,9 +215,7 @@ async fn test_player_buys_from_armor_shop() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -280,9 +266,7 @@ async fn test_player_sells_3_attr_weapon_to_shop() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -309,9 +293,7 @@ async fn test_other_clients_see_purchase() {
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
     entity_gateway.save_character(&char1).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -360,9 +342,7 @@ async fn test_other_clients_see_stacked_purchase() {
             ),
         }).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -399,9 +379,7 @@ async fn test_buying_item_without_enough_mseseta() {
 
     let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Normal).await;
@@ -437,9 +415,7 @@ async fn test_player_double_buys_from_tool_shop() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -502,9 +478,7 @@ async fn test_techs_disappear_from_shop_when_bought() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -564,9 +538,7 @@ async fn test_units_disappear_from_shop_when_bought() {
     entity_gateway.save_character(&char1).await.unwrap();
     entity_gateway.set_character_meseta(&char1.id, item::Meseta(999999)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
     create_room_with_difficulty(&mut ship, ClientId(1), "room", "", Difficulty::Ultimate).await;
@@ -641,9 +613,7 @@ async fn test_player_sells_untekked_weapon() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -685,9 +655,7 @@ async fn test_player_sells_rare_item() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -728,9 +696,7 @@ async fn test_player_sells_partial_photon_drop_stack() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -769,9 +735,7 @@ async fn test_player_sells_basic_frame() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -810,9 +774,7 @@ async fn test_player_sells_max_frame() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -850,9 +812,7 @@ async fn test_player_sells_basic_barrier() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -890,9 +850,7 @@ async fn test_player_sells_max_barrier() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -929,9 +887,7 @@ async fn test_player_sells_1_star_minusminus_unit() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -968,9 +924,7 @@ async fn test_player_sells_5_star_plusplus_unit() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1009,9 +963,7 @@ async fn test_player_sells_rare_frame() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1049,9 +1001,7 @@ async fn test_player_sells_rare_barrier() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1088,9 +1038,7 @@ async fn test_player_sells_rare_unit() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;
@@ -1128,9 +1076,7 @@ async fn test_player_cant_sell_if_meseta_would_go_over_max() {
 
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
 
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     join_lobby(&mut ship, ClientId(1)).await;

tests/test_trade.rs

@@ -133,9 +133,7 @@ async fn test_trade_one_individual_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -234,9 +232,7 @@ async fn test_trade_player2_to_player1() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -335,9 +331,7 @@ async fn test_reverse_trade_ack_order() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -439,9 +433,7 @@ async fn test_trade_one_stacked_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -543,9 +535,7 @@ async fn test_trade_partial_stacked_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -660,9 +650,7 @@ async fn test_trade_individual_both() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -832,9 +820,7 @@ async fn test_trade_stacked_both() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1002,9 +988,7 @@ async fn test_trade_partial_stack_both() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1178,9 +1162,7 @@ async fn test_trade_same_stacked_item_to_eachother() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1350,9 +1332,7 @@ async fn test_trade_stacked_when_already_have_partial_stack() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1487,9 +1467,7 @@ async fn test_trade_individual_for_stacked() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1679,9 +1657,7 @@ async fn test_trade_multiple_individual() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -1950,9 +1926,7 @@ async fn test_trade_multiple_stacked() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack1, p1_stack2])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack1, p2_stack2])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2195,9 +2169,7 @@ async fn test_trade_not_enough_inventory_space_individual() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2313,9 +2285,7 @@ async fn test_trade_not_enough_inventory_space_stacked() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2425,9 +2395,7 @@ async fn test_trade_stack_too_big() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(vec![p2_stack])).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2506,9 +2474,7 @@ async fn test_trade_meseta() {
 
     entity_gateway.set_character_meseta(&char1.id, Meseta(2323)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2588,9 +2554,7 @@ async fn test_trade_too_much_meseta() {
     entity_gateway.set_character_meseta(&char1.id, Meseta(4000)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, Meseta(999000)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2640,9 +2604,7 @@ async fn test_trade_invalid_amount_of_meseta() {
     entity_gateway.set_character_meseta(&char1.id, Meseta(4000)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, Meseta(999000)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2692,9 +2654,7 @@ async fn test_trade_meseta_request_and_items_dont_match() {
     entity_gateway.set_character_meseta(&char1.id, Meseta(4000)).await.unwrap();
     entity_gateway.set_character_meseta(&char2.id, Meseta(999000)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2741,9 +2701,7 @@ async fn test_player_declined_trade() {
     let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a", 1).await;
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2789,9 +2747,7 @@ async fn test_back_out_of_trade_last_minute() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -2885,9 +2841,7 @@ async fn test_valid_trade_when_both_inventories_are_full() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3027,9 +2981,7 @@ async fn test_invalid_trade_when_both_inventories_are_full() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(p2_inv)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3133,9 +3085,7 @@ async fn test_client_tries_to_start_two_trades() {
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
     let (_user2, _char3) = new_user_character(&mut entity_gateway, "a3", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     log_in_char(&mut ship, ClientId(3), "a3", "a").await;
@@ -3166,9 +3116,7 @@ async fn test_client_tries_trading_with_client_already_trading() {
     let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a", 1).await;
     let (_user2, _char3) = new_user_character(&mut entity_gateway, "a3", "a", 1).await;
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
     log_in_char(&mut ship, ClientId(3), "a3", "a").await;
@@ -3223,9 +3171,7 @@ async fn test_add_then_remove_individual_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3354,9 +3300,7 @@ async fn test_add_then_remove_stacked_item() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack1, p1_stack2])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3489,9 +3433,7 @@ async fn test_add_then_remove_partial_stack() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack1, p1_stack2])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3578,9 +3520,7 @@ async fn test_add_then_remove_meseta() {
 
     entity_gateway.set_character_meseta(&char1.id, Meseta(2323)).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3679,9 +3619,7 @@ async fn test_items_to_trade_data_does_not_match() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3762,9 +3700,7 @@ async fn test_items_to_trade_id_does_not_match() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3836,9 +3772,7 @@ async fn test_stack_is_same_amount_in_request_and_items_to_trade() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -3910,9 +3844,7 @@ async fn test_stack_is_same_amount_in_request_and_items_to_trade2() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(vec![p1_stack])).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -4006,9 +3938,7 @@ async fn test_items_to_trade_count_less_than() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -4110,9 +4040,7 @@ async fn test_items_to_trade_count_greater_than() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -4218,9 +4146,7 @@ async fn test_items_to_trade_count_mismatch_with_meseta() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;
 
@@ -4295,9 +4221,7 @@ async fn test_dropping_item_after_trade() {
     entity_gateway.set_character_inventory(&char1.id, &item::InventoryEntity::new(p1_inv)).await.unwrap();
     entity_gateway.set_character_inventory(&char2.id, &item::InventoryEntity::new(Vec::<item::InventoryItemEntity>::new())).await.unwrap();
 
-    let mut ship = Box::new(ShipServerState::builder()
-        .gateway(entity_gateway.clone())
-        .build());
+    let mut ship = standard_ship(entity_gateway.clone());
     log_in_char(&mut ship, ClientId(1), "a1", "a").await;
     log_in_char(&mut ship, ClientId(2), "a2", "a").await;