all hunters are cool, not just humars

.drone.yml

@@ -1,24 +1,12 @@
 ---
 kind: pipeline
 type: docker
-name: test elseware
+name: test elseware 
 
 concurrency:
     limit: 1
 
-environment:
-  CARGO_INCREMENTAL: false
-
 steps:
-- name: clean cache
-  image: rustlang/rust:nightly
-  volumes:
-  - name: cache
-    path: /usr/local/cargo
-  - name: target-cache
-    path: /drone/src/target
-  commands:
-  - cargo prune
 - name: build
   image: rustlang/rust:nightly
   volumes:
@@ -45,7 +33,7 @@ steps:
   - name: target-cache
     path: /drone/src/target
   commands:
-  - cargo test --jobs 1
+  - cargo test
 
 volumes:
 - name: cache

Cargo.toml

@@ -2,48 +2,10 @@
 name = "elseware"
 version = "0.1.0"
 authors = ["Jake Probst <jake.probst@gmail.com>"]
-edition = "2021"
-
-[workspace]
-members = [
-    "src/client",
-    "src/drops",
-    "src/entity",
-    "src/items",
-    "src/location",
-    "src/maps",
-    "src/networking",
-    "src/pktbuilder",
-    "src/quests",
-    "src/room",
-    "src/shops",
-    "src/stats",
-    "src/trade",
-    "src/patch_server",
-    "src/login_server",
-    "src/ship_server",
-]
-
-[workspace.dependencies]
-entity = { path = "./src/entity" }
-maps = { path = "./src/maps" }
-networking = { path = "./src/networking" }
-shops = { path = "./src/shops" }
-stats = { path = "./src/stats" }
-items = { path = "./src/items" }
-pktbuilder = { path = "./src/pktbuilder" }
-quests = { path = "./src/quests" }
-location = { path = "./src/location" }
-client = { path = "./src/client" }
-drops = { path = "./src/drops" }
-trade = { path = "./src/trade" }
-room = { path = "./src/room" }
-patch_server = { path = "./src/patch_server" }
-login_server = { path = "./src/login_server" }
-ship_server = { path = "./src/ship_server" }
-
-libpso = { git = "http://git.sharnoth.com/jake/libpso", rev="90246b6" }
+edition = "2018"
 
+[dependencies]
+libpso = { git = "http://git.sharnoth.com/jake/libpso" }
 async-std = { version = "1.9.0", features = ["unstable", "attributes"] }
 futures = "0.3.5"
 rand = "0.7.3"
@@ -60,38 +22,14 @@ fern = { version = "0.5", features = ["colored"] }
 byteorder = "1"
 enum-utils = "0.1.2"
 derive_more = { version = "0.99.3", features = ["display"]}
-thiserror = "1.0.37"
+thiserror = "1.0.15"
 ages-prs = "0.1"
 async-trait = "0.1.51"
-async-recursion= "1.0.0"
 lazy_static = "1.4.0"
+barrel = { version = "0.6.5", features = ["pg"] }
 refinery = { version = "0.5.0", features = ["postgres"] }
-sqlx = { version = "0.6.2", features = ["runtime-async-std-native-tls", "postgres", "json", "chrono"] }
+sqlx = { version = "0.4.0", features = ["runtime-async-std-native-tls", "postgres", "json", "chrono"] }
 strum = "0.19.5"
 strum_macros = "0.19"
-anyhow = { version = "1.0.68", features = ["backtrace"] }
+anyhow = { version = "1.0.47", features = ["backtrace"] }
 
-[dependencies]
-entity = { workspace = true }
-maps = { workspace = true }
-networking = { workspace = true }
-patch_server = { workspace = true }
-login_server = { workspace = true }
-ship_server = { workspace = true }
-
-libpso = { workspace = true }
-
-async-std = { workspace = true }
-bcrypt = { workspace = true }
-chrono = { workspace = true }
-fern = { workspace = true }
-futures = { workspace = true }
-log = { workspace = true }
-
-[dev-dependencies]
-drops = { workspace = true }
-shops = { workspace = true }
-items = { workspace = true }
-quests = { workspace = true }
-stats = { workspace = true }
-async-trait = { workspace = true }

data/item_stats/mag_stats.toml

@@ -11,7 +11,7 @@ photon_blast = "Pilla"
 
 [Surya]
 feed_table = 3
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Vayu]
 feed_table = 4
@@ -19,7 +19,7 @@ photon_blast = "MyllaYoulla"
 
 [Varaha]
 feed_table = 4
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Kama]
 feed_table = 4
@@ -27,7 +27,7 @@ photon_blast = "Pilla"
 
 [Ushasu]
 feed_table = 4
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Apsaras]
 feed_table = 4
@@ -35,7 +35,7 @@ photon_blast = "Estlla"
 
 [Kumara]
 feed_table = 4
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Kaitabha]
 feed_table = 4
@@ -55,7 +55,7 @@ photon_blast = "Estlla"
 
 [Rudra]
 feed_table = 2
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Marutah]
 feed_table = 2
@@ -63,7 +63,7 @@ photon_blast = "Pilla"
 
 [Yaksa]
 feed_table = 5
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Sita]
 feed_table = 5
@@ -99,7 +99,7 @@ photon_blast = "Estlla"
 
 [Vritra]
 feed_table = 1
-photon_blast = "Leilla"
+photon_blast = "Golla"
 
 [Namuci]
 feed_table = 2
@@ -107,7 +107,7 @@ photon_blast = "MyllaYoulla"
 
 [Sumba]
 feed_table = 2
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Naga]
 feed_table = 6
@@ -144,7 +144,7 @@ photon_blast = "Estlla"
 
 [Naraka]
 feed_table = 6
-photon_blast = "Golla"
+photon_blast = "Leilla"
 
 [Madhu]
 feed_table = 6

src/bin/login.rs

@@ -1,8 +1,9 @@
 use log::{info};
-use entity::gateway::postgres::PostgresGateway;
-use login_server::login::LoginServerState;
-use login_server::character::CharacterServerState;
-use networking::interserver::AuthToken;
+use elseware::entity::gateway::postgres::PostgresGateway;
+use elseware::login::login::LoginServerState;
+use elseware::login::character::CharacterServerState;
+use elseware::common::mainloop::{login_mainloop, character_mainloop};
+use elseware::common::interserver::AuthToken;
 
 fn main() {
     let colors = fern::colors::ColoredLevelConfig::new()
@@ -36,23 +37,15 @@ fn main() {
     let shipgate_token = std::env::var("SHIPGATE_TOKEN").unwrap();
     let entity_gateway = PostgresGateway::new(&db_host, &db_dbname, &db_username, &db_password);
     
-    let login_state = LoginServerState::new(entity_gateway.clone(), charserv_ip);
-    let login_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_server(login_state, login_server::login::LOGIN_PORT).await;
-    });
-
+    let thread_entity_gateway = entity_gateway.clone();
+    let login_state = LoginServerState::new(thread_entity_gateway, charserv_ip);
+    let login_loop = login_mainloop(login_state, elseware::login::login::LOGIN_PORT);
+    
     let char_state = CharacterServerState::new(entity_gateway, AuthToken(shipgate_token));
-    let sub_char_state = char_state.clone();
-    let character_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_server(sub_char_state, login_server::character::CHARACTER_PORT).await;
-    });
-
-    let inter_character_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_interserver_listen(char_state, login_server::login::COMMUNICATION_PORT).await;
-    });
+    let character_loop = character_mainloop(char_state, elseware::login::character::CHARACTER_PORT, elseware::login::login::COMMUNICATION_PORT);
     
     info!("[auth/character] starting server");
     async_std::task::block_on(async move {
-        futures::future::join_all(vec![login_loop, character_loop, inter_character_loop]).await
+        futures::future::join_all(vec![login_loop, character_loop]).await
     });
 }

src/bin/main.rs

@@ -1,18 +1,19 @@
 use std::net::Ipv4Addr;
 use log::{info};
 
-use networking::interserver::AuthToken;
-use login_server::login::LoginServerState;
-use login_server::character::CharacterServerState;
-use patch_server::{PatchServerState, generate_patch_tree, load_config, load_motd};
-use ship_server::ShipServerStateBuilder;
+use elseware::patch::patch::{PatchServerState, generate_patch_tree, load_config, load_motd};
+use elseware::login::login::LoginServerState;
+use elseware::login::character::CharacterServerState;
+use elseware::ship::ship::ShipServerStateBuilder;
+use elseware::entity::account::{NewUserAccountEntity, NewUserSettingsEntity};
+#[allow(unused_imports)]
+use elseware::entity::gateway::{EntityGateway, InMemoryGateway, PostgresGateway};
+use elseware::entity::character::NewCharacterEntity;
+use elseware::entity::item::{NewItemEntity, ItemDetail, InventoryItemEntity};
+use elseware::common::interserver::AuthToken;
 
-use maps::Holiday;
-use entity::gateway::{EntityGateway, InMemoryGateway};
-use entity::account::{NewUserAccountEntity, NewUserSettingsEntity};
-use entity::character::NewCharacterEntity;
-use entity::item::{NewItemEntity, ItemDetail, InventoryItemEntity};
-use entity::item;
+use elseware::entity::item;
+use elseware::common::mainloop::*;
 
 fn setup_logger() {
     let colors = fern::colors::ColoredLevelConfig::new()
@@ -52,7 +53,7 @@ fn main() {
 
         for i in 0..5 {
             let fake_user = NewUserAccountEntity {
-                email: format!("fake{i}@email.com"),
+                email: format!("fake{}@email.com", i),
                 username: if i == 0 { "hi".to_string() } else { format!("hi{}", i+1) },
                 password: bcrypt::hash("qwer", 5).unwrap(),
                 guildcard: i + 1,
@@ -64,18 +65,18 @@ fn main() {
             };
             let fake_user = entity_gateway.create_user(fake_user).await.unwrap();
             entity_gateway.create_user_settings(NewUserSettingsEntity::new(fake_user.id)).await.unwrap();
-            let mut character = NewCharacterEntity::new(fake_user.id);
+            let mut character = NewCharacterEntity::new(fake_user.id, 1);
             character.name = format!("Test Char {}", i*2);
             let character = entity_gateway.create_character(character).await.unwrap();
             entity_gateway.set_character_meseta(&character.id, item::Meseta(999999)).await.unwrap();
-            entity_gateway.set_bank_meseta(&character.id, &item::BankIdentifier::Character, item::Meseta(999999)).await.unwrap();
-            let mut character = NewCharacterEntity::new(fake_user.id);
+            entity_gateway.set_bank_meseta(&character.id, item::BankName("".into()), item::Meseta(999999)).await.unwrap();
+            let mut character = NewCharacterEntity::new(fake_user.id, 1);
             character.slot = 2;
             character.name = "ItemRefactor".into();
             character.exp = 80000000;
             let character = entity_gateway.create_character(character).await.unwrap();
             entity_gateway.set_character_meseta(&character.id, item::Meseta(999999)).await.unwrap();
-            entity_gateway.set_bank_meseta(&character.id, &item::BankIdentifier::Character, item::Meseta(999999)).await.unwrap();
+            entity_gateway.set_bank_meseta(&character.id, item::BankName("".into()), item::Meseta(999999)).await.unwrap();
 
             for _ in 0..3 {
                 entity_gateway.create_item(
@@ -324,91 +325,56 @@ fn main() {
             };
             entity_gateway.set_character_equips(&character.id, &equipped).await.unwrap();
 
-            let inventory = item::InventoryEntity::new(vec![InventoryItemEntity::from(item0), item1.into(), item2_w.into(), item3.into(),
-                                                            item4.into(), item5_m.into(), item6.into(), item6_1.into(), item7_a.into(),
-                                                            item8_s.into(), item9_u0.into(), item10_u1.into(), item11_u2.into(), item12_u3.into(),
-                                                            item13.into(), item14.into(), monomates.into()]);
+            let inventory = item::InventoryEntity::new(vec![InventoryItemEntity::from(item0), item1.into(), item2_w.into(), item3.into(), item4.into(), item5_m.into(), item6.into(), item6_1.into(), item7_a.into(), item8_s.into(), item9_u0.into(), item10_u1.into(), item11_u2.into(), item12_u3.into(), item13.into(), item14.into(), monomates.into()]);
             entity_gateway.set_character_inventory(&character.id, &inventory).await.unwrap();
-            entity_gateway.set_character_bank(&character.id, &item::BankEntity::default(), &item::BankIdentifier::Character).await.unwrap();
+            entity_gateway.set_character_bank(&character.id, &item::BankEntity::default(), item::BankName("".into())).await.unwrap();
         }
 
         info!("[patch] starting server");
         let patch_config = load_config();
         let patch_motd = load_motd();
         let (patch_file_tree, patch_file_lookup) = generate_patch_tree(patch_config.path.as_str());
-        let patch_state = PatchServerState::new(patch_file_tree, patch_file_lookup, patch_motd);
-        let patch_loop = async_std::task::spawn(async move {
-            networking::mainloop::run_server(patch_state, patch_config.port).await;
-        });
+        let patch_state = Box::new(PatchServerState::new(patch_file_tree, patch_file_lookup, patch_motd));
+        let patch_loop = patch_mainloop(*patch_state, patch_config.port);
 
+        let thread_entity_gateway = entity_gateway.clone();
         info!("[auth] starting server");
-        let login_state = LoginServerState::new(entity_gateway.clone(), "127.0.0.1".parse().unwrap());
-        let login_loop = async_std::task::spawn(async move {
-            networking::mainloop::run_server(login_state, login_server::login::LOGIN_PORT).await;
-        });
+        let login_state = Box::new(LoginServerState::new(thread_entity_gateway, "127.0.0.1".parse().unwrap()));
+        let login_loop = login_mainloop(*login_state, elseware::login::login::LOGIN_PORT);
 
+        let thread_entity_gateway = entity_gateway.clone();
         info!("[character] starting server");
-        let char_state = CharacterServerState::new(entity_gateway.clone(), AuthToken("".into()));
-        let sub_char_state = char_state.clone();
-        let character_loop = async_std::task::spawn(async move {
-            networking::mainloop::run_server(sub_char_state, login_server::character::CHARACTER_PORT).await;
-        });
+        let char_state = Box::new(CharacterServerState::new(thread_entity_gateway, AuthToken("".into())));
+        let character_loop = character_mainloop(*char_state, elseware::login::character::CHARACTER_PORT, elseware::login::login::COMMUNICATION_PORT);
 
-        let sub_char_state = char_state.clone();
-        let inter_character_loop = async_std::task::spawn(async move {
-            networking::mainloop::run_interserver_listen(sub_char_state, login_server::login::COMMUNICATION_PORT).await;
-        });
-
-        info!("[ship] starting servers");
-        let ship_state = ShipServerStateBuilder::default()
+        let thread_entity_gateway = entity_gateway.clone();
+        info!("[ship] starting server");
+        let ship_state = Box::new(ShipServerStateBuilder::default()
             .name("US/Sona-Nyl".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT)
-            .event(Holiday::Halloween)
-            .gateway(entity_gateway.clone())
-            .build();
-        let sub_ship_state = ship_state.clone();
-        let ship_loop1 = async_std::task::spawn(async move {
-            networking::mainloop::run_server(sub_ship_state, ship_server::SHIP_PORT).await;
-        });
-        let sub_ship_state = ship_state.clone();
-        let inter_ship_loop1 = async_std::task::spawn(async move {
-            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
-        });
+            .port(elseware::ship::ship::SHIP_PORT)
+            .gateway(thread_entity_gateway)
+            .build());
+        let ship_loop = ship_mainloop(*ship_state, elseware::ship::ship::SHIP_PORT, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT);
 
-        let ship_state = ShipServerStateBuilder::default()
+        let thread_entity_gateway = entity_gateway.clone();
+        let ship_state = Box::new(ShipServerStateBuilder::default()
             .name("EU/Dylath-Leen".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT+2000)
-            .event(Holiday::Christmas)
-            .gateway(entity_gateway.clone())
-            .build();
-        let sub_ship_state = ship_state.clone();
-        let ship_loop2 = async_std::task::spawn(async move {
-            networking::mainloop::run_server(sub_ship_state, ship_server::SHIP_PORT+2000).await;
-        });
-        let sub_ship_state = ship_state.clone();
-        let inter_ship_loop2 = async_std::task::spawn(async move {
-            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
-        });
+            .port(elseware::ship::ship::SHIP_PORT+2000)
+            .gateway(thread_entity_gateway)
+            .build());
+        let ship_loop2 = ship_mainloop(*ship_state, elseware::ship::ship::SHIP_PORT+2000, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT);
 
-        let ship_state = ShipServerStateBuilder::default()
+        let thread_entity_gateway = entity_gateway.clone();
+        let ship_state = Box::new(ShipServerStateBuilder::default()
             .name("JP/Thalarion".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT+3000)
-            .gateway(entity_gateway.clone())
-            .build();
-        let sub_ship_state = ship_state.clone();
-        let ship_loop3 = async_std::task::spawn(async move {
-            networking::mainloop::run_server(sub_ship_state, ship_server::SHIP_PORT+3000).await;
-        });
-        let sub_ship_state = ship_state.clone();
-        let inter_ship_loop3 = async_std::task::spawn(async move {
-            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
-        });
+            .port(elseware::ship::ship::SHIP_PORT+3000)
+            .gateway(thread_entity_gateway)
+            .build());
+        let ship_loop3 = ship_mainloop(*ship_state, elseware::ship::ship::SHIP_PORT+3000, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT);
 
-        futures::future::join_all(vec![patch_loop, login_loop, character_loop, inter_character_loop,
-                                       ship_loop1, ship_loop2, ship_loop3,
-                                       inter_ship_loop1, inter_ship_loop2, inter_ship_loop3]).await;
+        futures::future::join_all(vec![patch_loop, login_loop, character_loop, ship_loop, ship_loop2, ship_loop3]).await;
     });
 }

src/bin/patch.rs

@@ -1,5 +1,6 @@
-use patch_server::{PatchServerState, generate_patch_tree, load_config_env, load_motd};
-use log::info;
+use elseware::patch::patch::{PatchServerState, generate_patch_tree, load_config_env, load_motd};
+use log::{info};
+use elseware::common::mainloop::patch_mainloop;
 
 fn main() {
     info!("[patch] starting server");
@@ -7,10 +8,9 @@ fn main() {
     let patch_motd = load_motd();
     let (patch_file_tree, patch_file_lookup) = generate_patch_tree(patch_config.path.as_str());
     let patch_state = PatchServerState::new(patch_file_tree, patch_file_lookup, patch_motd);
+    let patch_loop = patch_mainloop(patch_state, patch_config.port);
 
-    let patch_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_server(patch_state, patch_config.port).await;
+    async_std::task::block_on(async move {
+        patch_loop.await
     });
-
-    async_std::task::block_on(patch_loop);
 }

src/bin/ship.rs

@@ -1,7 +1,8 @@
-use log::info;
-use entity::gateway::postgres::PostgresGateway;
-use ship_server::ShipServerStateBuilder;
-use networking::interserver::AuthToken;
+use log::{info};
+use elseware::entity::gateway::postgres::PostgresGateway;
+use elseware::ship::ship::ShipServerStateBuilder;
+use elseware::common::mainloop::ship_mainloop;
+use elseware::common::interserver::AuthToken;
 
 fn main() {
     let colors = fern::colors::ColoredLevelConfig::new()
@@ -36,27 +37,19 @@ fn main() {
     let shipgate_token = std::env::var("SHIPGATE_TOKEN").unwrap();
     let ship_name = std::env::var("SHIP_NAME").unwrap().parse().unwrap();
     let ip = std::env::var("SELF_IP").unwrap().parse().unwrap();
-
     let ship_state = ShipServerStateBuilder::default()
         .name(ship_name)
         .ip(ip)
-        .port(ship_server::SHIP_PORT)
+        .port(elseware::ship::ship::SHIP_PORT)
         .gateway(entity_gateway)
         .auth_token(AuthToken(shipgate_token))
         .build();
 
     let shipgate_ip = std::env::var("SHIPGATE_IP").unwrap().parse().unwrap();
-
-    let sub_ship_state = ship_state.clone();
-    let ship_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_server(sub_ship_state, ship_server::SHIP_PORT).await;
-    });
-    let inter_ship_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_interserver_connect(ship_state, shipgate_ip, login_server::login::COMMUNICATION_PORT).await;
-    });
-
+    let ship_loop = ship_mainloop(ship_state, elseware::ship::ship::SHIP_PORT, shipgate_ip, elseware::login::login::COMMUNICATION_PORT);
+    
     info!("[auth/character] starting server");
     async_std::task::block_on(async move {
-        futures::future::join_all(vec![ship_loop, inter_ship_loop]).await;
+        ship_loop.await
     });
 }

src/client/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "client"
-version = "0.1.0"
-edition = "2021"
-
-
-[dependencies]
-entity = { workspace = true }
-maps = { workspace = true }
-networking = { workspace = true }
-shops = { workspace = true }
-items = { workspace = true }
-
-libpso = { workspace = true }
-
-async-std = { workspace = true }
-futures = { workspace = true }
-anyhow = { workspace = true }
-thiserror = { workspace = true }
-chrono = { workspace = true }

src/client/src/lib.rs

@@ -1,174 +0,0 @@
-use std::collections::HashMap;
-use async_std::sync::{Arc, RwLock, RwLockReadGuard};
-
-use futures::future::BoxFuture;
-
-use libpso::packet::ship::*;
-use libpso::packet::login::Session;
-
-use networking::serverstate::ClientId;
-use entity::account::{UserAccountEntity, UserSettingsEntity};
-use entity::character::CharacterEntity;
-use entity::item;
-
-use maps::area::MapArea;
-use shops::{WeaponShopItem, ToolShopItem, ArmorShopItem};
-
-
-#[derive(thiserror::Error, Debug)]
-pub enum ClientError {
-    #[error("not found {0}")]
-    NotFound(ClientId),
-}
-
-
-#[derive(Clone, Default)]
-pub struct Clients(Arc<RwLock<HashMap<ClientId, RwLock<ClientState>>>>);
-
-impl Clients {
-    pub async fn add(&mut self, client_id: ClientId, client_state: ClientState) {
-        self.0
-            .write()
-            .await
-            .insert(client_id, RwLock::new(client_state));
-    }
-
-    pub async fn remove(&mut self, client_id: &ClientId) -> Option<ClientState> {
-        Some(self.0
-            .write()
-            .await
-            .remove(client_id)?
-            .into_inner())
-    }
-
-    pub async fn with<'a, T, F>(&'a self, client_id: ClientId, func: F) -> Result<T, anyhow::Error>
-    where
-        T: Send,
-        F: for<'b> FnOnce(&'b ClientState) -> BoxFuture<'b, T> + Send + 'a,
-    {
-        let clients = self.0
-            .read()
-            .await;
-        let client = clients
-            .get(&client_id)
-            .ok_or(ClientError::NotFound(client_id))?
-            .read()
-            .await;
-
-        Ok(func(&client).await)
-    }
-
-    pub async fn with_many<'a, T, F, const N: usize>(&'a self, client_ids: [ClientId; N], func: F) -> Result<T, anyhow::Error>
-    where
-        T: Send,
-        F: for<'b> FnOnce([RwLockReadGuard<'b, ClientState>; N]) -> BoxFuture<'b, T> + Send + 'a,
-    {
-        let clients = self.0
-            .read()
-            .await;
-        
-        let mut client_states: [std::mem::MaybeUninit<RwLockReadGuard<ClientState>>; N] = unsafe {
-            std::mem::MaybeUninit::uninit().assume_init()
-        };
-
-        for (cindex, client_id) in client_ids.iter().enumerate() {
-            let c = clients
-                .get(client_id)
-                .ok_or(ClientError::NotFound(*client_id))?
-                .read()
-                .await;
-            client_states[cindex].write(c);
-        }
-        
-        let client_states = unsafe {
-            std::mem::transmute_copy(&client_states)
-        };
-
-        Ok(func(client_states).await)
-    }
-
-    pub async fn with_mut<'a, T, F>(&'a self, client_id: ClientId, func: F) -> Result<T, anyhow::Error>
-    where
-        T: Send,
-        F: for<'b> FnOnce(&'b mut ClientState) -> BoxFuture<'b, T> + Send + 'a,
-    {
-        let clients = self.0
-            .read()
-            .await;
-        let mut client = clients
-            .get(&client_id)
-            .ok_or(ClientError::NotFound(client_id))?
-            .write()
-            .await;
-
-        Ok(func(&mut client).await)
-    }
-}
-
-
-#[derive(Debug, Clone, Copy)]
-pub struct ItemDropLocation {
-    pub map_area: MapArea,
-    pub x: f32,
-    pub z: f32,
-    pub item_id: items::ClientItemId,
-}
-
-pub struct LoadingQuest {
-    pub header_bin: Option<QuestHeader>,
-    pub header_dat: Option<QuestHeader>,
-}
-
-
-pub struct ClientState {
-    pub user: UserAccountEntity,
-    pub settings: UserSettingsEntity,
-    pub character: CharacterEntity,
-    _session: Session,
-    //guildcard: GuildCard,
-    pub block: usize,
-    pub item_drop_location: Option<ItemDropLocation>,
-    pub done_loading_quest: bool,
-    pub area: Option<MapArea>,
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-    pub weapon_shop: Vec<WeaponShopItem>,
-    pub tool_shop: Vec<ToolShopItem>,
-    pub armor_shop: Vec<ArmorShopItem>,
-    pub tek: Option<(items::ClientItemId, item::weapon::TekSpecialModifier, item::weapon::TekPercentModifier, i32)>,
-    pub character_playtime: chrono::Duration,
-    pub log_on_time: chrono::DateTime<chrono::Utc>,
-}
-
-impl ClientState {
-    pub fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, session: Session) -> ClientState {
-        let character_playtime = chrono::Duration::seconds(character.playtime as i64);
-        ClientState {
-            user,
-            settings,
-            character,
-            _session: session,
-            block: 0,
-            item_drop_location: None,
-            done_loading_quest: false,
-            area: None,
-            x: 0.0,
-            y: 0.0,
-            z: 0.0,
-            weapon_shop: Vec::new(),
-            tool_shop: Vec::new(),
-            armor_shop: Vec::new(),
-            tek: None,
-            character_playtime,
-            log_on_time: chrono::Utc::now(),
-        }
-    }
-
-    pub fn update_playtime(&mut self) {
-        let additional_playtime = chrono::Utc::now() - self.log_on_time;
-        self.character.playtime = (self.character_playtime + additional_playtime).num_seconds() as u32;
-    }
-}
-
-

src/common/interserver.rs

@@ -1,9 +1,8 @@
 use std::net::Ipv4Addr;
-use async_std::channel;
 use serde::{Serialize, Deserialize};
 use serde::de::DeserializeOwned;
-use entity::account::UserAccountId;
-use entity::character::CharacterEntityId;
+use crate::entity::account::UserAccountId;
+use crate::entity::character::CharacterEntityId;
 
 #[derive(Debug, Copy, Clone, Serialize, Deserialize, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ServerId(pub usize);
@@ -47,13 +46,12 @@ pub enum ShipMessage {
 
 
 #[async_trait::async_trait]
-pub trait InterserverActor: Clone {
+pub trait InterserverActor {
     type SendMessage: Serialize;
     type RecvMessage: DeserializeOwned;
     type Error;
 
     async fn on_connect(&mut self, id: ServerId) -> Vec<(ServerId, Self::SendMessage)>;
-    async fn on_action(&mut self, id: ServerId, msg: Self::RecvMessage) -> Result<Vec<(ServerId, Self::SendMessage)>, Self::Error>;
+    async fn action(&mut self, id: ServerId, msg: Self::RecvMessage) -> Result<Vec<(ServerId, Self::SendMessage)>, Self::Error>;
     async fn on_disconnect(&mut self, id: ServerId) -> Vec<(ServerId, Self::SendMessage)>;
-    async fn set_sender(&mut self, server_id: ServerId, tx: channel::Sender<Self::SendMessage>);
 }

src/common/leveltable.rs

@@ -1,11 +1,9 @@
+use std::collections::HashMap;
 use std::fs::File;
 use serde_json::Value;
-use entity::character::CharacterClass;
-use std::sync::LazyLock;
+use crate::entity::character::CharacterClass;
 
-pub static LEVEL_TABLE: LazyLock<CharacterLevelTable> = LazyLock::new(CharacterLevelTable::default);
-
-#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Default, Copy, Clone, Debug, PartialEq)]
 pub struct CharacterStats {
     pub hp: u16,
     pub atp: u16,
@@ -29,14 +27,14 @@ struct CharacterLevelEntry {
 }
 
 pub struct CharacterLevelTable {
-    table: Box<[[CharacterLevelEntry; 200]; 12]>,
+    table: HashMap<CharacterClass, [CharacterLevelEntry; 200]>,
 }
 
 impl Default for CharacterLevelTable {
     fn default() -> CharacterLevelTable {
         let file = File::open("data/char_stats.json").unwrap();
         let json: Value = serde_json::from_reader(file).unwrap();
-        let mut table = Box::new([[CharacterLevelEntry::default(); 200]; 12]);
+        let mut table = HashMap::new();
 
         for it in json.as_object().unwrap().iter(){
             let cl = match it.0.as_str() {
@@ -69,7 +67,7 @@ impl Default for CharacterLevelTable {
                 }
             }
 
-            table[u8::from(cl) as usize] = statlist;
+            table.insert(cl, statlist);
         }
 
         CharacterLevelTable {
@@ -80,7 +78,7 @@ impl Default for CharacterLevelTable {
 
 impl CharacterLevelTable {
     pub fn get_level_from_exp(&self, ch_class: CharacterClass, exp: u32) -> u32 {
-        if let Some(statlist) = self.table.get(u8::from(ch_class) as usize) {
+        if let Some(statlist) = self.table.get(&ch_class) {
             statlist
                 .iter()
                 .filter(|stat| {
@@ -94,7 +92,7 @@ impl CharacterLevelTable {
     }
 
     pub fn get_stats_from_exp(&self, ch_class: CharacterClass, exp: u32) -> (u32, CharacterStats) {
-        if let Some(statlist) = self.table.get(u8::from(ch_class) as usize) {
+        if let Some(statlist) = self.table.get(&ch_class) {
             statlist
                 .iter()
                 .filter(|stat| {

src/common/mainloop/client.rs

@@ -0,0 +1,317 @@
+use std::pin::Pin;
+use futures::future::Future;
+use log::{trace, info, warn};
+use async_std::sync::{Arc, Mutex};
+use async_std::io::prelude::{ReadExt, WriteExt};
+use std::collections::HashMap;
+
+use libpso::crypto::{PSOCipher, NullCipher, CipherError};
+use libpso::PacketParseError;
+use crate::common::serverstate::ClientId;
+use crate::common::serverstate::{RecvServerPacket, SendServerPacket, ServerState, OnConnect};
+
+
+#[derive(Debug)]
+pub enum NetworkError {
+    CouldNotSend,
+    CipherError(CipherError),
+    PacketParseError(PacketParseError),
+    IOError(std::io::Error),
+    DataNotReady,
+    ClientDisconnected,
+}
+
+impl From<CipherError> for NetworkError {
+    fn from(err: CipherError) -> NetworkError {
+        NetworkError::CipherError(err)
+    }
+}
+
+impl From<std::io::Error> for NetworkError {
+    fn from(err: std::io::Error) -> NetworkError {
+        NetworkError::IOError(err)
+    }
+}
+
+impl From<PacketParseError> for NetworkError {
+    fn from(err: PacketParseError) -> NetworkError {
+        NetworkError::PacketParseError(err)
+    }
+}
+
+struct PacketReceiver {
+    socket: Arc<async_std::net::TcpStream>,
+    cipher: Arc<Mutex<Box<dyn PSOCipher + Send>>>,
+    recv_buffer: Vec<u8>,
+    incoming_data: Vec<u8>,
+}
+
+impl PacketReceiver {
+    fn new(socket: Arc<async_std::net::TcpStream>, cipher: Arc<Mutex<Box<dyn PSOCipher + Send>>>) -> PacketReceiver {
+        PacketReceiver {
+            socket,
+            cipher,
+            recv_buffer: Vec::new(),
+            incoming_data: Vec::new(),
+        }
+    }
+
+    async fn fill_recv_buffer(&mut self) -> Result<(), NetworkError> {
+        let mut data = [0u8; 0x8000];
+
+        let mut socket = &*self.socket;
+        let len = socket.read(&mut data).await?;
+        if len == 0 {
+            return Err(NetworkError::ClientDisconnected);
+        }
+
+        self.recv_buffer.extend_from_slice(&data[..len]);
+
+        let mut dec_buf = {
+            let mut cipher = self.cipher.lock().await;
+            let block_chunk_len = self.recv_buffer.len() / cipher.block_size() * cipher.block_size();
+            let buf = self.recv_buffer.drain(..block_chunk_len).collect();
+            cipher.decrypt(&buf)?
+        };
+        self.incoming_data.append(&mut dec_buf);
+
+        Ok(())
+    }
+
+    async fn recv_pkts<R: RecvServerPacket + Send + std::fmt::Debug>(&mut self) -> Result<Vec<R>, NetworkError> {
+        self.fill_recv_buffer().await?;
+
+        let mut result = Vec::new();
+        loop {
+            if self.incoming_data.len() < 2 {
+                break;
+            }
+            let pkt_size = u16::from_le_bytes([self.incoming_data[0], self.incoming_data[1]]) as usize;
+            let mut pkt_len = pkt_size;
+            while pkt_len % self.cipher.lock().await.block_size() != 0 {
+                pkt_len += 1;
+            }
+
+            if pkt_len > self.incoming_data.len() {
+                break;
+            }
+
+            let pkt_data = self.incoming_data.drain(..pkt_len).collect::<Vec<_>>();
+
+            trace!("[recv buf] {:?}", pkt_data);
+            let pkt = match R::from_bytes(&pkt_data[..pkt_size]) {
+                Ok(p) => p,
+                Err(err) => {
+                    warn!("error RecvServerPacket::from_bytes: {:?}", err);
+                    continue
+                },
+            };
+
+            result.push(pkt);
+        }
+
+        Ok(result)
+    }
+}
+
+async fn send_pkt<S: SendServerPacket + Send + std::fmt::Debug>(socket: Arc<async_std::net::TcpStream>,
+                                                                cipher: Arc<Mutex<Box<dyn PSOCipher + Send>>>, pkt: S)
+                                                                -> Result<(), NetworkError>
+{
+    let buf = pkt.as_bytes();
+    trace!("[send buf] {:?}", buf);
+    let cbuf = cipher.lock().await.encrypt(&buf)?;
+    let mut ssock = &*socket;
+    ssock.write_all(&cbuf).await?;
+    Ok(())
+}
+
+
+enum ClientAction<S, R> {
+    NewClient(ClientId, async_std::channel::Sender<S>),
+    Packet(ClientId, R),
+    Disconnect(ClientId),
+}
+
+enum ServerStateAction<S> {
+    Cipher(Box<dyn PSOCipher + Send + Sync>, Box<dyn PSOCipher + Send + Sync>),
+    Packet(S),
+    Disconnect,
+}
+
+fn client_recv_loop<S, R>(client_id: ClientId,
+                                socket: Arc<async_std::net::TcpStream>,
+                                cipher: Arc<Mutex<Box<dyn PSOCipher + Send>>>,
+                                server_sender: async_std::channel::Sender<ClientAction<ServerStateAction<S>, R>>,
+                                client_sender: async_std::channel::Sender<ServerStateAction<S>>)
+where
+    S: SendServerPacket + std::fmt::Debug + Send + 'static,
+    R: RecvServerPacket + std::fmt::Debug + Send + 'static,
+{
+    async_std::task::spawn(async move {
+        server_sender.send(ClientAction::NewClient(client_id, client_sender)).await.unwrap();
+        let mut pkt_receiver = PacketReceiver::new(socket, cipher);
+
+        loop {
+            match pkt_receiver.recv_pkts().await {
+                Ok(pkts) => {
+                    for pkt in pkts {
+                        info!("[recv from {:?}] {:?}", client_id, pkt);
+                        server_sender.send(ClientAction::Packet(client_id, pkt)).await.unwrap();
+                    }
+                },
+                Err(err) => {
+                    match err {
+                        NetworkError::ClientDisconnected => {
+                            trace!("[client disconnected] {:?}", client_id);
+                            server_sender.send(ClientAction::Disconnect(client_id)).await.unwrap();
+                            break;
+                        }
+                        _ => {
+                            warn!("[client {:?} recv error] {:?}", client_id, err);
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+
+fn client_send_loop<S>(client_id: ClientId,
+                             socket: Arc<async_std::net::TcpStream>,
+                             cipher_in: Arc<Mutex<Box<dyn PSOCipher + Send>>>,
+                             cipher_out: Arc<Mutex<Box<dyn PSOCipher + Send>>>,
+                             client_receiver: async_std::channel::Receiver<ServerStateAction<S>>)
+where
+    S: SendServerPacket + std::fmt::Debug + Send + 'static,
+{
+    async_std::task::spawn(async move {
+        loop {
+            let action = client_receiver.recv().await.unwrap();
+            match action {
+                ServerStateAction::Cipher(inc, outc) => {
+                    *cipher_in.lock().await = inc;
+                    *cipher_out.lock().await = outc;
+                }
+                ServerStateAction::Packet(pkt) => {
+                    info!("[send to {:?}] {:?}", client_id, pkt);
+                    if let Err(err) = send_pkt(socket.clone(), cipher_out.clone(), pkt).await {
+                        warn!("[client {:?} send error ] {:?}", client_id, err);
+                    }
+                },
+                ServerStateAction::Disconnect => {
+                    break;
+                }
+            };
+        }
+    });
+}
+
+fn state_client_loop<STATE, S, R, E>(state: Arc<Mutex<STATE>>,
+                                           server_state_receiver: async_std::channel::Receiver<ClientAction<ServerStateAction<S>, R>>) where
+    STATE: ServerState<SendPacket=S, RecvPacket=R, PacketError=E> + Send + 'static,
+    S: SendServerPacket + std::fmt::Debug + Send + 'static,
+    R: RecvServerPacket + std::fmt::Debug + Send + 'static,
+    E: std::fmt::Debug + Send,
+{
+    async_std::task::spawn(async move {
+        let mut clients = HashMap::new();
+
+        loop {
+            let action = server_state_receiver.recv().await.unwrap();
+            let mut state = state.lock().await;
+
+            match action {
+                ClientAction::NewClient(client_id, sender) => {
+                    let actions = state.on_connect(client_id).await;
+                    match actions {
+                        Ok(actions) => {
+                            for action in actions {
+                                match action {
+                                    OnConnect::Cipher((inc, outc)) => {
+                                        sender.send(ServerStateAction::Cipher(inc, outc)).await.unwrap();
+                                    },
+                                    OnConnect::Packet(pkt) => {
+                                        sender.send(ServerStateAction::Packet(pkt)).await.unwrap();
+                                    }
+                                }
+                            }
+                        },
+                        Err(err) => {
+                            warn!("[client {:?} state on_connect error] {:?}", client_id, err);
+                        }
+                    }
+                    clients.insert(client_id, sender);
+                },
+                ClientAction::Packet(client_id, pkt) => {
+                    let pkts = state.handle(client_id, &pkt).await;
+                    match pkts {
+                        Ok(pkts) => {
+                            for (client_id, pkt) in pkts {
+                                if let Some(client) = clients.get_mut(&client_id) {
+                                    client.send(ServerStateAction::Packet(pkt)).await.unwrap();
+                                }
+                            }
+                        },
+                        Err(err) => {
+                            warn!("[client {:?} state handler error] {:?}", client_id, err);
+                        }
+                    }
+                },
+                ClientAction::Disconnect(client_id) => {
+                    let pkts = state.on_disconnect(client_id).await;
+                    match pkts {
+                        Ok(pkts) => {
+                            for (client_id, pkt) in pkts {
+                                if let Some(client) = clients.get_mut(&client_id) {
+                                    client.send(ServerStateAction::Packet(pkt)).await.unwrap();
+                                }
+                            }
+
+                            if let Some(client) = clients.get_mut(&client_id) {
+                                client.send(ServerStateAction::Disconnect).await.unwrap();
+                            }
+                        }
+                        Err(err) => {
+                            warn!("[client {:?} state on_disconnect error] {:?}", client_id, err);
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+
+
+pub fn client_accept_mainloop<STATE, S, R, E>(state: Arc<Mutex<STATE>>, client_port: u16) -> Pin<Box<dyn Future<Output = ()>>>
+where
+    STATE: ServerState<SendPacket=S, RecvPacket=R, PacketError=E> + Send + 'static,
+    S: SendServerPacket + std::fmt::Debug + Send + Sync + 'static,
+    R: RecvServerPacket + std::fmt::Debug + Send + Sync + 'static,
+    E: std::fmt::Debug + Send,
+{
+    Box::pin(async_std::task::spawn(async move {
+        let listener = async_std::net::TcpListener::bind(&std::net::SocketAddr::from((std::net::Ipv4Addr::new(0,0,0,0), client_port))).await.unwrap();
+        let mut id = 0;
+
+        let (server_state_sender, server_state_receiver) = async_std::channel::bounded(1024);
+        state_client_loop(state, server_state_receiver);
+
+        loop {
+            let (sock, addr) = listener.accept().await.unwrap();
+            id += 1;
+            let client_id = crate::common::serverstate::ClientId(id);
+
+            info!("new client {:?} {:?} {:?}", client_id, sock, addr);
+
+            let (client_sender, client_receiver) = async_std::channel::bounded(64);
+            let socket = Arc::new(sock);
+            let cipher_in: Arc<Mutex<Box<dyn PSOCipher + Send>>> = Arc::new(Mutex::new(Box::new(NullCipher {})));
+            let cipher_out: Arc<Mutex<Box<dyn PSOCipher + Send>>> = Arc::new(Mutex::new(Box::new(NullCipher {})));
+
+            client_recv_loop(client_id, socket.clone(), cipher_in.clone(), server_state_sender.clone(), client_sender);
+            client_send_loop(client_id, socket.clone(), cipher_in.clone(), cipher_out.clone(), client_receiver);
+        }
+    }))
+}
+

src/common/mainloop/interserver.rs

@@ -0,0 +1,260 @@
+use std::time::Duration;
+use std::pin::Pin;
+use futures::future::Future;
+use log::{info, warn};
+use async_std::sync::{Arc, Mutex};
+use async_std::io::prelude::{ReadExt, WriteExt};
+use std::collections::HashMap;
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+
+use crate::common::interserver::{ServerId, InterserverActor};
+
+use crate::login::character::CharacterServerState;
+use crate::ship::ship::ShipServerState;
+use crate::entity::gateway::entitygateway::EntityGateway;
+
+#[derive(Debug)]
+enum MessageReceiverError {
+    //InvalidSize,
+    InvalidPayload,
+    //NetworkError(std::io::Error),
+    Disconnected,
+}
+
+struct MessageReceiver {
+    socket: async_std::net::TcpStream,
+}
+
+impl MessageReceiver {
+    fn new(socket: async_std::net::TcpStream) -> MessageReceiver {
+        MessageReceiver {
+            socket,
+        }
+    }
+
+    async fn recv<R: DeserializeOwned + std::fmt::Debug + Send>(&mut self) -> Result<R, MessageReceiverError> {
+        let mut size_buf = [0u8; 4];
+        self.socket.read_exact(&mut size_buf).await.map_err(|_| MessageReceiverError::Disconnected)?;
+        let size = u32::from_le_bytes(size_buf) as usize;
+
+        let mut payload = vec![0u8; size];
+        self.socket.read_exact(&mut payload).await.map_err(|_| MessageReceiverError::Disconnected)?;
+        let payload = String::from_utf8(payload).map_err(|_| MessageReceiverError::InvalidPayload)?;
+
+        let msg = serde_json::from_str(&payload).map_err(|_| MessageReceiverError::InvalidPayload)?;
+        Ok(msg)
+    }
+}
+
+#[derive(Debug)]
+enum InterserverInputAction<S, R> {
+    NewConnection(ServerId, async_std::channel::Sender<S>),
+    Message(ServerId, R),
+    Disconnect(ServerId),
+}
+
+async fn interserver_state_loop<A, S, R>(state: Arc<Mutex<A>>, action_receiver: async_std::channel::Receiver<InterserverInputAction<S, R>>)
+where
+    A: InterserverActor<SendMessage=S, RecvMessage=R, Error=()> + Send + 'static,
+    S: Serialize + Send + 'static,
+    R: DeserializeOwned + Send + 'static,
+{
+    async_std::task::spawn(async move {
+        let mut ships = HashMap::new();
+
+        loop {
+            info!("interserver loop");
+            let action = match action_receiver.recv().await {
+                Ok(action) => action,
+                Err(err) => {
+                    warn!("error in iterserver state loop {:?}", err);
+                    continue;
+                }
+            };
+            let mut state = state.lock().await;
+
+            match action {
+                InterserverInputAction::NewConnection(server_id, ship_action_sender) => {
+                    ships.insert(server_id, ship_action_sender);
+                    for (server, action) in state.on_connect(server_id).await {
+                        if let Some(sender) = ships.get_mut(&server) { 
+                            sender.send(action).await.unwrap();
+                        }
+                    }
+                },
+                InterserverInputAction::Message(server_id, message) => {
+                    let actions = state.action(server_id, message).await;
+                    match actions {
+                        Ok(actions) => {
+                            for (server, action) in actions{
+                                if let Some(sender) = ships.get_mut(&server) {
+                                    sender.send(action).await.unwrap();
+                                }
+                            }
+                        },
+                        Err(err) => {
+                            warn!("[server {:?} state handler error] {:?}", server_id, err);
+                        }
+                    }
+                },
+                InterserverInputAction::Disconnect(server_id) => {
+                    let actions = state.on_disconnect(server_id).await;
+                    ships.remove(&server_id);
+                    for (server, action) in actions {
+                        if let Some(sender) = ships.get_mut(&server) {
+                            sender.send(action).await.unwrap();
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+
+async fn login_recv_loop<S, R>(server_id: ServerId,
+                               socket: async_std::net::TcpStream,
+                               state_loop_sender: async_std::channel::Sender<InterserverInputAction<S, R>>,
+                               output_loop_sender: async_std::channel::Sender<S>)
+where
+    S: Serialize + std::fmt::Debug + Send + 'static,
+    R: DeserializeOwned + std::fmt::Debug + Send + 'static,
+{
+    async_std::task::spawn(async move {
+        state_loop_sender.send(InterserverInputAction::NewConnection(server_id, output_loop_sender)).await.unwrap();
+        let mut msg_receiver = MessageReceiver::new(socket);
+
+        loop {
+            info!("login recv loop");
+            match msg_receiver.recv().await {
+                Ok(msg) => {
+                    info!("[login recv loop msg] {:?}", msg);
+                    state_loop_sender.send(InterserverInputAction::Message(server_id, msg)).await.unwrap();
+                },
+                Err(err) => {
+                    if let MessageReceiverError::Disconnected = err {
+                        info!("[login recv loop disconnect] {:?}", server_id);
+                        state_loop_sender.send(InterserverInputAction::Disconnect(server_id)).await.unwrap();
+                        break;
+                    }
+                    info!("[login recv loop err] {:?}", err);
+                }
+            }
+        }
+    });
+}
+
+async fn interserver_send_loop<S>(server_id: ServerId,
+                                  mut socket: async_std::net::TcpStream,
+                                  output_loop_receiver: async_std::channel::Receiver<S>)
+where
+    S: Serialize + std::fmt::Debug + Send + 'static,
+{
+    async_std::task::spawn(async move {
+        loop {
+            info!("login send loop");
+            match output_loop_receiver.recv().await {
+                Ok(msg) => {
+                    let payload = serde_json::to_string(&msg);
+                    if let Ok(payload) = payload {
+                        let len_bytes = u32::to_le_bytes(payload.len() as u32);
+
+                        if let Err(err) = socket.write_all(&len_bytes).await {
+                            warn!("interserver send failed: {:?}", err);
+                            break;
+                        }
+                        if let Err(err) = socket.write_all(payload.as_bytes()).await {
+                            warn!("intserserver send failed: {:?}", err);
+                            break;
+                        }
+                    }
+                },
+                Err(err) => {
+                    warn!("error in send_loop: {:?}, {:?}", server_id, err);
+                    break;
+                }
+            }
+        }
+    });
+}
+
+
+
+pub fn login_listen_mainloop<EG: EntityGateway + 'static>(state: Arc<Mutex<CharacterServerState<EG>>>, port: u16) ->  Pin<Box<dyn Future<Output = ()>>> {
+    Box::pin(async_std::task::spawn(async move {
+        let listener = async_std::net::TcpListener::bind(&std::net::SocketAddr::from((std::net::Ipv4Addr::new(0,0,0,0), port))).await.unwrap();
+        let mut id = 0;
+
+        let (server_state_sender, server_state_receiver) = async_std::channel::bounded(1024);
+        interserver_state_loop(state.clone(), server_state_receiver).await;
+
+        loop {
+            let (socket, addr) = listener.accept().await.unwrap();
+            info!("new ship server: {:?} {:?}", socket, addr);
+
+            id += 1;
+            let server_id = crate::common::interserver::ServerId(id);
+            let (client_sender, client_receiver) = async_std::channel::bounded(64);
+
+            {
+                let mut state = state.lock().await;
+                let local_sender = client_sender.clone();
+                state.set_sender(server_id, Box::new(move |message| {
+                    async_std::task::block_on(local_sender.send(message)).unwrap();
+                }))
+            }
+
+            login_recv_loop(server_id, socket.clone(), server_state_sender.clone(), client_sender).await;
+            interserver_send_loop(server_id, socket.clone(), client_receiver).await;
+        }
+    }))
+}
+
+pub fn ship_connect_mainloop<EG: EntityGateway + 'static>(state: Arc<Mutex<ShipServerState<EG>>>, ip: std::net::Ipv4Addr, port: u16) ->  Pin<Box<dyn Future<Output = ()>>> {
+    Box::pin(async_std::task::spawn(async move {
+        let mut id = 0;
+        let (server_state_sender, server_state_receiver) = async_std::channel::bounded(1024);
+
+        interserver_state_loop(state.clone(), server_state_receiver).await;
+
+        loop {
+            info!("trying to connect to loginserv");
+            let socket = match async_std::net::TcpStream::connect((ip, port)).await {
+                Ok(socket) => socket,
+                Err(err) => {
+                    info!("err trying to connect to loginserv {:?}", err);
+                    async_std::task::sleep(Duration::from_secs(10)).await;
+                    continue;
+                }
+            };
+            id += 1;
+            let server_id = crate::common::interserver::ServerId(id);
+            info!("found loginserv: {:?} {:?}", server_id, socket);
+            let (client_sender, client_receiver) = async_std::channel::bounded(64);
+
+            {
+                let mut state = state.lock().await;
+                let local_sender = client_sender.clone();
+                state.set_sender(Box::new(move |message| {
+                    async_std::task::block_on(local_sender.send(message)).unwrap();
+                }))
+            }
+
+            login_recv_loop(server_id, socket.clone(), server_state_sender.clone(), client_sender).await;
+            interserver_send_loop(server_id, socket.clone(), client_receiver).await;
+
+            let mut buf = [0u8; 1];
+            loop {
+                let peek = socket.peek(&mut buf).await;
+                match peek {
+                    Ok(len) if len == 0 => {
+                        break
+                    },
+                    _ => {
+                    }
+                }
+            }
+        }
+    }))
+}
+

src/common/mainloop/mod.rs

@@ -0,0 +1,45 @@
+mod client;
+mod interserver;
+
+use std::pin::Pin;
+use futures::future::{Future, join_all, FutureExt};
+use async_std::sync::{Arc, Mutex};
+
+use crate::common::mainloop::client::client_accept_mainloop;
+use crate::common::mainloop::interserver::{ship_connect_mainloop, login_listen_mainloop};
+pub use crate::common::mainloop::client::NetworkError;
+
+use crate::patch::patch::PatchServerState;
+use crate::login::login::LoginServerState;
+use crate::login::character::CharacterServerState;
+use crate::ship::ship::ShipServerState;
+use crate::entity::gateway::entitygateway::EntityGateway;
+
+
+
+pub fn patch_mainloop(patch_state: PatchServerState, patch_port: u16) -> Pin<Box<dyn Future<Output = ()>>> {
+    let patch_state = Arc::new(Mutex::new(patch_state));
+    let client_mainloop = client_accept_mainloop(patch_state, patch_port);
+    Box::pin(client_mainloop)
+}
+
+pub fn login_mainloop<EG: EntityGateway + 'static>(login_state: LoginServerState<EG>, login_port: u16) -> Pin<Box<dyn Future<Output = ()>>> {
+    let login_state = Arc::new(Mutex::new(login_state));
+    let client_mainloop = client_accept_mainloop(login_state, login_port);
+    Box::pin(client_mainloop)
+}
+
+pub fn character_mainloop<EG: EntityGateway + 'static>(character_state: CharacterServerState<EG>, character_port: u16, comm_port: u16) -> Pin<Box<dyn Future<Output = ()>>> {
+    let character_state = Arc::new(Mutex::new(character_state));
+    let client_mainloop = client_accept_mainloop(character_state.clone(), character_port);
+    let ship_communication_mainloop = login_listen_mainloop(character_state, comm_port);
+    Box::pin(join_all(vec![client_mainloop, ship_communication_mainloop]).map(|_| ()))
+}
+
+
+pub fn ship_mainloop<EG: EntityGateway + 'static>(ship_state: ShipServerState<EG>, ship_port: u16, comm_ip: std::net::Ipv4Addr, comm_port: u16) -> Pin<Box<dyn Future<Output = ()>>> {
+    let ship_state = Arc::new(Mutex::new(ship_state));
+    let client_mainloop = client_accept_mainloop(ship_state.clone(), ship_port);
+    let login_communication_mainloop = ship_connect_mainloop(ship_state, comm_ip, comm_port);
+    Box::pin(join_all(vec![client_mainloop, login_communication_mainloop]).map(|_| ()))
+}

src/common/mod.rs

@@ -0,0 +1,19 @@
+pub mod cipherkeys;
+pub mod serverstate;
+pub mod mainloop;
+pub mod leveltable;
+pub mod interserver;
+
+// https://www.reddit.com/r/rust/comments/33xhhu/how_to_create_an_array_of_structs_that_havent/
+#[macro_export]
+macro_rules! init_array(
+    ($ty:ty, $len:expr, $val:expr) => (
+        {
+            let mut array: [$ty; $len] = unsafe { std::mem::uninitialized() };
+            for i in array.iter_mut() {
+                unsafe { ::std::ptr::write(i, $val); }
+            }
+            array
+        }
+    )
+);

src/common/serverstate.rs

@@ -4,10 +4,9 @@ use libpso::crypto::PSOCipher;
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, derive_more::Display)]
 pub struct ClientId(pub usize);
 
-pub enum OnConnect<S: SendServerPacket, C: PSOCipher> {
+pub enum OnConnect<S: SendServerPacket> {
     Packet(S),
-    Cipher(C, C),
-    //Cipher((Box<dyn PSOCipher + Send + Sync>, Box<dyn PSOCipher + Send + Sync>)),
+    Cipher((Box<dyn PSOCipher + Send + Sync>, Box<dyn PSOCipher + Send + Sync>)),
 }
 
 pub trait RecvServerPacket: Sized + Sync {
@@ -20,14 +19,14 @@ pub trait SendServerPacket: Sized + Sync {
 
 // TODO: rename this trait, this isn't the state but the actionability of the state re: the client
 #[async_trait::async_trait]
-pub trait ServerState: Clone {
+pub trait ServerState {
     type SendPacket: SendServerPacket;
     type RecvPacket: RecvServerPacket;
-    type Cipher: PSOCipher;
     type PacketError;
     
-    async fn on_connect(&mut self, id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket, Self::Cipher>>, Self::PacketError>;
-    async fn handle(&mut self, id: ClientId, pkt: Self::RecvPacket) -> Result<Vec<(ClientId, Self::SendPacket)>, Self::PacketError>;
-                    //-> Result<Box<dyn Iterator<Item = (ClientId, Self::SendPacket)>>, Self::PacketError>;
+    async fn on_connect(&mut self, id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket>>, Self::PacketError>;
+    async fn handle(&mut self, id: ClientId, pkt: &Self::RecvPacket)
+                    -> Result<Box<dyn Iterator<Item = (ClientId, Self::SendPacket)> + Send>, Self::PacketError>;
     async fn on_disconnect(&mut self, id: ClientId) -> Result<Vec<(ClientId, Self::SendPacket)>, Self::PacketError>;
 }
+

src/drops/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "drops"
-version = "0.1.0"
-edition = "2021"
-
-
-[dependencies]
-entity = { workspace = true }
-maps = { workspace = true }
-stats = { workspace = true }
-
-rand = { workspace = true }
-rand_chacha = { workspace = true }
-serde = { workspace = true }
-enum-utils = { workspace = true }
-toml = { workspace = true }
-chrono = { workspace = true }

src/drops/src/lib.rs

@@ -1,298 +0,0 @@
-#![allow(dead_code, unused_must_use)]
-// TODO: there is some structure duplication that occurs here:
-// the rare and box tables instantiate their own copies of the
-// generic drop tables as they need them to apply their modifiers
-// to their drops
-
-
-pub mod rare_drop_table;
-mod generic_weapon;
-mod generic_armor;
-mod generic_shield;
-mod generic_unit;
-mod tool_table;
-mod tech_table;
-mod box_drop_table;
-
-use std::collections::HashMap;
-use std::fs::File;
-use std::path::PathBuf;
-use std::io::Read;
-use serde::{Serialize, Deserialize};
-use rand::{Rng, SeedableRng};
-
-use maps::monster::MonsterType;
-use maps::room::{Difficulty, Episode};
-use maps::area::MapArea;
-use entity::character::SectionID;
-use crate::generic_weapon::GenericWeaponTable;
-use crate::generic_armor::GenericArmorTable;
-use crate::generic_shield::GenericShieldTable;
-use crate::generic_unit::GenericUnitTable;
-use crate::tool_table::ToolTable;
-use crate::rare_drop_table::RareDropTable;
-use crate::box_drop_table::BoxDropTable;
-use maps::object::MapObject;
-use entity::item::{ItemType, weapon, armor, shield, unit, mag, tool, tech, esweapon};
-
-
-fn data_file_path(episode: Episode, difficulty: Difficulty, section_id: SectionID, filename: &str) -> PathBuf {
-    let mut path = PathBuf::from("data/drops/");
-    path.push(episode.to_string());
-    path.push(difficulty.to_string().to_lowercase());
-    path.push(section_id.to_string().to_lowercase());
-    path.push(filename);
-    path
-}
-
-pub fn load_data_file<T: serde::de::DeserializeOwned>(episode: Episode, difficulty: Difficulty, section_id: SectionID, filename: &str) -> T {
-    let path = data_file_path(episode, difficulty, section_id, filename);
-    let mut f = File::open(path).unwrap();
-    let mut s = String::new();
-    f.read_to_string(&mut s);
-
-    toml::from_str::<T>(s.as_str()).unwrap()
-}
-
-#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
-pub enum MonsterDropType {
-    #[serde(rename = "weapon")]
-    Weapon,
-    #[serde(rename = "armor")]
-    Armor,
-    #[serde(rename = "shield")]
-    Shield,
-    #[serde(rename = "unit")]
-    Unit,
-    #[serde(rename = "none")]
-    None,
-}
-
-#[derive(Debug, Serialize, Deserialize, Copy, Clone)]
-pub struct MonsterDropStats {
-    pub dar: u32,
-    pub drop_type: MonsterDropType,
-    pub min_meseta: u32,
-    pub max_meseta: u32,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum ItemDropType {
-    Weapon(weapon::Weapon),
-    Armor(armor::Armor),
-    Shield(shield::Shield),
-    Unit(unit::Unit),
-    Tool(tool::Tool),
-    //Tools(Vec<tool::Tool>),
-    TechniqueDisk(tech::TechniqueDisk),
-    Mag(mag::Mag),
-    Meseta(u32),
-}
-
-impl ItemDropType {
-    pub fn parse_item_from_bytes(data: [u8; 16]) -> Option<ItemDropType> {
-        let item_type = weapon::WeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::Weapon)
-            .or_else(|_| armor::ArmorType::parse_type([data[0],data[1],data[2]]).map(ItemType::Armor))
-            .or_else(|_| shield::ShieldType::parse_type([data[0],data[1],data[2]]).map(ItemType::Shield))
-            .or_else(|_| unit::UnitType::parse_type([data[0],data[1],data[2]]).map(ItemType::Unit))
-            .or_else(|_| mag::MagType::parse_type([data[0],data[1],data[2]]).map(ItemType::Mag))
-            .or_else(|_| tool::ToolType::parse_type([data[0],data[1],data[2]]).map(ItemType::Tool))
-            .or_else(|_| esweapon::ESWeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::ESWeapon)).ok()?;
-
-        match item_type {
-            ItemType::Weapon(_w) => Some(ItemDropType::Weapon(weapon::Weapon::from_bytes(data).ok()?)),
-            ItemType::Armor(_a) => Some(ItemDropType::Armor(armor::Armor::from_bytes(data).ok()?)),
-            ItemType::Shield(_s) => Some(ItemDropType::Shield(shield::Shield::from_bytes(data).ok()?)),
-            ItemType::Unit(_u) => Some(ItemDropType::Unit(unit::Unit::from_bytes(data).ok()?)),
-            ItemType::Mag(_m) => Some(ItemDropType::Mag(mag::Mag::from_bytes(data).ok()?)),
-            ItemType::Tool(_t) => Some(ItemDropType::Tool(tool::Tool::from_bytes(data).ok()?)),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct ItemDrop {
-    pub map_area: MapArea,
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-    pub item: ItemDropType,
-}
-
-
-pub trait DropTable {
-    fn get_drop(&mut self, map_area: &MapArea, monster: &MonsterType) -> Option<ItemDropType>;
-    fn get_box_drop(&mut self, map_area: &MapArea, object: &MapObject) -> Option<ItemDropType>;
-}
-
-pub struct StandardDropTable {
-    monster_stats: HashMap<MonsterType, MonsterDropStats>,
-    rare_table: RareDropTable,
-    weapon_table: GenericWeaponTable,
-    armor_table: GenericArmorTable,
-    shield_table: GenericShieldTable,
-    unit_table: GenericUnitTable,
-    tool_table: ToolTable,
-    box_table: BoxDropTable,
-    rng: rand_chacha::ChaCha20Rng,
-}
-
-impl StandardDropTable {
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new(episode: Episode, difficulty: Difficulty, section_id: SectionID) -> Box<dyn DropTable + Send + Sync> {
-        let monster_stats: HashMap<String, MonsterDropStats> = load_data_file(episode, difficulty, section_id, "monster_dar.toml");
-
-        Box::new(StandardDropTable {
-            monster_stats: monster_stats.into_iter().map(|(m, s)| (m.parse().unwrap(), s)).collect(),
-            rare_table: RareDropTable::new(episode, difficulty, section_id),
-            weapon_table: GenericWeaponTable::new(episode, difficulty, section_id),
-            armor_table: GenericArmorTable::new(episode, difficulty, section_id),
-            shield_table: GenericShieldTable::new(episode, difficulty, section_id),
-            unit_table: GenericUnitTable::new(episode, difficulty, section_id),
-            tool_table: ToolTable::new(episode, difficulty, section_id),
-            box_table: BoxDropTable::new(episode, difficulty, section_id),
-            rng: rand_chacha::ChaCha20Rng::from_entropy(),
-        })
-    }
-
-    pub fn builder() -> DropTableBuilder {
-        DropTableBuilder {
-            monster_stats: None,
-            rare_table: None,
-            weapon_table: None,
-            armor_table: None,
-            shield_table: None,
-            unit_table: None,
-            tool_table: None,
-            box_table: None,
-            rng: None,
-        }
-    }
-
-    fn generate_meseta(&mut self, monster: &MonsterDropStats) -> Option<ItemDropType> {
-        Some(ItemDropType::Meseta(self.rng.gen_range(monster.min_meseta, monster.max_meseta + 1)))
-    }
-
-    fn generate_typed_drop(&mut self, map_area: &MapArea, monster: &MonsterDropStats) -> Option<ItemDropType> {
-        match monster.drop_type {
-            MonsterDropType::Weapon => self.weapon_table.get_drop(map_area, &mut self.rng),
-            MonsterDropType::Armor => self.armor_table.get_drop(map_area, &mut self.rng),
-            MonsterDropType::Shield => self.shield_table.get_drop(map_area, &mut self.rng),
-            MonsterDropType::Unit => self.unit_table.get_drop(map_area, &mut self.rng),
-            MonsterDropType::None => None,
-        }
-    }
-}
-
-impl DropTable for StandardDropTable {
-    fn get_drop(&mut self, map_area: &MapArea, monster: &MonsterType) -> Option<ItemDropType> {
-        let monster_stat = *self.monster_stats.get(monster)?;
-
-        let drop_anything = self.rng.gen_range(0, 100);
-        if drop_anything > monster_stat.dar {
-            return None;
-        }
-
-        if let Some(item) = self.rare_table.get_drop(map_area, monster, &mut self.rng) {
-            return Some(item);
-        }
-
-        let drop_type = self.rng.gen_range(0, 3);
-
-        match drop_type {
-            0 => {
-                self.generate_meseta(&monster_stat)
-            },
-            1 => {
-                self.tool_table.get_drop(map_area, &mut self.rng)
-            },
-            2 => {
-                self.generate_typed_drop(map_area, &monster_stat)
-            },
-            _ => panic!()
-        }
-    }
-
-    fn get_box_drop(&mut self, map_area: &MapArea, object: &MapObject) -> Option<ItemDropType> {
-        self.box_table.get_drop(map_area, object, &mut self.rng)
-    }
-}
-
-
-pub struct DropTableBuilder {
-    monster_stats: Option<HashMap<MonsterType, MonsterDropStats>>,
-    rare_table: Option<RareDropTable>,
-    weapon_table: Option<GenericWeaponTable>,
-    armor_table: Option<GenericArmorTable>,
-    shield_table: Option<GenericShieldTable>,
-    unit_table: Option<GenericUnitTable>,
-    tool_table: Option<ToolTable>,
-    box_table: Option<BoxDropTable>,
-    rng: Option<rand_chacha::ChaCha20Rng>,
-}
-
-// TODO: add the rest of these later I just need these ones right now
-impl DropTableBuilder {
-    #[must_use]
-    pub fn monster_stats(mut self, monster_stats: HashMap<MonsterType, MonsterDropStats>) -> DropTableBuilder {
-        self.monster_stats = Some(monster_stats);
-        self
-    }
-
-    #[must_use]
-    pub fn monster_stat(mut self, monster_type: MonsterType, drop_stats: MonsterDropStats) -> DropTableBuilder {
-        match &mut self.monster_stats {
-            Some(monster_stats) => {
-                monster_stats.insert(monster_type, drop_stats);
-            },
-            None => {
-                let mut monster_stats = HashMap::default();
-                monster_stats.insert(monster_type, drop_stats);
-                self.monster_stats = Some(monster_stats);
-            }
-        }
-        self
-    }
-
-    #[must_use]
-    pub fn rare_table(mut self, rare_table: RareDropTable) -> DropTableBuilder {
-        self.rare_table = Some(rare_table);
-        self
-    }
-
-    pub fn build(self, episode: Episode, difficulty: Difficulty, section_id: SectionID) -> Box<dyn DropTable + Send + Sync> {
-        Box::new(StandardDropTable {
-            monster_stats: self.monster_stats.unwrap_or_else(|| {
-                let monster_stats: HashMap<String, MonsterDropStats> = load_data_file(episode, difficulty, section_id, "monster_dar.toml");
-                monster_stats.into_iter().map(|(m, s)| (m.parse().unwrap(), s)).collect()
-            }),
-            rare_table: self.rare_table.unwrap_or_else(|| RareDropTable::new(episode, difficulty, section_id)),
-            weapon_table: self.weapon_table.unwrap_or_else(|| GenericWeaponTable::new(episode, difficulty, section_id)),
-            armor_table: self.armor_table.unwrap_or_else(|| GenericArmorTable::new(episode, difficulty, section_id)),
-            shield_table: self.shield_table.unwrap_or_else(|| GenericShieldTable::new(episode, difficulty, section_id)),
-            unit_table: self.unit_table.unwrap_or_else(|| GenericUnitTable::new(episode, difficulty, section_id)),
-            tool_table: self.tool_table.unwrap_or_else(|| ToolTable::new(episode, difficulty, section_id)),
-            box_table: self.box_table.unwrap_or_else(|| BoxDropTable::new(episode, difficulty, section_id)),
-            rng: self.rng.unwrap_or_else(rand_chacha::ChaCha20Rng::from_entropy),
-        })
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use rand::seq::IteratorRandom;
-
-    #[test]
-    fn test_initializing_drop_table() {
-        let mut rng = rand_chacha::ChaCha20Rng::from_entropy();
-        let episode = vec![Episode::One, Episode::Two].into_iter().choose(&mut rng).unwrap();
-        let difficulty = vec![Difficulty::Normal, Difficulty::Hard, Difficulty::VeryHard, Difficulty::Ultimate]
-            .into_iter().choose(&mut rng).unwrap();
-        let section_id = vec![SectionID::Viridia, SectionID::Greenill, SectionID::Skyly, SectionID::Bluefull, SectionID::Purplenum,
-                              SectionID::Pinkal, SectionID::Redria, SectionID::Oran, SectionID::Yellowboze, SectionID::Whitill]
-            .into_iter().choose(&mut rng).unwrap();
-        DropTable::new(episode, difficulty, section_id);
-    }
-}

src/entity/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "entity"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-libpso = { workspace = true }
-maps = { workspace = true }
-chrono = { workspace = true }
-anyhow = { workspace = true }
-async-std = { workspace = true }
-sqlx = { workspace = true }
-thiserror = { workspace = true }
-serde = { workspace = true }
-async-trait = { workspace = true }
-enum-utils = { workspace = true }
-derive_more = { workspace = true }
-refinery = { workspace = true }
-lazy_static = { workspace = true }
-futures = { workspace = true }
-strum = { workspace = true }
-strum_macros = { workspace = true }
-toml = { workspace = true }

src/entity/character.rs

@@ -2,10 +2,10 @@ use std::convert::{From, Into};
 use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
 
-use libpso::packet::ship::{UpdateConfig, WriteInfoboard};
-use libpso::character::settings::{DEFAULT_PALETTE_CONFIG, DEFAULT_TECH_MENU};
-use crate::item::tech::Technique;
-use crate::account::UserAccountId;
+use libpso::packet::ship::{UpdateConfig, WriteInfoboard, KeyboardConfig, GamepadConfig};
+use libpso::character::settings::{DEFAULT_PALETTE_CONFIG, DEFAULT_TECH_MENU, DEFAULT_KEYBOARD_CONFIG1, DEFAULT_KEYBOARD_CONFIG2, DEFAULT_KEYBOARD_CONFIG3, DEFAULT_KEYBOARD_CONFIG4, DEFAULT_GAMEPAD_CONFIG};
+use crate::entity::item::tech::Technique;
+use crate::entity::account::UserAccountId;
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, enum_utils::FromStr, derive_more::Display, Serialize, Deserialize, Default)]
 pub enum CharacterClass {
@@ -157,7 +157,7 @@ pub struct CharacterAppearance {
 }
 
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct TechLevel(pub u8);
 
 #[derive(Clone, Debug, Default)]
@@ -167,14 +167,16 @@ pub struct CharacterTechniques {
 
 impl CharacterTechniques {
     pub fn set_tech(&mut self, tech: Technique, level: TechLevel) {
-        self.techs.insert(tech, TechLevel(level.0));
+        self.techs.insert(tech, TechLevel(level.0 - 1));
     }
 
+    // from_bytes
+
     pub fn as_bytes(&self) -> [u8; 20] {
         self.techs.iter()
             .fold([0xFF; 20], |mut techlist, (tech, level)| {
                 let index = tech.as_value();
-                techlist[index as usize] = level.0 - 1;
+                techlist[index as usize] = level.0;
                 techlist
             })
     }
@@ -223,7 +225,7 @@ impl CharacterInfoboard {
     }
 
     pub fn update_infoboard(&mut self, new_board: &WriteInfoboard) {
-        self.board = libpso::util::utf8_to_utf16_array(&new_board.message);
+        self.board = libpso::utf8_to_utf16_array!(new_board.message, 172);
     }
 }
 
@@ -262,6 +264,82 @@ pub struct CharacterMaterials {
     pub tp: u32,
 }
 
+#[derive(Clone, Debug)]
+pub struct CharacterKeyboardConfig {
+    pub keyboard_config: [u8; 0x16C],
+}
+
+impl Default for CharacterKeyboardConfig {
+    fn default() -> CharacterKeyboardConfig {
+        CharacterKeyboardConfig {
+            keyboard_config: DEFAULT_KEYBOARD_CONFIG1,
+        }
+    }
+}
+
+impl CharacterKeyboardConfig {
+    fn new(preset: usize) -> CharacterKeyboardConfig {
+        match preset {
+            1 => {
+                CharacterKeyboardConfig {
+                    keyboard_config: DEFAULT_KEYBOARD_CONFIG1,
+                }
+            },
+            2 => {
+                CharacterKeyboardConfig {
+                    keyboard_config: DEFAULT_KEYBOARD_CONFIG2,
+                }
+            },
+            3 => {
+                CharacterKeyboardConfig {
+                    keyboard_config: DEFAULT_KEYBOARD_CONFIG3,
+                }
+            },
+            4 => {
+                CharacterKeyboardConfig {
+                    keyboard_config: DEFAULT_KEYBOARD_CONFIG4,
+                }
+            },
+            _ => {
+                CharacterKeyboardConfig {
+                    keyboard_config: DEFAULT_KEYBOARD_CONFIG1,
+                }
+            },
+        }
+    }
+
+    pub fn update(&mut self, new_config: &KeyboardConfig) {
+        self.keyboard_config = new_config.keyboard_config;
+    }
+
+    pub fn as_bytes(&self) -> [u8; 0x16C] {
+        self.keyboard_config
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CharacterGamepadConfig {
+    pub gamepad_config: [u8; 0x38],
+}
+
+impl Default for CharacterGamepadConfig {
+    fn default() -> CharacterGamepadConfig {
+        CharacterGamepadConfig {
+            gamepad_config: DEFAULT_GAMEPAD_CONFIG,
+        }
+    }
+}
+
+impl CharacterGamepadConfig {
+    pub fn update(&mut self, new_config: &GamepadConfig) {
+        self.gamepad_config = new_config.gamepad_config;
+    }
+
+    pub fn as_bytes(&self) -> [u8; 0x38] {
+        self.gamepad_config
+    }
+}
+
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Default, derive_more::Display)]
 pub struct CharacterEntityId(pub u32);
 
@@ -285,10 +363,12 @@ pub struct NewCharacterEntity {
 
     pub tech_menu: CharacterTechMenu,
     pub option_flags: u32,
+    pub keyboard_config: CharacterKeyboardConfig,
+    pub gamepad_config: CharacterGamepadConfig,
 }
 
 impl NewCharacterEntity {
-    pub fn new(user: UserAccountId) -> NewCharacterEntity {
+    pub fn new(user: UserAccountId, keyboard_config_preset: usize,) -> NewCharacterEntity {
         NewCharacterEntity {
             user_id: user,
             slot: 0,
@@ -304,6 +384,8 @@ impl NewCharacterEntity {
             materials: CharacterMaterials::default(),
             tech_menu: CharacterTechMenu::default(),
             option_flags: 0,
+            keyboard_config: CharacterKeyboardConfig::new(keyboard_config_preset),
+            gamepad_config: CharacterGamepadConfig::default(),
         }
     }
 }
@@ -329,6 +411,6 @@ pub struct CharacterEntity {
 
     pub tech_menu: CharacterTechMenu,
     pub option_flags: u32,
-
-    pub playtime: u32,
+    pub keyboard_config: CharacterKeyboardConfig,
+    pub gamepad_config: CharacterGamepadConfig,
 }

src/entity/gateway/entitygateway.rs

@@ -1,45 +1,30 @@
 use thiserror::Error;
-use futures::future::{Future, BoxFuture};
 
-use crate::account::*;
-use crate::character::*;
-use crate::item::*;
-use crate::room::*;
+use crate::entity::account::*;
+use crate::entity::character::*;
+use crate::entity::item::*;
 
 
 // TODO: better granularity?
+//#[derive(Error, Debug)]
 #[derive(Error, Debug)]
+#[error("")]
 pub enum GatewayError {
-    #[error("unknown error")]
     Error,
-    #[error("postgres error {0}")]
     PgError(#[from] sqlx::Error)
 }
 
-
 #[async_trait::async_trait]
-pub trait EntityGateway: Send + Sync {
-    type Transaction<'t>: EntityGatewayTransaction + Clone where Self: 't;
-
-    fn with_transaction<'a, F, Fut, R>(&'a mut self, _func: F) -> BoxFuture<'a, Result<R, anyhow::Error>>
-    where
-        Fut: Future<Output = Result<(Self::Transaction<'a>, R), anyhow::Error>> + Send + 'a,
-        F: FnOnce(Self::Transaction<'a>) -> Fut + Send + 'a,
-        R: Send,
-        Self: Sized
-    {
-        unimplemented!();
-    }
-
+pub trait EntityGateway: Send + Sync + Clone {
     async fn create_user(&mut self, _user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
         unimplemented!()
     }
 
-    async fn get_user_by_id(&mut self, _id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
+    async fn get_user_by_id(&self, _id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
         unimplemented!();
     }
 
-    async fn get_user_by_name(&mut self, _username: String) -> Result<UserAccountEntity, GatewayError> {
+    async fn get_user_by_name(&self, _username: String) -> Result<UserAccountEntity, GatewayError> {
         unimplemented!();
     }
 
@@ -51,7 +36,7 @@ pub trait EntityGateway: Send + Sync {
         unimplemented!();
     }
 
-    async fn get_user_settings_by_user(&mut self, _user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
+    async fn get_user_settings_by_user(&self, _user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
         unimplemented!();
     }
 
@@ -64,7 +49,7 @@ pub trait EntityGateway: Send + Sync {
     }
 
     // TODO: just make this a vec sorted by slot order?
-    async fn get_characters_by_user(&mut self, _user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
+    async fn get_characters_by_user(&self, _user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
         unimplemented!();
     }
 
@@ -72,7 +57,7 @@ pub trait EntityGateway: Send + Sync {
         unimplemented!();
     }
 
-    async fn get_guild_card_data_by_user(&mut self, _user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
+    async fn get_guild_card_data_by_user(&self, _user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
         unimplemented!();
     }
 
@@ -96,15 +81,22 @@ pub trait EntityGateway: Send + Sync {
         unimplemented!();
     }
 
-    async fn add_weapon_modifier(&mut self, _item_id: &ItemEntityId, _modifier: &weapon::WeaponModifier) -> Result<(), GatewayError> {
+    async fn add_weapon_modifier(&mut self, _item_id: &ItemEntityId, _modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
         unimplemented!();
     }
 
+
+    /*
+    async fn get_items_by_character(&self, _char_id: &CharacterEntityId) -> Result<Vec<ItemEntity>, GatewayError> {
+        unimplemented!();
+    }
+     */
+
     async fn get_character_inventory(&mut self, _char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
         unimplemented!();
     }
 
-    async fn get_character_bank(&mut self, _char_id: &CharacterEntityId, _bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError> {
+    async fn get_character_bank(&mut self, _char_id: &CharacterEntityId, _bank_name: BankName) -> Result<BankEntity, GatewayError> {
         unimplemented!();
     }
 
@@ -112,7 +104,7 @@ pub trait EntityGateway: Send + Sync {
         unimplemented!();
     }
 
-    async fn set_character_bank(&mut self, _char_id: &CharacterEntityId, _bank: &BankEntity, _bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
+    async fn set_character_bank(&mut self, _char_id: &CharacterEntityId, _inventory: &BankEntity, _bank_name: BankName) -> Result<(), GatewayError> {
         unimplemented!();
     }
 
@@ -132,41 +124,15 @@ pub trait EntityGateway: Send + Sync {
         unimplemented!();
     }
 
-    async fn get_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError> {
+    async fn get_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank: BankName) -> Result<Meseta, GatewayError> {
         unimplemented!();
     }
 
-    async fn set_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank_identifier: &BankIdentifier, _amount: Meseta) -> Result<(), GatewayError> {
+    async fn set_bank_meseta(&mut self, _char_id: &CharacterEntityId, _bank: BankName, _amount: Meseta) -> Result<(), GatewayError> {
         unimplemented!();
     }
 
-    async fn create_trade(&mut self, _char_id1: &CharacterEntityId, _char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
-        unimplemented!();
-    }
-
-    async fn set_character_playtime(&mut self, _char_id: &CharacterEntityId, _playtime: u32) -> Result<(), GatewayError> {
-        unimplemented!();
-    }
-
-    async fn create_room(&mut self, _room: NewRoomEntity) -> Result<RoomEntity, GatewayError> {
-        unimplemented!();
-    }
-
-    async fn add_room_note(&mut self, _room_id: RoomEntityId, _note: RoomNote) -> Result<(), GatewayError> {
+    async fn set_character_exp(&mut self, _char_id: &CharacterEntityId, _exp: u32) -> Result<(), GatewayError> {
         unimplemented!();
     }
 }
-
-
-#[async_trait::async_trait]
-pub trait EntityGatewayTransaction: Send + Sync + Sized {
-    type ParentGateway: EntityGateway + Clone;
-
-    fn gateway(&mut self) -> &mut Self::ParentGateway {
-        unimplemented!()
-    }
-
-    async fn commit(self) -> Result<(), GatewayError> {
-        unimplemented!()
-    }
-}

src/entity/gateway/inmemory.rs

@@ -0,0 +1,362 @@
+use std::collections::BTreeMap;
+use std::convert::TryInto;
+
+use crate::entity::account::*;
+use crate::entity::character::*;
+use crate::entity::gateway::{EntityGateway, GatewayError};
+use crate::entity::item::*;
+
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone)]
+pub struct InMemoryGateway {
+    users: Arc<Mutex<BTreeMap<UserAccountId, UserAccountEntity>>>,
+    user_settings: Arc<Mutex<BTreeMap<UserSettingsId, UserSettingsEntity>>>,
+    characters: Arc<Mutex<BTreeMap<CharacterEntityId, CharacterEntity>>>,
+    character_meseta: Arc<Mutex<BTreeMap<CharacterEntityId, Meseta>>>,
+    bank_meseta: Arc<Mutex<BTreeMap<(CharacterEntityId, BankName), Meseta>>>,
+    items: Arc<Mutex<BTreeMap<ItemEntityId, ItemEntity>>>,
+    inventories: Arc<Mutex<BTreeMap<CharacterEntityId, InventoryEntity>>>,
+    banks: Arc<Mutex<BTreeMap<CharacterEntityId, BankEntity>>>,
+    equips: Arc<Mutex<BTreeMap<CharacterEntityId, EquippedEntity>>>,
+    mag_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<mag::MagModifier>>>>,
+    weapon_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<weapon::WeaponModifier>>>>,
+}
+
+impl Default for InMemoryGateway {
+    fn default() -> InMemoryGateway {
+        InMemoryGateway {
+            users: Arc::new(Mutex::new(BTreeMap::new())),
+            user_settings: Arc::new(Mutex::new(BTreeMap::new())),
+            characters: Arc::new(Mutex::new(BTreeMap::new())),
+            character_meseta: Arc::new(Mutex::new(BTreeMap::new())),
+            bank_meseta: Arc::new(Mutex::new(BTreeMap::new())),
+            items: Arc::new(Mutex::new(BTreeMap::new())),
+            inventories: Arc::new(Mutex::new(BTreeMap::new())),
+            banks: Arc::new(Mutex::new(BTreeMap::new())),
+            equips: Arc::new(Mutex::new(BTreeMap::new())),
+            mag_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
+            weapon_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
+        }
+    }
+}
+
+impl InMemoryGateway {
+    fn apply_modifiers(&self, inventory: InventoryEntity ) -> InventoryEntity {
+        let items = self.items.lock().unwrap();
+        let inventory_items = inventory.items.into_iter()
+            .map(|item| {
+                item.map_individual(|mut item| {
+                    item.item = match item.item {
+                        ItemDetail::Weapon(mut weapon) => {
+                            if let Some(weapon_modifiers) = self.weapon_modifiers.lock().unwrap().get(&item.id) {
+                                for weapon_modifier in weapon_modifiers.iter() {
+                                    weapon.apply_modifier(weapon_modifier);
+                                }
+                            }
+                            ItemDetail::Weapon(weapon)
+                        },
+                        ItemDetail::Mag(mag) => {
+                            let mut mag = mag::Mag::baby_mag(mag.color as u16);
+                            if let Some(mag_modifiers) = self.mag_modifiers.lock().unwrap().get(&item.id) {
+                                for mag_modifier in mag_modifiers.iter() {
+                                    match mag_modifier {
+                                        mag::MagModifier::FeedMag {food} => {
+                                            if let Some(mag_feed) = items.get(food) {
+                                                if let ItemDetail::Tool(mag_feed) = mag_feed.item {
+                                                    mag.feed(mag_feed.tool)
+                                                }
+                                            }
+                                        },
+                                        mag::MagModifier::OwnerChange(class, section_id) => {
+                                            mag.change_owner(*class, *section_id)
+                                        },
+                                        mag::MagModifier::MagCell(mag_cell_id) => {
+                                            if let Some(mag_cell) = items.get(mag_cell_id) {
+                                                if let ItemDetail::Tool(mag_cell) = mag_cell.item {
+                                                    mag.apply_mag_cell(mag_cell.tool.try_into().unwrap())
+                                                }
+                                            }
+                                        },
+                                        _ => {}
+                                    }
+                                }
+                            }
+                            ItemDetail::Mag(mag)
+                        }
+                        _ => {
+                            item.item
+                        }
+                    };
+
+                    item
+                })
+            })
+            .collect();
+        InventoryEntity::new(inventory_items)
+    }
+}
+
+#[async_trait::async_trait]
+impl EntityGateway for InMemoryGateway {
+    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
+        let mut users = self.users.lock().unwrap();
+        let id = users
+            .iter()
+            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
+            + 1;
+        let user = UserAccountEntity {
+            id: UserAccountId(id),
+            username: user.username,
+            password: user.password,
+            guildcard: user.guildcard,
+            team_id: user.team_id,
+            banned_until: user.banned_until,
+            muted_until: user.muted_until,
+            created_at: chrono::Utc::now(),
+            flags: user.flags,
+            activated: user.activated,
+            at_login: false,
+            at_character: false,
+            at_ship: false,
+        };
+        users.insert(user.id, user.clone());
+        Ok(user)
+    }
+
+    async fn get_user_by_id(&self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
+        let users = self.users.lock().unwrap();
+        users.get(&id).cloned().ok_or(GatewayError::Error)
+    }
+
+    async fn get_user_by_name(&self, username: String) -> Result<UserAccountEntity, GatewayError> {
+        let users = self.users.lock().unwrap();
+        users
+            .iter()
+            .find(|(_, k)| k.username == username)
+            .map(|(_, k)| k.clone())
+            .ok_or(GatewayError::Error)
+    }
+
+    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError>  {
+        let mut users = self.users.lock().unwrap();
+        users.insert(user.id, user.clone());
+        Ok(())
+    }
+
+    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
+        let mut user_settings = self.user_settings.lock().unwrap();
+        let id = user_settings
+            .iter()
+            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
+            + 1;
+        let new_settings = UserSettingsEntity {
+            id: UserSettingsId(id),
+            user_id: settings.user_id,
+            settings: settings.settings,
+        };
+        user_settings.insert(new_settings.id, new_settings.clone());
+        Ok(new_settings)
+    }
+
+    async fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
+        let user_settings = self.user_settings.lock().unwrap();
+        user_settings
+            .iter()
+            .find(|(_, k)| k.user_id == user.id)
+            .map(|(_, k)| k.clone())
+            .ok_or(GatewayError::Error)
+    }
+
+    async fn get_characters_by_user(&self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
+        let characters = self.characters.lock().unwrap();
+        const NONE: Option<CharacterEntity> = None;
+        let mut chars = [NONE; 4];
+        characters
+            .iter()
+            .filter(|(_, c)| c.user_id == user.id)
+            .for_each(|(_, c)| chars[c.slot as usize] = Some(c.clone()));
+        Ok(chars)
+    }
+
+    async fn create_character(&mut self, character: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
+        let mut characters = self.characters.lock().unwrap();
+        let id = characters
+            .iter()
+            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
+            + 1;
+
+        let new_character = CharacterEntity {
+            id: CharacterEntityId(id),
+            user_id: character.user_id,
+            slot: character.slot,
+            name: character.name,
+            exp: character.exp,
+            char_class: character.char_class,
+            section_id: character.section_id,
+            appearance: character.appearance,
+            techs: character.techs,
+            config: character.config,
+            info_board: character.info_board,
+            guildcard: character.guildcard,
+            materials: character.materials,
+            tech_menu: character.tech_menu,
+            option_flags: character.option_flags,
+            keyboard_config: character.keyboard_config,
+            gamepad_config: character.gamepad_config,
+        };
+        characters.insert(new_character.id, new_character.clone());
+        Ok(new_character)
+    }
+
+    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError>  {
+        let mut characters = self.characters.lock().unwrap();
+        characters.insert(char.id, char.clone());
+        Ok(())
+    }
+
+    async fn get_guild_card_data_by_user(&self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
+        Ok(GuildCardDataEntity::new(user.id))
+    }
+
+    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
+        let mut items = self.items.lock().unwrap();
+        let id = items
+            .iter()
+            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
+            + 1;
+        let new_item = ItemEntity {
+            id: ItemEntityId(id),
+            item: item.item,
+        };
+        items.insert(ItemEntityId(id), new_item.clone());
+        Ok(new_item)
+    }
+
+    async fn add_item_note(&mut self, _item_id: &ItemEntityId, _item_note: ItemNote) -> Result<(), GatewayError> {
+        Ok(())
+    }
+
+    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
+        self.mag_modifiers.lock().unwrap()
+            .entry(*mag_item_id)
+            .or_insert_with(Vec::new)
+            .push(mag::MagModifier::FeedMag {
+                food: *tool_item_id
+            });
+        Ok(())
+    }
+
+    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
+        self.mag_modifiers.lock().unwrap()
+            .entry(*mag_item_id)
+            .or_insert_with(Vec::new)
+            .push(mag::MagModifier::OwnerChange(character.char_class, character.section_id));
+        Ok(())
+    }
+
+    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
+        self.mag_modifiers.lock().unwrap()
+            .entry(*mag_item_id)
+            .or_insert_with(Vec::new)
+            .push(mag::MagModifier::MagCell(*mag_cell_id));
+        Ok(())
+    }
+
+    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
+        self.weapon_modifiers.lock().unwrap()
+            .entry(*item_id)
+            .or_insert_with(Vec::new)
+            .push(modifier);
+        Ok(())
+    }
+
+    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
+        let inventories = self.inventories.lock().unwrap();
+        Ok(inventories
+           .iter()
+           .find(|(id, _)| **id == *char_id)
+           .map(|(_, inv)| inv.clone())
+           .map(|inv| self.apply_modifiers(inv))
+           .unwrap_or_default())
+    }
+
+    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, _bank_name: BankName) -> Result<BankEntity, GatewayError> {
+        let banks = self.banks.lock().unwrap();
+        Ok(banks
+           .iter()
+           .find(|(id, _)| **id == *char_id)
+           .map(|(_, b)| b.clone())
+           .unwrap_or_default())
+    }
+
+    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
+        let mut inventories = self.inventories.lock().unwrap();
+        inventories.insert(*char_id, inventory.clone());
+        Ok(())
+    }
+
+    // TOOD: impl bank name
+    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, _bank_name: BankName) -> Result<(), GatewayError> {
+        let mut banks = self.banks.lock().unwrap();
+        banks.insert(*char_id, bank.clone());
+        Ok(())
+    }
+
+    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
+        let equips = self.equips.lock().unwrap();
+        Ok(equips
+            .iter()
+            .find(|(id, _)| **id == *char_id)
+            .map(|(_, inv)| inv.clone())
+            .unwrap_or_default())
+    }
+
+    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> {
+        let mut equips = self.equips.lock().unwrap();
+        equips.insert(*char_id, equipped.clone());
+        Ok(())
+    }
+
+    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
+        let mut character_meseta = self.character_meseta.lock().unwrap();
+        character_meseta.insert(*char_id, meseta);
+        Ok(())
+    }
+
+    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
+        let mut character_meseta = self.character_meseta.lock().unwrap();
+        if let Some(meseta) = character_meseta.get_mut(char_id) {
+            Ok(*meseta)
+        }
+        else {
+            Err(GatewayError::Error)
+        }
+    }
+
+    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: BankName, meseta: Meseta) -> Result<(), GatewayError> {
+        let mut bank_meseta = self.bank_meseta.lock().unwrap();
+        bank_meseta.insert((*char_id, bank), meseta);
+        Ok(())
+    }
+
+    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: BankName) -> Result<Meseta, GatewayError> {
+        let mut bank_meseta = self.bank_meseta.lock().unwrap();
+        if let Some(meseta) = bank_meseta.get_mut(&(*char_id, bank)) {
+            Ok(*meseta)
+        }
+        else {
+            Err(GatewayError::Error)
+        }
+    }
+
+    async fn set_character_exp(&mut self, char_id: &CharacterEntityId, exp: u32) -> Result<(), GatewayError> {
+        let mut chars = self.characters.lock().unwrap();
+        if let Some(character) = chars.get_mut(char_id) {
+          character.exp = exp;
+          Ok(())
+        } else {
+          Err(GatewayError::Error)
+        }
+    }
+}

src/entity/gateway/mod.rs

@@ -2,6 +2,6 @@ pub mod entitygateway;
 pub mod inmemory;
 pub mod postgres;
 
-pub use entitygateway::{EntityGateway, EntityGatewayTransaction, GatewayError};
+pub use entitygateway::{EntityGateway, GatewayError};
 pub use inmemory::InMemoryGateway;
 pub use self::postgres::PostgresGateway;

src/entity/gateway/postgres/migrations/V0001__initial.sql

@@ -19,8 +19,8 @@ create table user_settings (
   id serial primary key not null,
   user_account integer references user_accounts (id) not null,
   blocked_users bytea not null,
-  key_config bytea not null,
-  joystick_config bytea not null,
+  keyboard_config bytea not null,
+  gamepad_config bytea not null,
   option_flags integer not null,
   shortcuts bytea not null,
   symbol_chats bytea not null,
@@ -65,12 +65,10 @@ create table player_character (
   tp smallint not null,
 
   tech_menu bytea not null,
-  meseta integer not null,
-  bank_meseta integer not null
-
+  keyboard_config bytea not null,
+  gamepad_config bytea not null
 );
 
-
 create table item (
   id serial primary key not null,
   item jsonb not null

src/entity/gateway/postgres/migrations/V0003__item_notes.sql

@@ -1,4 +1,4 @@
-drop table item_location;
+drop table if exists item_location;
 
 create table item_note (
   item integer references item (id) not null,

src/entity/gateway/postgres/migrations/V0004__meseta.sql

@@ -11,6 +11,6 @@ create table bank_meseta (
 );
 
 
-alter table player_character
-  drop column meseta,
-  drop column bank_meseta;
+alter table if exists player_character
+  drop column if exists meseta,
+  drop column if exists bank_meseta;

src/entity/gateway/postgres/migrations/mod.rs

@@ -0,0 +1,3 @@
+use refinery::include_migration_mods;
+
+include_migration_mods!("src/entity/gateway/postgres/migrations");

src/entity/gateway/postgres/models.rs

@@ -4,13 +4,10 @@ use std::convert::Into;
 use serde::{Serialize, Deserialize};
 use libpso::character::settings;
 use libpso::util::vec_to_array;
-use crate::account::*;
-use crate::character::*;
-use crate::item::*;
-use crate::room::*;
-use maps::area::MapArea;
-use maps::room::{Episode, Difficulty};
-use maps::monster::MonsterType;
+use crate::entity::account::*;
+use crate::entity::character::*;
+use crate::entity::item::*;
+use crate::ship::map::MapArea;
 
 #[derive(Debug, sqlx::FromRow)]
 pub struct PgUserAccount {
@@ -52,8 +49,8 @@ pub struct PgUserSettings {
     id: i32,
     user_account: i32,
     blocked_users: Vec<u8>, //[u32; 0x1E],
-    key_config: Vec<u8>, //[u8; 0x16C],
-    joystick_config: Vec<u8>, //[u8; 0x38],
+    keyboard_config: Vec<u8>, //[u8; 0x16C],
+    gamepad_config: Vec<u8>, //[u8; 0x38],
     option_flags: i32,
     shortcuts: Vec<u8>, //[u8; 0xA40],
     symbol_chats: Vec<u8>, //[u8; 0x4E0],
@@ -67,8 +64,8 @@ impl From<PgUserSettings> for UserSettingsEntity {
             user_id: UserAccountId(other.user_account as u32),
             settings: settings::UserSettings {
                 blocked_users: vec_to_array(other.blocked_users.chunks(4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])).collect()),
-                keyboard_config: vec_to_array(other.key_config),
-                gamepad_config: vec_to_array(other.joystick_config),
+                keyboard_config: vec_to_array(other.keyboard_config),
+                gamepad_config: vec_to_array(other.gamepad_config),
                 option_flags: other.option_flags as u32,
                 shortcuts: vec_to_array(other.shortcuts),
                 symbol_chats: vec_to_array(other.symbol_chats),
@@ -220,8 +217,8 @@ pub struct PgCharacter {
     tp: i16,
 
     tech_menu: Vec<u8>,
-
-    playtime: i32,
+    keyboard_config: Vec<u8>,
+    gamepad_config: Vec<u8>,
 }
 
 impl From<PgCharacter> for CharacterEntity {
@@ -247,13 +244,13 @@ impl From<PgCharacter> for CharacterEntity {
                 prop_y: other.prop_y,
             },
             techs: CharacterTechniques {
-                techs: other.techs.iter().enumerate().take(19).filter(|(_, t)| **t != 0xFF).map(|(i, t)| (tech::Technique::from_value(i as u8), TechLevel(*t + 1)) ).collect()
+                techs: other.techs.iter().enumerate().take(19).filter(|(_, t)| **t != 0xFF).map(|(i, t)| (tech::Technique::from_value(i as u8), TechLevel(*t)) ).collect()
             },
             config: CharacterConfig {
                 raw_data: vec_to_array(other.config)
             },
             info_board: CharacterInfoboard {
-                board: libpso::util::utf8_to_utf16_array(other.infoboard),
+                board: libpso::utf8_to_utf16_array!(other.infoboard, 172),
             },
             guildcard: CharacterGuildCard {
                 description: other.guildcard,
@@ -271,7 +268,12 @@ impl From<PgCharacter> for CharacterEntity {
             tech_menu: CharacterTechMenu {
                 tech_menu: vec_to_array(other.tech_menu)
             },
-            playtime: other.playtime as u32,
+            keyboard_config: CharacterKeyboardConfig {
+                keyboard_config: vec_to_array(other.keyboard_config)
+            },
+            gamepad_config: CharacterGamepadConfig {
+                gamepad_config: vec_to_array(other.gamepad_config)
+            },
         }
     }
 }
@@ -580,16 +582,6 @@ pub enum PgItemNoteDetail {
     },
     EnemyDrop {
         character_id: u32,
-        room_id: u32,
-        monster_type: MonsterType,
-        map_area: MapArea,
-        x: f32,
-        y: f32,
-        z: f32,
-    },
-    BoxDrop {
-        character_id: u32,
-        room_id: u32,
         map_area: MapArea,
         x: f32,
         y: f32,
@@ -599,41 +591,24 @@ pub enum PgItemNoteDetail {
         character_id: u32,
     },
     PlayerDrop {
-        character_id: u32,
         map_area: MapArea,
         x: f32,
         y: f32,
         z: f32,
     },
-    Consumed {
-        character_id: u32,
-    },
+    Consumed,
     FedToMag {
-        character_id: u32,
         mag: u32,
     },
     BoughtAtShop {
         character_id: u32,
     },
-    SoldToShop {
-        character_id: u32,
-    },
+    SoldToShop,
     Trade {
-        trade_id: u32,
+        id: u32,
         character_to: u32,
         character_from: u32,
     },
-    Withdraw {
-        character_id: u32,
-        bank: BankIdentifier,
-    },
-    Deposit {
-        character_id: u32,
-        bank: BankIdentifier,
-    },
-    FloorLimitReached {
-        map_area: MapArea,
-    }
 }
 
 impl From<ItemNote> for PgItemNoteDetail {
@@ -642,62 +617,31 @@ impl From<ItemNote> for PgItemNoteDetail {
             ItemNote::CharacterCreation{character_id} => PgItemNoteDetail::CharacterCreation {
                 character_id: character_id.0,
             },
-            ItemNote::EnemyDrop{character_id, room_id, monster_type, map_area, x, y, z} => PgItemNoteDetail::EnemyDrop {
+            ItemNote::EnemyDrop{character_id, map_area, x, y, z} => PgItemNoteDetail::EnemyDrop {
                 character_id: character_id.0,
-                room_id: room_id.0,
-                monster_type,
-                map_area,
-                x,y,z,
-            },
-            ItemNote::BoxDrop{character_id, room_id, map_area, x, y, z} => PgItemNoteDetail::BoxDrop {
-                character_id: character_id.0,
-                room_id: room_id.0,
                 map_area,
                 x,y,z,
             },
             ItemNote::Pickup{character_id} => PgItemNoteDetail::Pickup {
                 character_id: character_id.0,
             },
-            ItemNote::PlayerDrop{character_id, map_area, x, y, z} => PgItemNoteDetail::PlayerDrop {
-                character_id: character_id.0,
+            ItemNote::PlayerDrop{map_area, x, y, z} => PgItemNoteDetail::PlayerDrop {
                 map_area,
                 x,y,z,
             },
-            ItemNote::Consumed{character_id} => PgItemNoteDetail::Consumed {
-                character_id: character_id.0,
-            },
-            ItemNote::FedToMag{character_id, mag} => PgItemNoteDetail::FedToMag{
-                character_id: character_id.0,
+            ItemNote::Consumed => PgItemNoteDetail::Consumed,
+            ItemNote::FedToMag{mag} => PgItemNoteDetail::FedToMag{
                 mag: mag.0
             },
             ItemNote::BoughtAtShop{character_id} => PgItemNoteDetail::BoughtAtShop {
                 character_id: character_id.0,
             },
-            ItemNote::SoldToShop{character_id} => PgItemNoteDetail::SoldToShop {
-                character_id: character_id.0,
-            },
-            ItemNote::Trade{trade_id, character_to, character_from} => PgItemNoteDetail::Trade {
-                trade_id: trade_id.0,
+            ItemNote::SoldToShop => PgItemNoteDetail::SoldToShop,
+            ItemNote::Trade{id, character_to, character_from} => PgItemNoteDetail::Trade {
+                id: id.0,
                 character_to: character_to.0,
                 character_from: character_from.0,
-            },
-            ItemNote::Withdraw{character_id, bank} => {
-                PgItemNoteDetail::Withdraw {
-                    character_id: character_id.0,
-                    bank,
-                }
-            },
-            ItemNote::Deposit{character_id, bank} => {
-                PgItemNoteDetail::Deposit {
-                    character_id: character_id.0,
-                    bank,
-                }
-            },
-            ItemNote::FloorLimitReached { map_area } => {
-                PgItemNoteDetail::FloorLimitReached {
-                    map_area,
-                }
-            },
+            }
         }
     }
 }
@@ -706,58 +650,33 @@ impl From<PgItemNoteDetail> for ItemNote {
     fn from(other: PgItemNoteDetail) -> ItemNote {
         match other {
             PgItemNoteDetail::CharacterCreation{character_id} => ItemNote::CharacterCreation {
-                character_id: CharacterEntityId(character_id),
+                character_id: CharacterEntityId(character_id as u32),
             },
-            PgItemNoteDetail::EnemyDrop{character_id, room_id, monster_type, map_area, x, y, z} => ItemNote::EnemyDrop {
-                character_id: CharacterEntityId(character_id),
-                room_id: RoomEntityId(room_id),
-                monster_type,
-                map_area,
-                x,y,z,
-            },
-            PgItemNoteDetail::BoxDrop{character_id, room_id, map_area, x, y, z} => ItemNote::BoxDrop {
-                character_id: CharacterEntityId(character_id),
-                room_id: RoomEntityId(room_id),
+            PgItemNoteDetail::EnemyDrop{character_id, map_area, x, y, z} => ItemNote::EnemyDrop {
+                character_id: CharacterEntityId(character_id as u32),
                 map_area,
                 x,y,z,
             },
             PgItemNoteDetail::Pickup{character_id} => ItemNote::Pickup {
-                character_id: CharacterEntityId(character_id),
+                character_id: CharacterEntityId(character_id as u32),
             },
-            PgItemNoteDetail::PlayerDrop{character_id, map_area, x, y, z} => ItemNote::PlayerDrop {
-                character_id: CharacterEntityId(character_id),
+            PgItemNoteDetail::PlayerDrop{map_area, x, y, z} => ItemNote::PlayerDrop {
                 map_area,
                 x,y,z,
             },
-            PgItemNoteDetail::Consumed{character_id} => ItemNote::Consumed {
-                character_id: CharacterEntityId(character_id),
-            },
-            PgItemNoteDetail::FedToMag{character_id, mag} => ItemNote::FedToMag{
-                character_id: CharacterEntityId(character_id),
+            PgItemNoteDetail::Consumed => ItemNote::Consumed,
+            PgItemNoteDetail::FedToMag{mag} => ItemNote::FedToMag{
                 mag: ItemEntityId(mag)
             },
             PgItemNoteDetail::BoughtAtShop{character_id} => ItemNote::BoughtAtShop {
                 character_id: CharacterEntityId(character_id),
             },
-            PgItemNoteDetail::SoldToShop{character_id} => ItemNote::SoldToShop {
-                character_id: CharacterEntityId(character_id),
-            },
-            PgItemNoteDetail::Trade {trade_id, character_to, character_from} => ItemNote::Trade {
-                trade_id: TradeId(trade_id),
-                character_to: CharacterEntityId(character_to),
-                character_from: CharacterEntityId(character_from),
-            },
-            PgItemNoteDetail::Withdraw{character_id, bank} => ItemNote::Withdraw {
-                character_id: CharacterEntityId(character_id),
-                bank,
-            },
-            PgItemNoteDetail::Deposit{character_id, bank} => ItemNote::Deposit {
-                character_id: CharacterEntityId(character_id),
-                bank,
-            },
-            PgItemNoteDetail::FloorLimitReached { map_area } => ItemNote::FloorLimitReached {
-                map_area,
-            },
+            PgItemNoteDetail::SoldToShop => ItemNote::SoldToShop,
+            PgItemNoteDetail::Trade {id, character_to, character_from} => ItemNote::Trade {
+                id: TradeId(id as u32),
+                character_to: CharacterEntityId(character_to as u32),
+                character_from: CharacterEntityId(character_from as u32),
+            }
         }
     }
 }
@@ -908,43 +827,3 @@ impl From<(CharacterEntityId, EquippedEntity)> for PgEquipped {
     }
 }
 
-#[derive(Debug, sqlx::FromRow)]
-pub struct PgTradeEntity {
-    id: i32,
-    character1: i32,
-    character2: i32,
-}
-
-impl From<PgTradeEntity> for TradeEntity {
-    fn from(other: PgTradeEntity) -> TradeEntity {
-        TradeEntity {
-            id: TradeId(other.id as u32),
-            character1: CharacterEntityId(other.character1 as u32),
-            character2: CharacterEntityId(other.character2 as u32),
-        }
-    }
-}
-
-
-#[derive(Debug, sqlx::FromRow, Serialize)]
-pub struct PgRoomEntity {
-    id: i32,
-    name: String,
-    section_id: i8,
-    mode: i8,
-    episode: i8,
-    difficulty: i8,
-}
-
-impl From<PgRoomEntity> for RoomEntity {
-    fn from(other: PgRoomEntity) -> RoomEntity {
-        RoomEntity {
-            id: RoomEntityId(other.id as u32),
-            name: other.name,
-            section_id: SectionID::from(other.section_id as u8),
-            mode: RoomEntityMode::from(other.mode as u8),
-            episode: Episode::try_from(other.episode as u8).unwrap(),
-            difficulty: Difficulty::try_from(other.difficulty as u8).unwrap(),
-        }
-    }
-}

src/entity/gateway/postgres/postgres.rs

@@ -0,0 +1,601 @@
+use std::convert::{From, TryFrom, Into};
+use futures::TryStreamExt;
+use async_std::stream::StreamExt;
+use libpso::character::guildcard;
+use crate::entity::account::*;
+use crate::entity::character::*;
+use crate::entity::gateway::{EntityGateway, GatewayError};
+use crate::entity::item::*;
+use super::models::*;
+
+use sqlx::postgres::PgPoolOptions;
+
+mod embedded {
+    use refinery::embed_migrations;
+    embed_migrations!("src/entity/gateway/postgres/migrations");
+}
+
+
+#[derive(Clone)]
+pub struct PostgresGateway {
+    pool: sqlx::Pool<sqlx::Postgres>,
+}
+
+impl PostgresGateway {
+    pub fn new(host: &str, dbname: &str, username: &str, password: &str) -> PostgresGateway {
+        let mut conn = refinery::config::Config::new(refinery::config::ConfigDbType::Postgres)
+            .set_db_host(host)
+            .set_db_user(username)
+            .set_db_pass(password)
+            .set_db_name(dbname);
+        embedded::migrations::runner().run(&mut conn).unwrap();
+
+        let pool = async_std::task::block_on(async move {
+            let pool = PgPoolOptions::new()
+                .max_connections(5)
+                .connect(&format!("postgresql://{}:{}@{}:5432/{}", username, password, host, dbname)).await.unwrap();
+
+            pool
+        });
+
+        PostgresGateway {
+            pool,
+        }
+    }
+
+    async fn apply_item_modifications(&self, item: ItemEntity) -> ItemEntity {
+        let ItemEntity {id, item} = item;
+
+        let item = match item {
+            ItemDetail::Weapon(mut weapon) => {
+                let q = r#"select weapon, modifier
+                           from weapon_modifier
+                           where weapon = $1
+                           order by created_at"#;
+                let weapon_modifiers = sqlx::query_as::<_, PgWeaponModifier>(q)
+                    .bind(id.0 as i32)
+                    .fetch(&self.pool);
+
+                weapon_modifiers.for_each(|modifier| {
+                    if let Ok(modifier) = modifier {
+                        weapon.apply_modifier(&modifier.modifier);
+                    }
+                }).await;
+
+                ItemDetail::Weapon(weapon)
+            },
+            ItemDetail::Mag(mut mag) => {
+                let q = r#"select mag, modifier, item.item -> 'Tool' as feed, item2.item -> 'Tool' as cell
+                           from mag_modifier
+                           left join item on item.id = cast (modifier ->> 'FeedMag' as integer)
+                           left join item as item2 on item2.id = cast (modifier ->> 'MagCell' as integer)
+                           where mag = $1 order by created_at"#;
+                let mag_modifiers = sqlx::query_as::<_, PgMagModifierWithParameters>(q)
+                    .bind(id.0 as i32)
+                    .fetch(&self.pool);
+
+                mag_modifiers.for_each(|modifier| {
+                    let PgMagModifierWithParameters {modifier, feed, cell, ..} = modifier.unwrap();
+                    let modifier: mag::MagModifier = modifier.0.into();
+                    match modifier {
+                        mag::MagModifier::FeedMag{..} => {
+                            mag.feed(feed.unwrap().tool)
+                        },
+                        mag::MagModifier::BankMag => {
+                            mag.bank()
+                        },
+                        mag::MagModifier::MagCell(_) => {
+                            mag.apply_mag_cell(mag::MagCell::try_from(Into::<tool::Tool>::into(cell.unwrap().0).tool).unwrap())
+                        },
+                        mag::MagModifier::OwnerChange(class, section_id) => {
+                            mag.change_owner(class, section_id)
+                        },
+                    }
+                }).await;
+
+                ItemDetail::Mag(mag)
+            },
+            item => item
+        };
+
+        ItemEntity {
+            id,
+            item,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl EntityGateway for PostgresGateway {
+    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
+        let new_user = sqlx::query_as::<_, PgUserAccount>("insert into user_accounts (email, username, password, activated) values ($1, $2, $3, $4) returning *;")
+            .bind(user.email)
+            .bind(user.username)
+            .bind(user.password)
+            .bind(user.activated)
+            .fetch_one(&self.pool).await?;
+        Ok(new_user.into())
+    }
+
+    async fn get_user_by_id(&self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
+        let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where id = $1")
+            .bind(id.0)
+            .fetch_one(&self.pool).await?;
+        Ok(user.into())
+    }
+
+    async fn get_user_by_name(&self, username: String) -> Result<UserAccountEntity, GatewayError> {
+        let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where username = $1")
+            .bind(username)
+            .fetch_one(&self.pool).await?;
+        Ok(user.into())
+    }
+
+    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> {
+        sqlx::query("UPDATE user_accounts set username=$1, password=$2, banned=$3, muted=$4, flags=$5 where id=$6")
+            .bind(&user.username)
+            .bind(&user.password)
+            .bind(&user.banned_until)
+            .bind(&user.muted_until)
+            .bind(&user.flags)
+            .bind(&user.id.0)
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
+        let new_settings = sqlx::query_as::<_, PgUserSettings>("insert into user_settings (user_account, blocked_users, keyboard_config, gamepad_config, option_flags, shortcuts, symbol_chats, team_name)
+                                                                values ($1, $2, $3, $4, $5, $6, $7, $8) returning *;")
+            .bind(settings.user_id.0)
+            .bind(settings.settings.blocked_users.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
+            .bind(settings.settings.keyboard_config.to_vec())
+            .bind(settings.settings.gamepad_config.to_vec())
+            .bind(settings.settings.option_flags as i32)
+            .bind(settings.settings.shortcuts.to_vec())
+            .bind(settings.settings.symbol_chats.to_vec())
+            .bind(settings.settings.team_name.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
+            .fetch_one(&self.pool).await?;
+        Ok(new_settings.into())
+    }
+
+    async fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
+        let settings = sqlx::query_as::<_, PgUserSettings>("select * from user_settings where user_account = $1")
+            .bind(user.id.0)
+            .fetch_one(&self.pool).await?;
+        Ok(settings.into())
+    }
+
+    async fn save_user_settings(&mut self, settings: &UserSettingsEntity) -> Result<(), GatewayError> {
+        sqlx::query("update user_settings set blocked_users=$1, keyboard_config=$2, gamepad_config=$3, option_flags=$4, shortcuts=$5, symbol_chats=$6, team_name=$7 where id=$8")
+            .bind(settings.settings.blocked_users.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
+            .bind(&settings.settings.keyboard_config.to_vec())
+            .bind(&settings.settings.gamepad_config.to_vec())
+            .bind(&settings.settings.option_flags)
+            .bind(&settings.settings.shortcuts.to_vec())
+            .bind(&settings.settings.symbol_chats.to_vec())
+            .bind(settings.settings.team_name.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
+            .bind(&settings.id.0)
+            .fetch_one(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn create_character(&mut self, char: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
+        let q = r#"insert into player_character
+                  (user_account, slot, name, exp, class, section_id, costume, skin, face, head, hair, hair_r, hair_g, hair_b, prop_x, prop_y, techs,
+                   config, infoboard, guildcard, option_flags, power, mind, def, evade, luck, hp, tp, tech_menu, keyboard_config, gamepad_config)
+                  values
+                  ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31)
+                  returning *;"#;
+        let character = sqlx::query_as::<_, PgCharacter>(q)
+            .bind(char.user_id.0)
+            .bind(char.slot as i16)
+            .bind(char.name)
+            .bind(char.exp as i32)
+            .bind(char.char_class.to_string())
+            .bind(char.section_id.to_string())
+            .bind(char.appearance.costume as i16)
+            .bind(char.appearance.skin as i16)
+            .bind(char.appearance.face as i16)
+            .bind(char.appearance.head as i16)
+            .bind(char.appearance.hair as i16)
+            .bind(char.appearance.hair_r as i16)
+            .bind(char.appearance.hair_g as i16)
+            .bind(char.appearance.hair_b as i16)
+            .bind(char.appearance.prop_x)
+            .bind(char.appearance.prop_y)
+            .bind(&char.techs.as_bytes().to_vec())
+            .bind(&char.config.as_bytes().to_vec())
+            .bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0)))
+            .bind(char.guildcard.description)
+            .bind(char.option_flags as i32)
+            .bind(char.materials.power as i16)
+            .bind(char.materials.mind as i16)
+            .bind(char.materials.def as i16)
+            .bind(char.materials.evade as i16)
+            .bind(char.materials.luck as i16)
+            .bind(char.materials.hp as i16)
+            .bind(char.materials.tp as i16)
+            .bind(char.tech_menu.tech_menu.to_vec())
+            .bind(char.keyboard_config.keyboard_config.to_vec())
+            .bind(char.gamepad_config.gamepad_config.to_vec())
+            .fetch_one(&self.pool).await?;
+
+        Ok(character.into())
+    }
+
+    async fn get_characters_by_user(&self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
+        let mut stream = sqlx::query_as::<_, PgCharacter>("select * from player_character where user_account = $1 and slot < 4 order by slot")
+            .bind(user.id.0)
+            .fetch(&self.pool);
+        const NONE: Option<CharacterEntity> = None;
+        let mut result = [NONE; 4];
+        while let Some(character) = stream.try_next().await? {
+            let index = character.slot as usize;
+            result[index] = Some(character.into())
+        }
+
+        Ok(result)
+    }
+
+    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> {
+        let q = r#"update player_character set
+                   user_account=$1, slot=$2, name=$3, exp=$4, class=$5, section_id=$6, costume=$7, skin=$8, face=$9, head=$10, hair=$11, hair_r=$12,
+                   hair_g=$13, hair_b=$14, prop_x=$15, prop_y=$16, techs=$17, config=$18, infoboard=$19, guildcard=$20, power=$21, mind=$22, def=$23,
+                   evade=$24, luck=$25, hp=$26, tp=$27, tech_menu=$28, option_flags=$29
+                   where id=$32;"#;
+        sqlx::query(q)
+            .bind(char.user_id.0)
+            .bind(char.slot as i16)
+            .bind(&char.name)
+            .bind(char.exp as i32)
+            .bind(char.char_class.to_string())
+            .bind(char.section_id.to_string())
+            .bind(char.appearance.costume as i16)
+            .bind(char.appearance.skin as i16)
+            .bind(char.appearance.face as i16)
+            .bind(char.appearance.head as i16)
+            .bind(char.appearance.hair as i16)
+            .bind(char.appearance.hair_r as i16)
+            .bind(char.appearance.hair_g as i16)
+            .bind(char.appearance.hair_b as i16)
+            .bind(char.appearance.prop_x)
+            .bind(char.appearance.prop_y)
+            .bind(&char.techs.as_bytes().to_vec())
+            .bind(&char.config.as_bytes().to_vec())
+            .bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0)))
+            .bind(&char.guildcard.description)
+            .bind(char.materials.power as i16)
+            .bind(char.materials.mind as i16)
+            .bind(char.materials.def as i16)
+            .bind(char.materials.evade as i16)
+            .bind(char.materials.luck as i16)
+            .bind(char.materials.hp as i16)
+            .bind(char.materials.tp as i16)
+            .bind(char.tech_menu.tech_menu.to_vec())
+            .bind(char.option_flags as i32)
+            .bind(char.id.0 as i32)
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn get_guild_card_data_by_user(&self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
+        Ok(GuildCardDataEntity {
+            id: GuildCardDataId(0),
+            user_id: user.id,
+            guildcard: guildcard::GuildCardData::default(),
+        })
+    }
+
+    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
+        let mut tx = self.pool.begin().await?;
+        let new_item = sqlx::query_as::<_, PgItem>("insert into item (item) values ($1) returning *;")
+            .bind(sqlx::types::Json(PgItemDetail::from(item.item)))
+            .fetch_one(&mut tx).await?;
+
+        tx.commit().await?;
+        Ok(ItemEntity {
+            id: ItemEntityId(new_item.id as u32),
+            item: new_item.item.0.into(),
+        })
+    }
+
+    async fn add_item_note(&mut self, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError> {
+        sqlx::query("insert into item_note(item, note) values ($1, $2)")
+            .bind(item_id.0)
+            .bind(sqlx::types::Json(PgItemNoteDetail::from(item_note)))
+            .execute(&self.pool).await?;
+        Ok(())
+
+        /*
+        let mut tx = self.pool.begin().await?;
+        if let ItemLocation::Inventory{slot, ..} = &item_location {
+            sqlx::query("delete from inventory_slot where item = $1")
+                .bind(item_id.0 as i32)
+                .execute(&mut tx).await?;
+            sqlx::query("insert into inventory_slot (item, slot) values ($1, $2)")
+                .bind(item_id.0)
+                .bind(*slot as i32)
+                .execute(&mut tx).await?;
+            sqlx::query(r#"insert into item_location (item, location)
+                           select $1, $2
+                               where (select jsonb_object_keys(location) from item_location where item=$1
+                               order by created_at desc limit 1) != 'Inventory'"#)
+                .bind(item_id.0)
+                .bind(sqlx::types::Json(PgItemLocationDetail::from(item_location)))
+                .execute(&mut tx).await?;
+        }
+        else {
+            sqlx::query("insert into item_location (item, location) values ($1, $2)")
+                .bind(item_id.0)
+                .bind(sqlx::types::Json(PgItemLocationDetail::from(item_location)))
+                .execute(&mut tx).await?;
+        }
+        tx.commit().await?;
+        Ok(())
+        */
+    }
+
+    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
+        sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
+            .bind(mag_item_id.0)
+            .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::FeedMag{food: *tool_item_id})))
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
+        sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
+            .bind(mag_item_id.0)
+            .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::OwnerChange(character.char_class, character.section_id))))
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
+        sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
+            .bind(mag_item_id.0)
+            .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::MagCell(*mag_cell_id))))
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
+        sqlx::query("insert into weapon_modifier (weapon, modifier) values ($1, $2);")
+            .bind(item_id.0)
+            .bind(sqlx::types::Json(modifier))
+            .execute(&self.pool).await?;
+        Ok(())
+    }
+
+/*
+    async fn get_items_by_character(&self, char_id: &CharacterEntityId) -> Result<Vec<ItemEntity>, GatewayError> {
+        let q = r#"select * from (
+                      select distinct on (item_location.item)
+                          item.id,
+                          case
+                              when item_location.location -> 'Inventory' is not null then
+                                  jsonb_set(item_location.location, '{Inventory,slot}', inventory_slot.slot::text::jsonb)
+                              else
+                                  item_location.location
+                          end,
+                          item.item
+                      from item_location
+                      join item on item.id = item_location.item
+                      join inventory_slot on inventory_slot.item = item.id
+                      order by item_location.item, item_location.created_at desc
+                  ) as i
+                  where cast (location -> 'Inventory' ->> 'character_id' as integer) = $1
+                     or cast (location -> 'Bank' ->> 'character_id' as integer) = $1
+                   "#;
+        let items = sqlx::query_as::<_, PgItemWithLocation>(q)
+            .bind(char_id.0)
+            .fetch(&self.pool);
+        Ok(join_all(items
+                    .filter_map(|item: Result<PgItemWithLocation, _>| {
+                        let item = item.ok()?;
+                        Some(ItemEntity {
+                            id: ItemEntityId(item.id as u32),
+                            item: item.item.0.into(),
+                            location: item.location.0.into()
+                        })
+                    })
+                    .map(|item: ItemEntity| {
+                        self.apply_item_modifications(item)
+                    })
+                    .collect::<Vec<_>>()
+                    .await
+        ).await)
+    }
+*/
+    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
+        let inventory = sqlx::query_as::<_, PgInventoryEntity>("select * from inventory where pchar = $1")
+            .bind(char_id.0)
+            .fetch_one(&self.pool).await?;
+        // TODO: inefficient
+        let mut real_inventory = Vec::new();
+        for inv_item in inventory.items.0.into_iter() {
+            match inv_item {
+                PgInventoryItemEntity::Individual(item) => {
+                    let entity = sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
+                        .bind(item)
+                        .fetch_one(&self.pool).await
+                        .map(|item| item.into())
+                        .map(|item| self.apply_item_modifications(item))?
+                        .await;
+                    real_inventory.push(InventoryItemEntity::Individual(entity));
+                },
+                PgInventoryItemEntity::Stacked(items) => {
+                    let mut stacked_item = Vec::new();
+                    for s_item in items {
+                        stacked_item.push(sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
+                                          .bind(s_item)
+                                          .fetch_one(&self.pool).await
+                                          .map(|item| item.into())
+                                          .map(|item| self.apply_item_modifications(item))?
+                                          .await)
+                    }
+                    real_inventory.push(InventoryItemEntity::Stacked(stacked_item));
+                }
+            }
+        }
+        
+        Ok(InventoryEntity::new(real_inventory))
+    }
+
+    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_name: BankName) -> Result<BankEntity, GatewayError> {
+        let bank = sqlx::query_as::<_, PgInventoryEntity>("select * from bank where pchar = $1 and name = $2")
+            .bind(char_id.0)
+            .bind(bank_name.0)
+            .fetch_one(&self.pool).await?;
+        // TODO: inefficient
+        let mut real_bank = Vec::new();
+        for bank_item in bank.items.0.into_iter() {
+            match bank_item {
+                PgInventoryItemEntity::Individual(item) => {
+                    let entity = sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
+                        .bind(item)
+                        .fetch_one(&self.pool).await
+                        .map(|item| item.into())
+                        .map(|item| self.apply_item_modifications(item))?
+                        .await;
+                    real_bank.push(BankItemEntity::Individual(entity));
+                },
+                PgInventoryItemEntity::Stacked(items) => {
+                    let mut stacked_item = Vec::new();
+                    for s_item in items {
+                        stacked_item.push(sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
+                                          .bind(s_item)
+                                          .fetch_one(&self.pool).await
+                                          .map(|item| item.into())
+                                          .map(|item| self.apply_item_modifications(item))?
+                                          .await)
+                    }
+                    real_bank.push(BankItemEntity::Stacked(stacked_item));
+                }
+            }
+        }
+        
+        Ok(BankEntity::new(real_bank))
+    }
+
+    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
+        let inventory = inventory.items.iter()
+            .map(|item| {
+                match item {
+                    InventoryItemEntity::Individual(item) => {
+                        PgInventoryItemEntity::Individual(item.id.0 as i32)
+                    },
+                    InventoryItemEntity::Stacked(items) => {
+                        PgInventoryItemEntity::Stacked(items.iter().map(|i| i.id.0 as i32).collect())
+                    },
+                }
+            })
+            .collect::<Vec<_>>();
+
+        sqlx::query("insert into inventory (pchar, items) values ($1, $2) on conflict (pchar) do update set items = $2")
+            .bind(char_id.0)
+            .bind(sqlx::types::Json(inventory))
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_name: BankName) -> Result<(), GatewayError> {
+        let bank = bank.items.iter()
+            .map(|item| {
+                match item {
+                    BankItemEntity::Individual(item) => {
+                        PgInventoryItemEntity::Individual(item.id.0 as i32)
+                    },
+                    BankItemEntity::Stacked(items) => {
+                        PgInventoryItemEntity::Stacked(items.iter().map(|i| i.id.0 as i32).collect())
+                    },
+                }
+            })
+            .collect::<Vec<_>>();
+
+        sqlx::query("insert into bank (pchar, items, name) values ($1, $2, $3) on conflict (pchar, name) do update set items = $2")
+            .bind(char_id.0)
+            .bind(sqlx::types::Json(bank))
+            .bind(bank_name.0)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
+        let equips = sqlx::query_as::<_, PgEquipped>("select * from equipped where pchar = $1")
+            .bind(char_id.0)
+            .fetch_one(&self.pool)
+            .await?;
+
+        Ok(equips.into())
+    }
+
+    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equips: &EquippedEntity) -> Result<(), GatewayError> {
+        sqlx::query(r#"insert into equipped (pchar, weapon, armor, shield, unit0, unit1, unit2, unit3, mag) values ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+                       on conflict (pchar) do update set weapon=$2, armor=$3, shield=$4, unit0=$5, unit1=$6, unit2=$7, unit3=$8, mag=$9"#)
+            .bind(char_id.0)
+            .bind(equips.weapon.map(|i| i.0 as i32))
+            .bind(equips.armor.map(|i| i.0 as i32))
+            .bind(equips.shield.map(|i| i.0 as i32))
+            .bind(equips.unit[0].map(|i| i.0 as i32))
+            .bind(equips.unit[1].map(|i| i.0 as i32))
+            .bind(equips.unit[2].map(|i| i.0 as i32))
+            .bind(equips.unit[3].map(|i| i.0 as i32))
+            .bind(equips.mag.map(|i| i.0 as i32))
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
+        sqlx::query("insert into character_meseta values ($1, $2) on conflict (pchar) do update set meseta = $2")
+            .bind(char_id.0)
+            .bind(meseta.0 as i32)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
+        #[derive(sqlx::FromRow)]
+        struct PgMeseta(i32);
+        let meseta = sqlx::query_as::<_, PgMeseta>(r#"select meseta from character_meseta where pchar = $1"#)
+            .bind(char_id.0)
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(Meseta(meseta.0 as u32))
+    }
+
+    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: BankName, meseta: Meseta) -> Result<(), GatewayError> {
+        sqlx::query("insert into bank_meseta values ($1, $2, $3) on conflict (pchar, bank) do update set meseta = $3")
+            .bind(char_id.0)
+            .bind(bank.0)
+            .bind(meseta.0 as i32)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+
+    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: BankName) -> Result<Meseta, GatewayError> {
+        #[derive(sqlx::FromRow)]
+        struct PgMeseta(i32);
+        let meseta = sqlx::query_as::<_, PgMeseta>(r#"select meseta from bank_meseta where pchar = $1 and bank = $2"#)
+            .bind(char_id.0)
+            .bind(bank.0)
+            .fetch_one(&self.pool)
+            .await?;
+        Ok(Meseta(meseta.0 as u32))
+    }
+
+    async fn set_character_exp(&mut self, char_id: &CharacterEntityId, exp: u32) -> Result<(), GatewayError> {
+        let q = r#"update player_character set exp=$1 where id=$2;"#;
+        sqlx::query(q)
+            .bind(exp as i32)
+            .bind(char_id.0 as i32)
+            .execute(&self.pool)
+            .await?;
+        Ok(())
+    }
+}

src/entity/item/armor.rs

@@ -1,5 +1,5 @@
 use serde::{Serialize, Deserialize};
-use crate::item::ItemEntityId;
+use crate::entity::item::ItemEntityId;
 
 #[derive(Debug, Copy, Clone)]
 pub enum ItemParseError {
@@ -289,7 +289,7 @@ impl ArmorType {
 }
 
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum ArmorModifier {
     AddSlot {
         addslot: ItemEntityId,
@@ -297,7 +297,7 @@ pub enum ArmorModifier {
 }
 
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Armor {
     pub armor: ArmorType,
     pub dfp: u8,

src/entity/item/esweapon.rs

@@ -121,7 +121,7 @@ impl ESWeaponType {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, strum_macros::EnumIter)]
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, strum_macros::EnumIter)]
 pub enum ESWeaponSpecial {
     Jellen = 1,
     Zalure,
@@ -169,7 +169,7 @@ impl ESWeaponSpecial {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ESWeapon {
     pub esweapon: ESWeaponType,
     pub special: Option<ESWeaponSpecial>,

src/entity/item/mag.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
-use thiserror::Error;
 use serde::{Serialize, Deserialize};
-use crate::item::tool::ToolType;
-use crate::character::{CharacterClass, SectionID};
-use crate::item::ItemEntityId;
+use crate::entity::item::tool::ToolType;
+use crate::entity::character::{CharacterClass, SectionID};
+use crate::entity::item::ItemEntityId;
 use std::io::Read;
 
 use std::cmp::Ordering::{Less, Greater, Equal};
@@ -420,9 +419,9 @@ pub enum MagCell {
 }
 
 impl std::convert::TryFrom<ToolType> for MagCell {
-    type Error = MagCellError;
+    type Error = ();
 
-    fn try_from(tool: ToolType) -> Result<MagCell, MagCellError> {
+    fn try_from(tool: ToolType) -> Result<MagCell, ()> {
         match tool {
             ToolType::CellOfMag502 => Ok(MagCell::CellOfMag502),
             ToolType::CellOfMag213 => Ok(MagCell::CellOfMag213),
@@ -449,7 +448,7 @@ impl std::convert::TryFrom<ToolType> for MagCell {
             ToolType::YahoosEngine => Ok(MagCell::YahoosEngine),
             ToolType::DPhotonCore => Ok(MagCell::DPhotonCore),
             ToolType::LibertaKit => Ok(MagCell::LibertaKit),
-            _ => Err(MagCellError::IsNotMagCell),
+            _ => Err(()),
         }
     }
 }
@@ -510,18 +509,9 @@ impl MagAttributeOrdering {
     }
 }
 
-
-#[derive(Error, Debug)]
-pub enum MagCellError {
-    #[error("not a mag cell")]
-    IsNotMagCell,
-    #[error("mag is rare")]
-    IsRareMag,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum MagModifier {
-    FeedMag {
+    FeedMag{
         food: ItemEntityId,
     },
     BankMag, // when putting a mag in the bank it truncates the values which has applications when raising degenerate mags
@@ -529,7 +519,7 @@ pub enum MagModifier {
     OwnerChange(CharacterClass, SectionID)
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, enum_utils::FromStr)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize, enum_utils::FromStr)]
 pub enum PhotonBlast {
     Farlla,
     Estlla,
@@ -539,7 +529,7 @@ pub enum PhotonBlast {
     MyllaYoulla,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Mag {
     pub mag: MagType,
     def: u16,
@@ -1057,10 +1047,7 @@ impl Mag {
     }
 
     // TODO: this needs more checks on validity
-    pub fn apply_mag_cell(&mut self, mag_cell: MagCell) -> Result<(), MagCellError> {
-        if self.is_rare_item() {
-            return Err(MagCellError::IsRareMag)
-        }
+    pub fn apply_mag_cell(&mut self, mag_cell: MagCell) {
         self.mag = match mag_cell {
             MagCell::CellOfMag502 => {
                 match self.id {
@@ -1110,11 +1097,11 @@ impl Mag {
             MagCell::YahoosEngine => MagType::Yahoo,
             MagCell::DPhotonCore => MagType::GaelGiel,
             MagCell::LibertaKit => MagType::Agastya,
-        };
-        Ok(())
+        }
     }
 
-    pub fn is_rare_item(&self) -> bool {
+    // TODO: is this even needed? mags are not shop sellable...yet
+    pub fn is_rare_item(self) -> bool {
         matches!(
             self.mag,
             MagType::Pitri

src/entity/item/mod.rs

@@ -9,27 +9,19 @@ pub mod mag;
 pub mod esweapon;
 
 use serde::{Serialize, Deserialize};
-use crate::character::CharacterEntityId;
-use crate::room::RoomEntityId;
-use maps::area::MapArea;
-use maps::monster::MonsterType;
-//use crate::ship::drops::ItemDropType;
+use crate::entity::character::CharacterEntityId;
+use crate::ship::map::MapArea;
+use crate::ship::drops::ItemDropType;
 
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(PartialEq, Copy, Clone, Debug, Hash, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct ItemEntityId(pub u32);
 #[derive(Hash, PartialEq, Eq, Debug, Clone)]
 pub struct ItemId(u32);
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, derive_more::Display)]
 pub struct BankName(pub String);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct TradeId(pub u32);
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize, derive_more::Display)]
-pub enum BankIdentifier {
-    Character,
-    Shared(BankName),
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ItemNote {
     CharacterCreation {
@@ -37,16 +29,8 @@ pub enum ItemNote {
     },
     EnemyDrop {
         character_id: CharacterEntityId,
-        room_id: RoomEntityId,
-        monster_type: MonsterType,
-        map_area: MapArea,
-        x: f32,
-        y: f32,
-        z: f32,
-    },
-    BoxDrop {
-        character_id: CharacterEntityId,
-        room_id: RoomEntityId,
+        //monster_type: MonsterType,
+        //droprate: f32,
         map_area: MapArea,
         x: f32,
         y: f32,
@@ -56,44 +40,27 @@ pub enum ItemNote {
         character_id: CharacterEntityId,
     },
     PlayerDrop {
-        character_id: CharacterEntityId,
         map_area: MapArea,
         x: f32,
         y: f32,
         z: f32,
     },
-    Consumed {
-        character_id: CharacterEntityId,
-    },
+    Consumed,
     FedToMag {
-        character_id: CharacterEntityId,
         mag: ItemEntityId,
     },
     BoughtAtShop {
         character_id: CharacterEntityId,
     },
-    SoldToShop {
-        character_id: CharacterEntityId,
-    },
+    SoldToShop,
     Trade {
-        trade_id: TradeId,
+        id: TradeId,
         character_to: CharacterEntityId,
         character_from: CharacterEntityId,
     },
-    Withdraw {
-        character_id: CharacterEntityId,
-        bank: BankIdentifier,
-    },
-    Deposit {
-        character_id: CharacterEntityId,
-        bank: BankIdentifier,
-    },
-    FloorLimitReached {
-        map_area: MapArea,
-    },
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct Meseta(pub u32);
 
 impl Meseta {
@@ -118,12 +85,12 @@ pub enum ItemType {
     ESWeapon(esweapon::ESWeaponType),
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ItemParseError {
     InvalidBytes
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum ItemDetail {
     Weapon(weapon::Weapon),
     Armor(armor::Armor),
@@ -156,6 +123,26 @@ impl ItemDetail {
         }
     }
 
+    pub fn parse_item_from_bytes(data: [u8; 16]) -> Option<ItemDropType> {
+        let item_type = weapon::WeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::Weapon)
+            .or_else(|_| armor::ArmorType::parse_type([data[0],data[1],data[2]]).map(ItemType::Armor))
+            .or_else(|_| shield::ShieldType::parse_type([data[0],data[1],data[2]]).map(ItemType::Shield))
+            .or_else(|_| unit::UnitType::parse_type([data[0],data[1],data[2]]).map(ItemType::Unit))
+            .or_else(|_| mag::MagType::parse_type([data[0],data[1],data[2]]).map(ItemType::Mag))
+            .or_else(|_| tool::ToolType::parse_type([data[0],data[1],data[2]]).map(ItemType::Tool))
+            .or_else(|_| esweapon::ESWeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::ESWeapon)).ok()?;
+            
+        match item_type {
+            ItemType::Weapon(_w) => Some(ItemDropType::Weapon(weapon::Weapon::from_bytes(data).ok()?)),
+            ItemType::Armor(_a) => Some(ItemDropType::Armor(armor::Armor::from_bytes(data).ok()?)),
+            ItemType::Shield(_s) => Some(ItemDropType::Shield(shield::Shield::from_bytes(data).ok()?)),
+            ItemType::Unit(_u) => Some(ItemDropType::Unit(unit::Unit::from_bytes(data).ok()?)),
+            ItemType::Mag(_m) => Some(ItemDropType::Mag(mag::Mag::from_bytes(data).ok()?)),
+            ItemType::Tool(_t) => Some(ItemDropType::Tool(tool::Tool::from_bytes(data).ok()?)),
+            _ => None,
+        }
+    }
+
     pub fn as_client_bytes(&self) -> [u8; 16] {
         match self {
             ItemDetail::Weapon(w) => w.as_bytes(),
@@ -189,7 +176,7 @@ pub struct NewItemEntity {
     pub item: ItemDetail,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ItemEntity {
     pub id: ItemEntityId,
     pub item: ItemDetail,
@@ -244,13 +231,6 @@ impl InventoryItemEntity {
             _ => None,
         }
     }
-
-    pub fn stacked(&self) -> Option<&Vec<ItemEntity>> {
-        match self {
-            InventoryItemEntity::Stacked(i) => Some(i),
-            _ => None,
-        }
-    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -337,15 +317,3 @@ impl BankEntity {
         }
     }
 }
-
-#[derive(Clone, Debug)]
-pub struct TradeEntity {
-    pub id: TradeId,
-    pub character1: CharacterEntityId,
-    pub character2: CharacterEntityId,
-}
-
-#[derive(Clone, Debug)]
-pub enum ItemModifier {
-    WeaponModifier(weapon::WeaponModifier),
-}

src/entity/item/shield.rs

@@ -519,7 +519,7 @@ impl ShieldType {
 }
 
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Shield {
     pub shield: ShieldType,
     pub dfp: u8,

src/entity/item/tool.rs

@@ -212,43 +212,7 @@ impl ToolType {
                  ToolType::Addslot |
                  ToolType::PhotonDrop |
                  ToolType::PhotonSphere |
-                 ToolType::PhotonCrystal |
-                 ToolType::JackOLantern |
-                 ToolType::ChristmasPresent |
-                 ToolType::EasterEgg |
-                 ToolType::CellOfMag502 |
-                 ToolType::CellOfMag213 |
-                 ToolType::PartsOfRobochao |
-                 ToolType::HeartOfOpaOpa |
-                 ToolType::HeartOfPian |
-                 ToolType::HeartOfChao |
-                 ToolType::HeartOfChuChu |
-                 ToolType::HeartOfAngel |
-                 ToolType::HeartOfDevil |
-                 ToolType::KitOfHamburger |
-                 ToolType::PanthersSpirit |
-                 ToolType::KitOfMark3 |
-                 ToolType::KitOfMasterSystem |
-                 ToolType::KitOfGenesis |
-                 ToolType::KitOfSegaSaturn |
-                 ToolType::KitOfDreamcast |
-                 ToolType::HeartOfKapuKapu |
-                 ToolType::Tablet |
-                 ToolType::DragonScale |
-                 ToolType::HeavenStrikerCoat |
-                 ToolType::PioneerParts |
-                 ToolType::AmitiesMemo |
-                 ToolType::HeartOfMorolian |
-                 ToolType::RappysBeak |
-                 ToolType::YahoosEngine |
-                 ToolType::DPhotonCore |
-                 ToolType::LibertaKit |
-                 ToolType::CellOfMag0503 |
-                 ToolType::CellOfMag0504 |
-                 ToolType::CellOfMag0505 |
-                 ToolType::CellOfMag0506 |
-                 ToolType::CellOfMag0507
-        )
+                 ToolType::PhotonCrystal)
     }
 
     pub fn max_stack(&self) -> usize {
@@ -280,41 +244,6 @@ impl ToolType {
             ToolType::PhotonDrop => 99,
             ToolType::PhotonSphere => 99,
             ToolType::PhotonCrystal => 99,
-            ToolType::JackOLantern => 99,
-            ToolType::ChristmasPresent => 99,
-            ToolType::EasterEgg => 99,
-            ToolType::CellOfMag502 => 99,
-            ToolType::CellOfMag213 => 99,
-            ToolType::PartsOfRobochao => 99,
-            ToolType::HeartOfOpaOpa => 99,
-            ToolType::HeartOfPian => 99,
-            ToolType::HeartOfChao => 99,
-            ToolType::HeartOfChuChu => 99,
-            ToolType::HeartOfAngel => 99,
-            ToolType::HeartOfDevil => 99,
-            ToolType::KitOfHamburger => 99,
-            ToolType::PanthersSpirit => 99,
-            ToolType::KitOfMark3 => 99,
-            ToolType::KitOfMasterSystem => 99,
-            ToolType::KitOfGenesis => 99,
-            ToolType::KitOfSegaSaturn => 99,
-            ToolType::KitOfDreamcast => 99,
-            ToolType::HeartOfKapuKapu => 99,
-            ToolType::Tablet => 99,
-            ToolType::DragonScale => 99,
-            ToolType::HeavenStrikerCoat => 99,
-            ToolType::PioneerParts => 99,
-            ToolType::AmitiesMemo => 99,
-            ToolType::HeartOfMorolian => 99,
-            ToolType::RappysBeak => 99,
-            ToolType::YahoosEngine => 99,
-            ToolType::DPhotonCore => 99,
-            ToolType::LibertaKit => 99,
-            ToolType::CellOfMag0503 => 99,
-            ToolType::CellOfMag0504 => 99,
-            ToolType::CellOfMag0505 => 99,
-            ToolType::CellOfMag0506 => 99,
-            ToolType::CellOfMag0507 => 99,
             _ => 1,
         }
     }
@@ -326,7 +255,6 @@ impl ToolType {
                  ToolType::HeartOfOpaOpa |
                  ToolType::HeartOfPian |
                  ToolType::HeartOfChao |
-                 ToolType::HeartOfChuChu |
                  ToolType::HeartOfAngel |
                  ToolType::HeartOfDevil |
                  ToolType::KitOfHamburger |
@@ -336,7 +264,6 @@ impl ToolType {
                  ToolType::KitOfGenesis |
                  ToolType::KitOfSegaSaturn |
                  ToolType::KitOfDreamcast |
-                 ToolType::HeartOfKapuKapu |
                  ToolType::Tablet |
                  ToolType::DragonScale |
                  ToolType::HeavenStrikerCoat |
@@ -715,7 +642,7 @@ impl ToolType {
 }
 
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Tool {
     pub tool: ToolType,
 }
@@ -735,7 +662,7 @@ impl Tool {
     }
 
     pub fn from_bytes(data: [u8; 16]) -> Result<Tool, ItemParseError> {
-        let t = ToolType::parse_type([data[0], data[1], data[2]]);
+        let t = ToolType::parse_type([data[0], data[1], data[2]]); 
         if let Ok(t) = t {
             Ok(Tool {
                 tool: t,

src/entity/item/unit.rs

@@ -323,7 +323,7 @@ impl UnitType {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum UnitModifier {
     PlusPlus,
     Plus,
@@ -331,7 +331,7 @@ pub enum UnitModifier {
     MinusMinus,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Unit {
     pub unit: UnitType,
     pub modifier: Option<UnitModifier>,

src/entity/item/weapon.rs

@@ -1,4 +1,4 @@
-use crate::item::ItemEntityId;
+use crate::entity::item::ItemEntityId;
 use serde::{Serialize, Deserialize};
 
 #[derive(Debug, Copy, Clone)]
@@ -10,7 +10,7 @@ pub enum ItemParseError {
     InvalidWeaponAttribute,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq, Ord, PartialOrd, Serialize, Deserialize)]
 pub enum Attribute {
     Native = 1,
     ABeast,
@@ -32,7 +32,7 @@ impl Attribute {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub struct WeaponAttribute {
     pub attr: Attribute,
     pub value: i8,
@@ -45,7 +45,7 @@ impl WeaponAttribute {
 }
 
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, strum_macros::EnumIter)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize, strum_macros::EnumIter)]
 pub enum WeaponSpecial {
     Draw = 1,
     Drain,
@@ -1424,14 +1424,14 @@ impl WeaponType {
 }
 
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum TekSpecialModifier {
     Plus,
     Neutral,
     Minus,
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum TekPercentModifier {
     PlusPlus,
     Plus,
@@ -1440,7 +1440,7 @@ pub enum TekPercentModifier {
     MinusMinus,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum WeaponModifier {
     AddPercents {
         attr: WeaponAttribute,
@@ -1457,7 +1457,7 @@ pub enum WeaponModifier {
     },
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Weapon {
     pub weapon: WeaponType,
     pub special: Option<WeaponSpecial>,
@@ -1479,52 +1479,44 @@ impl Weapon {
     }
 
     pub fn apply_modifier(&mut self, modifier: &WeaponModifier) {
-        match modifier {
-            WeaponModifier::Tekked{special, percent, grind} => {
-                match special {
-                    TekSpecialModifier::Plus => {
-                        self.special = self.special.map(|special| {
-                            special.rank_up()
-                        });
-                    },
-                    TekSpecialModifier::Minus => {
-                        self.special = self.special.map(|special| {
-                            special.rank_down()
-                        });
-                    },
-                    TekSpecialModifier::Neutral => {
-                    },
-                }
-                for i in 0..3 {
-                    self.attrs[i] = self.attrs[i].map(|mut attr| {
-                        match percent {
-                            TekPercentModifier::PlusPlus => {
-                                attr.value += 10;
-                            },
-                            TekPercentModifier::Plus => {
-                                attr.value += 5;
-                            },
-                            TekPercentModifier::MinusMinus => {
-                                attr.value -= 10;
-                            },
-                            TekPercentModifier::Minus => {
-                                attr.value -= 5;
-                            },
-                            TekPercentModifier::Neutral => {
-                            }
-                        }
-                        attr
+        if let WeaponModifier::Tekked{special, percent, grind} = modifier {
+            match special {
+                TekSpecialModifier::Plus => {
+                    self.special = self.special.map(|special| {
+                        special.rank_up()
                     });
-                }
-                self.grind = std::cmp::max(self.grind as i32 + grind, 0) as u8;
-                self.tekked = true;
-            },
-            WeaponModifier::AddGrind {amount, ..} => {
-                self.grind += *amount as u8;
-            },
-            WeaponModifier::AddPercents {..} => {
-                // TODO
+                },
+                TekSpecialModifier::Minus => {
+                    self.special = self.special.map(|special| {
+                        special.rank_down()
+                    });
+                },
+                TekSpecialModifier::Neutral => {
+                },
             }
+            for i in 0..3 {
+                self.attrs[i] = self.attrs[i].map(|mut attr| {
+                    match percent {
+                        TekPercentModifier::PlusPlus => {
+                            attr.value += 10;
+                        },
+                        TekPercentModifier::Plus => {
+                            attr.value += 5;
+                        },
+                        TekPercentModifier::MinusMinus => {
+                            attr.value -= 10;
+                        },
+                        TekPercentModifier::Minus => {
+                            attr.value -= 5;
+                        },
+                        TekPercentModifier::Neutral => {
+                        }
+                    }
+                    attr
+                });
+            }
+            self.grind = std::cmp::max(self.grind as i32 + grind, 0) as u8;
+            self.tekked = true;
         }
     }
 

src/entity/mod.rs

@@ -2,4 +2,3 @@ pub mod gateway;
 pub mod account;
 pub mod character;
 pub mod item;
-pub mod room;

src/entity/src/gateway/inmemory.rs

@@ -1,787 +0,0 @@
-use std::collections::BTreeMap;
-use std::convert::TryInto;
-use futures::future::{Future, BoxFuture};
-
-use crate::account::*;
-use crate::character::*;
-use crate::gateway::{EntityGateway, EntityGatewayTransaction, GatewayError};
-use crate::item::*;
-use crate::room::*;
-
-use async_std::sync::{Arc, Mutex};
-
-#[derive(Clone)]
-pub struct InMemoryGatewayTransaction {
-    working_gateway: InMemoryGateway,
-    original_gateway: InMemoryGateway,
-}
-
-
-fn copy_if_needed<K, V>(working_table: &mut BTreeMap<K, V>, original_table: &BTreeMap<K, V>, key: K) -> Option<()>
-where
-    K: Ord + Copy,
-    V: Clone,
-{
-    if let std::collections::btree_map::Entry::Vacant(e) = working_table.entry(key) {
-        e.insert(original_table.get(&key)?.clone());
-    }
-
-    Some(())
-}
-
-// functions here have been skipped as they are not used in transactions, add as needed
-#[async_trait::async_trait]
-impl EntityGateway for InMemoryGatewayTransaction {
-    type Transaction<'t> = InMemoryGatewayTransaction where Self: 't;
-
-    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
-        self.working_gateway.create_user(user).await
-    }
-
-    async fn get_user_by_id(&mut self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
-        match self.working_gateway.get_user_by_id(id).await {
-            Ok(user) => Ok(user),
-            Err(_) => {
-                self.original_gateway.get_user_by_id(id).await
-            }
-        }
-    }
-
-    async fn get_user_by_name(&mut self, username: String) -> Result<UserAccountEntity, GatewayError> {
-        match self.working_gateway.get_user_by_name(username.clone()).await {
-            Ok(user) => Ok(user),
-            Err(_) => {
-                self.original_gateway.get_user_by_name(username).await
-            }
-        }
-    }
-
-    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError>  {
-        self.working_gateway.save_user(user).await
-    }
-
-    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
-        self.working_gateway.create_user_settings(settings).await
-    }
-
-    async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
-        match self.working_gateway.get_user_settings_by_user(user).await {
-            Ok(user) => Ok(user),
-            Err(_) => {
-                self.original_gateway.get_user_settings_by_user(user).await
-            }
-        }
-    }
-
-    async fn save_user_settings(&mut self, settings: &UserSettingsEntity) -> Result<(), GatewayError>  {
-        self.original_gateway.save_user_settings(settings).await
-    }
-
-    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError>  {
-        copy_if_needed(&mut *self.working_gateway.characters.lock().await,
-                       &*self.original_gateway.characters.lock().await,
-                       char.id
-        );
-        self.working_gateway.save_character(char).await
-    }
-
-    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
-        self.working_gateway.create_item(item).await
-    }
-
-    async fn add_item_note(&mut self, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError> {
-        self.working_gateway.add_item_note(item_id, item_note).await
-    }
-
-    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
-        self.working_gateway.feed_mag(mag_item_id, tool_item_id).await
-    }
-
-    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
-        self.working_gateway.change_mag_owner(mag_item_id, character).await
-    }
-
-    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
-        self.working_gateway.use_mag_cell(mag_item_id, mag_cell_id).await
-    }
-
-    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: &weapon::WeaponModifier) -> Result<(), GatewayError> {
-        self.working_gateway.add_weapon_modifier(item_id, modifier).await
-    }
-
-    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
-        match self.working_gateway.get_character_inventory(char_id).await {
-            Ok(inventory) => Ok(inventory),
-            Err(_) => {
-                self.original_gateway.get_character_inventory(char_id).await
-            }
-        }
-    }
-
-    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError> {
-        match self.working_gateway.get_character_bank(char_id, bank_identifier).await {
-            Ok(bank) => Ok(bank),
-            Err(_) => {
-                self.original_gateway.get_character_bank(char_id, bank_identifier).await
-            }
-        }
-    }
-
-    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
-        self.working_gateway.set_character_inventory(char_id, inventory).await
-    }
-
-    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
-        self.working_gateway.set_character_bank(char_id, bank, bank_identifier).await
-    }
-
-    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
-        match self.working_gateway.get_character_equips(char_id).await {
-            Ok(equips) => Ok(equips),
-            Err(_) => {
-                self.original_gateway.get_character_equips(char_id).await
-            }
-        }
-    }
-
-    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> {
-        self.working_gateway.set_character_equips(char_id, equipped).await
-    }
-
-    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
-        self.working_gateway.set_character_meseta(char_id, meseta).await
-    }
-
-    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
-        match self.working_gateway.get_character_meseta(char_id).await {
-            Ok(meseta) => Ok(meseta),
-            Err(_) => {
-                self.original_gateway.get_character_meseta(char_id).await
-            }
-        }
-    }
-
-    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier, meseta: Meseta) -> Result<(), GatewayError> {
-        self.working_gateway.set_bank_meseta(char_id, bank_identifier, meseta).await
-    }
-
-    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError> {
-        match self.working_gateway.get_bank_meseta(char_id, bank_identifier).await {
-            Ok(meseta) => Ok(meseta),
-            Err(_) => {
-                self.original_gateway.get_bank_meseta(char_id, bank_identifier).await
-            }
-        }
-    }
-
-    async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
-        self.working_gateway.create_trade(char_id1, char_id2).await
-    }
-
-    async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> {
-        copy_if_needed(&mut *self.working_gateway.characters.lock().await,
-                       &*self.original_gateway.characters.lock().await,
-                       *char_id
-        );
-        self.working_gateway.set_character_playtime(char_id, playtime).await
-    }
-}
-
-#[async_trait::async_trait]
-impl EntityGatewayTransaction for InMemoryGatewayTransaction {
-    type ParentGateway = InMemoryGatewayTransaction;
-
-    fn gateway(&mut self) -> &mut Self::ParentGateway {
-        self
-    }
-
-    async fn commit(mut self) -> Result<(), GatewayError> {
-        self.original_gateway.users.lock().await.extend(self.working_gateway.users.lock().await.clone());
-        self.original_gateway.user_settings.lock().await.extend(self.working_gateway.user_settings.lock().await.clone());
-        self.original_gateway.characters.lock().await.extend(self.working_gateway.characters.lock().await.clone());
-        self.original_gateway.character_meseta.lock().await.extend(self.working_gateway.character_meseta.lock().await.clone());
-        self.original_gateway.bank_meseta.lock().await.extend(self.working_gateway.bank_meseta.lock().await.clone());
-        self.original_gateway.shared_bank_meseta.lock().await.extend(self.working_gateway.shared_bank_meseta.lock().await.clone());
-        self.original_gateway.items.lock().await.extend(self.working_gateway.items.lock().await.clone());
-        self.original_gateway.inventories.lock().await.extend(self.working_gateway.inventories.lock().await.clone());
-        self.original_gateway.character_banks.lock().await.extend(self.working_gateway.character_banks.lock().await.clone());
-        self.original_gateway.shared_banks.lock().await.extend(self.working_gateway.shared_banks.lock().await.clone());
-        self.original_gateway.equips.lock().await.extend(self.working_gateway.equips.lock().await.clone());
-        self.original_gateway.mag_modifiers.lock().await.extend(self.working_gateway.mag_modifiers.lock().await.clone());
-        self.original_gateway.weapon_modifiers.lock().await.extend(self.working_gateway.weapon_modifiers.lock().await.clone());
-        self.original_gateway.trades.lock().await.extend(self.working_gateway.trades.lock().await.clone());
-
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-enum InventoryItemElement {
-    Individual(ItemEntityId),
-    Stacked(Vec<ItemEntityId>),
-}
-
-#[derive(Clone)]
-pub struct InMemoryGateway {
-    users: Arc<Mutex<BTreeMap<UserAccountId, UserAccountEntity>>>,
-    user_settings: Arc<Mutex<BTreeMap<UserSettingsId, UserSettingsEntity>>>,
-    characters: Arc<Mutex<BTreeMap<CharacterEntityId, CharacterEntity>>>,
-    character_meseta: Arc<Mutex<BTreeMap<CharacterEntityId, Meseta>>>,
-    bank_meseta: Arc<Mutex<BTreeMap<CharacterEntityId, Meseta>>>,
-    shared_bank_meseta: Arc<Mutex<BTreeMap<(UserAccountId, BankName), Meseta>>>,
-    items: Arc<Mutex<BTreeMap<ItemEntityId, ItemEntity>>>,
-    inventories: Arc<Mutex<BTreeMap<CharacterEntityId, Vec<InventoryItemElement>>>>,
-    character_banks: Arc<Mutex<BTreeMap<CharacterEntityId, BankEntity>>>,
-    shared_banks: Arc<Mutex<BTreeMap<(UserAccountId, BankName), BankEntity>>>,
-    equips: Arc<Mutex<BTreeMap<CharacterEntityId, EquippedEntity>>>,
-    mag_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<mag::MagModifier>>>>,
-    weapon_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<weapon::WeaponModifier>>>>,
-    trades: Arc<Mutex<Vec<TradeEntity>>>,
-}
-
-impl Default for InMemoryGateway {
-    fn default() -> InMemoryGateway {
-        InMemoryGateway {
-            users: Arc::new(Mutex::new(BTreeMap::new())),
-            user_settings: Arc::new(Mutex::new(BTreeMap::new())),
-            characters: Arc::new(Mutex::new(BTreeMap::new())),
-            character_meseta: Arc::new(Mutex::new(BTreeMap::new())),
-            bank_meseta: Arc::new(Mutex::new(BTreeMap::new())),
-            shared_bank_meseta: Arc::new(Mutex::new(BTreeMap::new())),
-            items: Arc::new(Mutex::new(BTreeMap::new())),
-            inventories: Arc::new(Mutex::new(BTreeMap::new())),
-            character_banks: Arc::new(Mutex::new(BTreeMap::new())),
-            shared_banks: Arc::new(Mutex::new(BTreeMap::new())),
-            equips: Arc::new(Mutex::new(BTreeMap::new())),
-            mag_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
-            weapon_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
-            trades: Arc::new(Mutex::new(Vec::new())),
-        }
-    }
-}
-
-fn apply_modifiers(items: &BTreeMap<ItemEntityId, ItemEntity>,
-                   weapon_modifiers: &BTreeMap<ItemEntityId, Vec<weapon::WeaponModifier>>,
-                   mag_modifiers: &BTreeMap<ItemEntityId, Vec<mag::MagModifier>>,
-                   inventory: InventoryEntity ) -> InventoryEntity {
-    let inventory_items = inventory.items.into_iter()
-        .map(|item| {
-            item.map_individual(|mut item| {
-                item.item = match item.item {
-                    ItemDetail::Weapon(mut weapon) => {
-                        if let Some(weapon_modifiers) = weapon_modifiers.get(&item.id) {
-                            for weapon_modifier in weapon_modifiers.iter() {
-                                weapon.apply_modifier(weapon_modifier);
-                            }
-                        }
-                        ItemDetail::Weapon(weapon)
-                    },
-                    ItemDetail::Mag(mag) => {
-                        let mut mag = mag::Mag::baby_mag(mag.color as u16);
-                        if let Some(mag_modifiers) = mag_modifiers.get(&item.id) {
-                            for mag_modifier in mag_modifiers.iter() {
-                                match mag_modifier {
-                                    mag::MagModifier::FeedMag {food} => {
-                                        if let Some(mag_feed) = items.get(food) {
-                                            if let ItemDetail::Tool(mag_feed) = mag_feed.item {
-                                                mag.feed(mag_feed.tool)
-                                            }
-                                        }
-                                    },
-                                    mag::MagModifier::OwnerChange(class, section_id) => {
-                                        mag.change_owner(*class, *section_id)
-                                    },
-                                    mag::MagModifier::MagCell(mag_cell_id) => {
-                                        if let Some(mag_cell) = items.get(mag_cell_id) {
-                                            if let ItemDetail::Tool(mag_cell) = mag_cell.item {
-                                                mag.apply_mag_cell(mag_cell.tool.try_into().unwrap()).unwrap()
-                                            }
-                                        }
-                                    },
-                                    _ => {}
-                                }
-                            }
-                        }
-                        ItemDetail::Mag(mag)
-                    }
-                    _ => {
-                        item.item
-                    }
-                };
-
-                item
-            })
-        })
-        .collect();
-    InventoryEntity::new(inventory_items)
-}
-
-#[async_trait::async_trait]
-impl EntityGateway for InMemoryGateway {
-    type Transaction<'t> = InMemoryGatewayTransaction where Self: 't;
-
-    fn with_transaction<'a, F, Fut, R>(&'a mut self, func: F) -> BoxFuture<'a, Result<R, anyhow::Error>>
-    where
-        Fut: Future<Output = Result<(Self::Transaction<'a>, R), anyhow::Error>> + Send + 'a,
-        F: FnOnce(Self::Transaction<'a>) -> Fut + Send + 'a,
-        R: Send,
-    {
-        Box::pin(async move {
-            let users = self.users.lock().await.clone();
-            let user_settings = self.user_settings.lock().await.clone();
-            let characters = self.characters.lock().await.clone();
-            let character_meseta = self.character_meseta.lock().await.clone();
-            let bank_meseta = self.bank_meseta.lock().await.clone();
-            let shared_bank_meseta = self.shared_bank_meseta.lock().await.clone();
-            let items = self.items.lock().await.clone();
-            let inventories = self.inventories.lock().await.clone();
-            let character_banks = self.character_banks.lock().await.clone();
-            let shared_banks = self.shared_banks.lock().await.clone();
-            let equips = self.equips.lock().await.clone();
-            let mag_modifiers = self.mag_modifiers.lock().await.clone();
-            let weapon_modifiers = self.weapon_modifiers.lock().await.clone();
-            let trades = self.trades.lock().await.clone();
-
-            let working_gateway = InMemoryGateway {
-                users: Arc::new(Mutex::new(users)),
-                user_settings: Arc::new(Mutex::new(user_settings)),
-                characters: Arc::new(Mutex::new(characters)),
-                character_meseta: Arc::new(Mutex::new(character_meseta)),
-                bank_meseta: Arc::new(Mutex::new(bank_meseta)),
-                shared_bank_meseta: Arc::new(Mutex::new(shared_bank_meseta)),
-                items: Arc::new(Mutex::new(items)),
-                inventories: Arc::new(Mutex::new(inventories)),
-                character_banks: Arc::new(Mutex::new(character_banks)),
-                shared_banks: Arc::new(Mutex::new(shared_banks)),
-                equips: Arc::new(Mutex::new(equips)),
-                mag_modifiers: Arc::new(Mutex::new(mag_modifiers)),
-                weapon_modifiers: Arc::new(Mutex::new(weapon_modifiers)),
-                trades: Arc::new(Mutex::new(trades)),
-            };
-
-            let transaction = InMemoryGatewayTransaction {
-                working_gateway,
-                original_gateway: self.clone(),
-            };
-
-            let (transaction, result) = func(transaction).await?;
-
-            transaction.commit().await?;
-            Ok(result)
-        })
-    }
-
-    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
-        let mut users = self.users.lock().await;
-        let id = users
-            .iter()
-            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
-            + 1;
-        let user = UserAccountEntity {
-            id: UserAccountId(id),
-            username: user.username,
-            password: user.password,
-            guildcard: user.guildcard,
-            team_id: user.team_id,
-            banned_until: user.banned_until,
-            muted_until: user.muted_until,
-            created_at: chrono::Utc::now(),
-            flags: user.flags,
-            activated: user.activated,
-            at_login: false,
-            at_character: false,
-            at_ship: false,
-        };
-        users.insert(user.id, user.clone());
-        Ok(user)
-    }
-
-    async fn get_user_by_id(&mut self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
-        let users = self.users.lock().await;
-        users.get(&id).cloned().ok_or(GatewayError::Error)
-    }
-
-    async fn get_user_by_name(&mut self, username: String) -> Result<UserAccountEntity, GatewayError> {
-        let users = self.users.lock().await;
-        users
-            .iter()
-            .find(|(_, k)| k.username == username)
-            .map(|(_, k)| k.clone())
-            .ok_or(GatewayError::Error)
-    }
-
-    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError>  {
-        let mut users = self.users.lock().await;
-        users.insert(user.id, user.clone());
-        Ok(())
-    }
-
-    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
-        let mut user_settings = self.user_settings.lock().await;
-        let id = user_settings
-            .iter()
-            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
-            + 1;
-        let new_settings = UserSettingsEntity {
-            id: UserSettingsId(id),
-            user_id: settings.user_id,
-            settings: settings.settings,
-        };
-        user_settings.insert(new_settings.id, new_settings.clone());
-        Ok(new_settings)
-    }
-
-    async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
-        let user_settings = self.user_settings.lock().await;
-        user_settings
-            .iter()
-            .find(|(_, k)| k.user_id == user.id)
-            .map(|(_, k)| k.clone())
-            .ok_or(GatewayError::Error)
-    }
-
-    async fn save_user_settings(&mut self, settings: &UserSettingsEntity) -> Result<(), GatewayError>  {
-        let mut user_settings = self.user_settings.lock().await;
-        user_settings.insert(settings.id, settings.clone());
-        Ok(())
-    }
-
-    async fn get_characters_by_user(&mut self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
-        let characters = self.characters.lock().await;
-        const NONE: Option<CharacterEntity> = None;
-        let mut chars = [NONE; 4];
-        characters
-            .iter()
-            .filter(|(_, c)| c.user_id == user.id)
-            .for_each(|(_, c)| chars[c.slot as usize] = Some(c.clone()));
-        Ok(chars)
-    }
-
-    async fn create_character(&mut self, character: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
-        let mut characters = self.characters.lock().await;
-        let id = characters
-            .iter()
-            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
-            + 1;
-
-        let new_character = CharacterEntity {
-            id: CharacterEntityId(id),
-            user_id: character.user_id,
-            slot: character.slot,
-            name: character.name,
-            exp: character.exp,
-            char_class: character.char_class,
-            section_id: character.section_id,
-            appearance: character.appearance,
-            techs: character.techs,
-            config: character.config,
-            info_board: character.info_board,
-            guildcard: character.guildcard,
-            materials: character.materials,
-            tech_menu: character.tech_menu,
-            option_flags: character.option_flags,
-            playtime: 0,
-        };
-        characters.insert(new_character.id, new_character.clone());
-        Ok(new_character)
-    }
-
-    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError>  {
-        let mut characters = self.characters.lock().await;
-        characters.insert(char.id, char.clone());
-        Ok(())
-    }
-
-    async fn get_guild_card_data_by_user(&mut self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
-        Ok(GuildCardDataEntity::new(user.id))
-    }
-
-    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
-        let mut items = self.items.lock().await;
-        let id = items
-            .iter()
-            .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
-            + 1;
-        let new_item = ItemEntity {
-            id: ItemEntityId(id),
-            item: item.item,
-        };
-        items.insert(ItemEntityId(id), new_item.clone());
-        Ok(new_item)
-    }
-
-    async fn add_item_note(&mut self, _item_id: &ItemEntityId, _item_note: ItemNote) -> Result<(), GatewayError> {
-        Ok(())
-    }
-
-    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
-        self.mag_modifiers.lock().await
-            .entry(*mag_item_id)
-            .or_insert_with(Vec::new)
-            .push(mag::MagModifier::FeedMag {
-                food: *tool_item_id
-            });
-        Ok(())
-    }
-
-    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
-        self.mag_modifiers.lock().await
-            .entry(*mag_item_id)
-            .or_insert_with(Vec::new)
-            .push(mag::MagModifier::OwnerChange(character.char_class, character.section_id));
-        Ok(())
-    }
-
-    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
-        self.mag_modifiers.lock().await
-            .entry(*mag_item_id)
-            .or_insert_with(Vec::new)
-            .push(mag::MagModifier::MagCell(*mag_cell_id));
-        Ok(())
-    }
-
-    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: &weapon::WeaponModifier) -> Result<(), GatewayError> {
-        self.weapon_modifiers.lock().await
-            .entry(*item_id)
-            .or_insert_with(Vec::new)
-            .push(modifier.clone());
-        Ok(())
-    }
-
-    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
-        let inventories = self.inventories.lock().await;
-        let items = self.items.lock().await;
-        let weapon_modifiers = self.weapon_modifiers.lock().await;
-        let mag_modifiers = self.mag_modifiers.lock().await;
-        Ok(inventories
-           .iter()
-           .find(|(id, _)| **id == *char_id)
-           .map(|(_, inv)| {
-               InventoryEntity {
-                   items: inv
-                       .iter()
-                       .map(|inv_item_id| {
-                           match inv_item_id {
-                               InventoryItemElement::Individual(individual_id) => {
-                                   InventoryItemEntity::Individual(items.get(individual_id).unwrap().clone())
-                               },
-                               InventoryItemElement::Stacked(stacked_ids) => {
-                                   InventoryItemEntity::Stacked(
-                                       stacked_ids.iter()
-                                           .map(|stacked_id| {
-                                               items.get(stacked_id).unwrap().clone()
-                                           })
-                                           .collect()
-                                   )
-                               }
-                           }
-                       })
-                       .collect()
-               }
-           })
-           .map(|inv| apply_modifiers(&items, &weapon_modifiers, &mag_modifiers, inv))
-           .unwrap_or_default())
-    }
-
-    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError> {
-        match bank_identifier {
-            BankIdentifier::Character => {
-                let character_banks = self.character_banks.lock().await;
-                Ok(character_banks
-                   .iter()
-                   .find(|(id, _)| **id == *char_id)
-                   .map(|(_, b)| b.clone())
-                   .unwrap_or_default())
-            },
-            BankIdentifier::Shared(bank_name) => {
-                let user_id = self.characters
-                    .lock()
-                    .await
-                    .iter()
-                    .find(|(id, _)| **id == *char_id)
-                    .unwrap()
-                    .1
-                    .user_id;
-                let shared_banks = self.shared_banks.lock().await;
-                Ok(shared_banks
-                   .iter()
-                   .find(|((id, name), _)| *id == user_id && *name == *bank_name)
-                   .map(|(_, b)| b.clone())
-                   .unwrap_or_default())
-            }
-        }
-    }
-
-    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
-        let mut inventories = self.inventories.lock().await;
-        inventories.insert(*char_id, inventory.items
-                           .iter()
-                           .map(|inventory_item| {
-                               match inventory_item {
-                                   InventoryItemEntity::Individual(individual) => {
-                                       InventoryItemElement::Individual(individual.id)
-                                   },
-                                   InventoryItemEntity::Stacked(stacked) => {
-                                       InventoryItemElement::Stacked(
-                                           stacked.iter()
-                                               .map(|stacked| {
-                                                   stacked.id
-                                               })
-                                               .collect()
-                                       )
-                                   }
-                               }
-                           })
-                           .collect());
-        Ok(())
-    }
-
-    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
-        match bank_identifier {
-            BankIdentifier::Character => {
-                let mut character_banks = self.character_banks.lock().await;
-                character_banks.insert(*char_id, bank.clone());
-            },
-            BankIdentifier::Shared(bank_name) => {
-                let user_id = self.characters
-                    .lock()
-                    .await
-                    .iter()
-                    .find(|(id, _)| **id == *char_id)
-                    .unwrap()
-                    .1
-                    .user_id;
-                let mut shared_banks = self.shared_banks.lock().await;
-                shared_banks.insert((user_id, bank_name.clone()), bank.clone());
-            }
-        }
-
-        Ok(())
-    }
-
-    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
-        let equips = self.equips.lock().await;
-        Ok(equips
-            .iter()
-            .find(|(id, _)| **id == *char_id)
-            .map(|(_, inv)| inv.clone())
-            .unwrap_or_default())
-    }
-
-    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> {
-        let mut equips = self.equips.lock().await;
-        equips.insert(*char_id, equipped.clone());
-        Ok(())
-    }
-
-    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
-        let mut character_meseta = self.character_meseta.lock().await;
-        character_meseta.insert(*char_id, meseta);
-        Ok(())
-    }
-
-    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
-        let mut character_meseta = self.character_meseta.lock().await;
-        if let Some(meseta) = character_meseta.get_mut(char_id) {
-            Ok(*meseta)
-        }
-        else {
-            Err(GatewayError::Error)
-        }
-    }
-
-    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier, meseta: Meseta) -> Result<(), GatewayError> {
-        match bank_identifier {
-            BankIdentifier::Character => {
-                let mut bank_meseta = self.bank_meseta.lock().await;
-                bank_meseta.insert(*char_id, meseta);
-            }
-            BankIdentifier::Shared(bank_name) => {
-                let user_id = self.characters
-                    .lock()
-                    .await
-                    .iter()
-                    .find(|(id, _)| **id == *char_id)
-                    .unwrap()
-                    .1
-                    .user_id;
-                self.shared_bank_meseta
-                    .lock()
-                    .await
-                    .insert((user_id, bank_name.clone()), meseta);
-            }
-        }
-        Ok(())
-    }
-
-    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError> {
-        match bank_identifier {
-            BankIdentifier::Character => {
-                let mut bank_meseta = self.bank_meseta.lock().await;
-                if let Some(meseta) = bank_meseta.get_mut(char_id) {
-                    Ok(*meseta)
-                }
-                else {
-                    Err(GatewayError::Error)
-                }
-            },
-            BankIdentifier::Shared(bank_name) => {
-                let mut shared_bank_meseta = self.shared_bank_meseta.lock().await;
-                let user_id = self.characters
-                    .lock()
-                    .await
-                    .iter()
-                    .find(|(id, _)| **id == *char_id)
-                    .unwrap()
-                    .1
-                    .user_id;
-                if let Some(meseta) = shared_bank_meseta.get_mut(&(user_id, bank_name.clone())) {
-                    Ok(*meseta)
-                }
-                else {
-                    Ok(Meseta(0))
-                }
-            }
-        }
-    }
-
-    async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
-        let mut trades = self.trades.lock().await;
-        let id = trades.len() as u32;
-        let new_trade = TradeEntity {
-            id: TradeId(id),
-            character1: *char_id1,
-            character2: *char_id2,
-        };
-        trades.push(new_trade.clone());
-        Ok(new_trade)
-    }
-
-    async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> {
-        let mut characters = self.characters.lock().await;
-        if let Some(character) = characters.get_mut(char_id) {
-            character.playtime = playtime;
-            Ok(())
-        }
-        else {
-            Err(GatewayError::Error)
-        }
-    }
-
-    // I do not care to replicate this in testing
-    async fn create_room(&mut self, room: NewRoomEntity) -> Result<RoomEntity, GatewayError> {
-        Ok(RoomEntity {
-            id: RoomEntityId(0),
-            name: room.name,
-            section_id: room.section_id,
-            episode: room.episode,
-            difficulty: room.difficulty,
-            mode: room.mode,
-        })
-    }
-
-    // I do not care to replicate this in testing
-    async fn add_room_note(&mut self, _room_id: RoomEntityId, _note: RoomNote) -> Result<(), GatewayError> {
-        Ok(())
-    }
-}

src/entity/src/gateway/postgres/migrations/V0005__trade.sql

@@ -1,5 +0,0 @@
-create table trades (
-  id serial primary key not null,
-  character1 integer references player_character (id) not null,
-  character2 integer references player_character (id) not null
-);

src/entity/src/gateway/postgres/migrations/V0006__playtime.sql

@@ -1,2 +0,0 @@
-alter table player_character
-  add playtime integer;

src/entity/src/gateway/postgres/migrations/V0007__player_keyconfig.sql

@@ -1,3 +0,0 @@
-alter table player_character
-  add keyboard_config bytea not null,
-  add gamepad_config bytea not null;

src/entity/src/gateway/postgres/migrations/V0008__playtime_not_null.sql

@@ -1,5 +0,0 @@
-alter table player_character
-  drop column playtime;
-
-alter table player_character
-  add playtime integer not null;

src/entity/src/gateway/postgres/migrations/V0009__no_player_keyconfig.sql

@@ -1,3 +0,0 @@
-alter table player_character
-  drop column keyboard_config,
-  drop column gamepad_config;

src/entity/src/gateway/postgres/migrations/V0010__char_create_timestamp.sql

@@ -1,2 +0,0 @@
-alter table player_character
-  add created_at timestamptz default current_timestamp not null;

src/entity/src/gateway/postgres/migrations/V0011__shared_bank.sql

@@ -1,16 +0,0 @@
-
-create table shared_bank (
-  user_account integer references user_accounts (id) not null,
-  items jsonb not null,
-  name varchar(128) not null,
-  unique (user_account, name)
-);
-
-
-create table shared_bank_meseta (
-  user_account integer references user_accounts (id) not null,
-  name varchar(128) not null,
-  meseta integer not null,
-  unique (user_account, name)
-);
-

src/entity/src/gateway/postgres/migrations/V0012__room.sql

@@ -1,14 +0,0 @@
-create table room (
-  id serial primary key not null,
-  name varchar(32) not null,
-  section_id char not null,
-  mode char not null,
-  episode char not null,
-  difficulty char not null
-);
-
-create table room_note (
-  room integer references room (id) not null,
-  note jsonb not null,
-  created_at timestamptz default current_timestamp not null
-);

src/entity/src/gateway/postgres/migrations/V0013__room2.sql

@@ -1,17 +0,0 @@
-drop table room_note;
-drop table room;
-
-create table room (
-  id serial primary key not null,
-  name varchar(32) not null,
-  section_id "char" not null,
-  mode "char" not null,
-  episode "char" not null,
-  difficulty "char" not null
-);
-
-create table room_note (
-  room integer references room (id) not null,
-  note jsonb not null,
-  created_at timestamptz default current_timestamp not null
-);

src/entity/src/gateway/postgres/migrations/mod.rs

@@ -1,3 +0,0 @@
-use refinery::include_migration_mods;
-
-include_migration_mods!("src/gateway/postgres/migrations");

src/entity/src/gateway/postgres/postgres.rs

@@ -1,966 +0,0 @@
-// this lint is currently bugged and suggests incorrect code https://github.com/rust-lang/rust-clippy/issues/9123
-#![allow(clippy::explicit_auto_deref)]
-
-use std::convert::{From, Into};
-use futures::future::{Future, BoxFuture};
-use futures::stream::{StreamExt, FuturesOrdered};
-use async_std::sync::{Arc, Mutex};
-use libpso::character::guildcard;
-use crate::account::*;
-use crate::character::*;
-use crate::gateway::{EntityGateway, EntityGatewayTransaction, GatewayError};
-use crate::item::*;
-use crate::room::*;
-use super::models::*;
-
-use sqlx::postgres::PgPoolOptions;
-use sqlx::Connection;
-
-
-mod embedded {
-    use refinery::embed_migrations;
-    embed_migrations!("src/gateway/postgres/migrations");
-}
-
-
-#[derive(Clone)]
-pub struct PostgresTransaction<'t> {
-    pgtransaction: Arc<Mutex<sqlx::Transaction<'t, sqlx::Postgres>>>,
-}
-
-
-#[async_trait::async_trait]
-impl<'t> EntityGatewayTransaction for PostgresTransaction<'t> {
-    type ParentGateway = PostgresTransaction<'t>;
-
-    fn gateway(&mut self) -> &mut Self::ParentGateway {
-        self
-    }
-
-    async fn commit(self) -> Result<(), GatewayError> {
-        Arc::try_unwrap(self.pgtransaction)
-            .unwrap()
-            .into_inner()
-            .commit()
-            .await?;
-        Ok(())
-    }
-}
-
-
-#[derive(Clone)]
-pub struct PostgresGateway {
-    pool: sqlx::Pool<sqlx::Postgres>,
-}
-
-impl PostgresGateway {
-    pub fn new(host: &str, dbname: &str, username: &str, password: &str) -> PostgresGateway {
-        let mut conn = refinery::config::Config::new(refinery::config::ConfigDbType::Postgres)
-            .set_db_host(host)
-            .set_db_user(username)
-            .set_db_pass(password)
-            .set_db_name(dbname);
-        embedded::migrations::runner().run(&mut conn).unwrap();
-
-        let pool = async_std::task::block_on(async move {
-            PgPoolOptions::new()
-                .max_connections(5)
-                .connect(&format!("postgresql://{username}:{password}@{host}:5432/{dbname}")).await.unwrap()
-        });
-
-        PostgresGateway {
-            pool,
-        }
-    }
-}
-
-
-// TODO: remove unwraps, return Result
-async fn apply_item_modifications(conn: &mut sqlx::PgConnection, item: ItemEntity) -> ItemEntity
-{
-    let ItemEntity {id, item} = item;
-
-    let item = match item {
-        ItemDetail::Weapon(mut weapon) => {
-            let q = r#"select weapon, modifier
-                           from weapon_modifier
-                           where weapon = $1
-                           order by created_at"#;
-            let weapon_modifiers = sqlx::query_as::<_, PgWeaponModifier>(q)
-                .bind(id.0 as i32)
-                .fetch(conn);
-
-            weapon_modifiers.for_each(|modifier| async move {
-                if let Ok(modifier) = modifier {
-                    weapon.apply_modifier(&modifier.modifier);
-                }
-            }).await;
-
-            ItemDetail::Weapon(weapon)
-        },
-        ItemDetail::Mag(mag) => {
-            let q = r#"select mag, modifier, item.item -> 'Tool' as feed, item2.item -> 'Tool' as cell
-                           from mag_modifier
-                           left join item on item.id = cast (modifier ->> 'FeedMag' as integer)
-                           left join item as item2 on item2.id = cast (modifier ->> 'MagCell' as integer)
-                           where mag = $1 order by created_at"#;
-            let mag_modifiers = sqlx::query_as::<_, PgMagModifierWithParameters>(q)
-                .bind(id.0 as i32)
-                .fetch(conn);
-
-            let mag = mag_modifiers.fold(mag, |mut mag, modifier| async {
-                let PgMagModifierWithParameters {modifier, feed, cell, ..} = modifier.unwrap();
-                let modifier: mag::MagModifier = modifier.0.into();
-                match modifier {
-                    mag::MagModifier::FeedMag{..} => {
-                        mag.feed(feed.unwrap().tool)
-                    },
-                    mag::MagModifier::BankMag => {
-                        mag.bank()
-                    },
-                    mag::MagModifier::MagCell(_) => {
-                        mag.apply_mag_cell(mag::MagCell::try_from(Into::<tool::Tool>::into(cell.unwrap().0).tool).unwrap()).unwrap()
-                    },
-                    mag::MagModifier::OwnerChange(class, section_id) => {
-                        mag.change_owner(class, section_id)
-                    },
-                }
-
-                mag
-            }).await;
-
-            ItemDetail::Mag(mag)
-        },
-        item => item
-    };
-
-    ItemEntity {
-        id,
-        item,
-    }
-}
-
-async fn fetch_item<T>(conn: &mut sqlx::PgConnection, item: PgInventoryItemEntity, individual: fn(ItemEntity) -> T, stacked: fn(Vec<ItemEntity>) -> T) -> Result<T, GatewayError>
-{
-    match item {
-        PgInventoryItemEntity::Individual(item) => {
-            let entity = sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
-                .bind(item)
-                .fetch_one(&mut *conn).await
-                .map(|item| item.into())
-                .map(|item| apply_item_modifications(&mut *conn, item))?
-                .await;
-            Ok(individual(entity))
-        },
-        PgInventoryItemEntity::Stacked(items) => {
-            let mut stacked_item = Vec::new();
-            for s_item in items {
-                stacked_item.push(sqlx::query_as::<_, PgItemEntity>("select item.id, item.item from item where id = $1")
-                                  .bind(s_item)
-                                  .fetch_one(&mut *conn).await
-                                  .map(|item| item.into())?)
-            }
-            Ok(stacked(stacked_item))
-        }
-    }
-}
-
-async fn create_user(conn: &mut sqlx::PgConnection, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError>
-{
-    let new_user = sqlx::query_as::<_, PgUserAccount>("insert into user_accounts (email, username, password, activated) values ($1, $2, $3, $4) returning *;")
-        .bind(user.email)
-        .bind(user.username)
-        .bind(user.password)
-        .bind(user.activated)
-        .fetch_one(conn).await?;
-    Ok(new_user.into())
-}
-
-async fn get_user_by_id(conn: &mut sqlx::PgConnection, id: UserAccountId) -> Result<UserAccountEntity, GatewayError>
-{
-    let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where id = $1")
-        .bind(id.0 as i32)
-        .fetch_one(conn).await?;
-    Ok(user.into())
-}
-
-async fn get_user_by_name(conn: &mut sqlx::PgConnection, username: String) -> Result<UserAccountEntity, GatewayError>
-{
-    let user = sqlx::query_as::<_, PgUserAccount>("select * from user_accounts where username = $1")
-        .bind(username)
-        .fetch_one(conn).await?;
-    Ok(user.into())
-}
-
-
-async fn save_user(conn: &mut sqlx::PgConnection, user: &UserAccountEntity) -> Result<(), GatewayError>
-{
-    sqlx::query("UPDATE user_accounts set username=$1, password=$2, banned=$3, muted=$4, flags=$5 where id=$6")
-        .bind(&user.username)
-        .bind(&user.password)
-        .bind(user.banned_until)
-        .bind(user.muted_until)
-        .bind(user.flags as i32)
-        .bind(user.id.0 as i32)
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn create_user_settings(conn: &mut sqlx::PgConnection, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError>
-{
-    let new_settings = sqlx::query_as::<_, PgUserSettings>("insert into user_settings (user_account, blocked_users, key_config, joystick_config, option_flags, shortcuts, symbol_chats, team_name)
-                                                            values ($1, $2, $3, $4, $5, $6, $7, $8) returning *;")
-        .bind(settings.user_id.0 as i32)
-        .bind(settings.settings.blocked_users.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
-        .bind(settings.settings.keyboard_config.to_vec())
-        .bind(settings.settings.gamepad_config.to_vec())
-        .bind(settings.settings.option_flags as i32)
-        .bind(settings.settings.shortcuts.to_vec())
-        .bind(settings.settings.symbol_chats.to_vec())
-        .bind(settings.settings.team_name.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
-        .fetch_one(conn).await?;
-    Ok(new_settings.into())
-}
-
-async fn get_user_settings_by_user(conn: &mut sqlx::PgConnection, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError>
-{
-    let settings = sqlx::query_as::<_, PgUserSettings>("select * from user_settings where user_account = $1")
-        .bind(user.id.0 as i32)
-        .fetch_one(conn).await?;
-    Ok(settings.into())
-}
-
-async fn save_user_settings(conn: &mut sqlx::PgConnection, settings: &UserSettingsEntity) -> Result<(), GatewayError>
-{
-    sqlx::query("update user_settings set blocked_users=$1, key_config=$2, joystick_config=$3, option_flags=$4, shortcuts=$5, symbol_chats=$6, team_name=$7 where id=$8")
-        .bind(settings.settings.blocked_users.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
-        .bind(&settings.settings.keyboard_config.to_vec())
-        .bind(&settings.settings.gamepad_config.to_vec())
-        .bind(settings.settings.option_flags as i32)
-        .bind(&settings.settings.shortcuts.to_vec())
-        .bind(&settings.settings.symbol_chats.to_vec())
-        .bind(settings.settings.team_name.iter().copied().flat_map(|i| i.to_le_bytes().to_vec()).collect::<Vec<u8>>())
-        .bind(settings.id.0 as i32)
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn create_character(conn: &mut sqlx::PgConnection, char: NewCharacterEntity) -> Result<CharacterEntity, GatewayError>
-{
-    let q = r#"insert into player_character
-              (user_account, slot, name, exp, class,
-               section_id, costume, skin, face, head,
-               hair, hair_r, hair_g, hair_b, prop_x,
-               prop_y, techs, config, infoboard, guildcard,
-               power, mind, def, evade, luck,
-               hp, tp, tech_menu, option_flags, playtime)
-              values
-              ($1, $2, $3, $4, $5,
-               $6, $7, $8, $9, $10,
-               $11, $12, $13, $14, $15,
-               $16, $17, $18, $19, $20,
-               $21, $22, $23, $24, $25,
-               $26, $27, $28, $29, $30)
-              returning *;"#;
-    let character = sqlx::query_as::<_, PgCharacter>(q)
-        .bind(char.user_id.0 as i32)
-        .bind(char.slot as i16)
-        .bind(char.name)
-        .bind(char.exp as i32)
-        .bind(char.char_class.to_string())
-        .bind(char.section_id.to_string())
-        .bind(char.appearance.costume as i16)
-        .bind(char.appearance.skin as i16)
-        .bind(char.appearance.face as i16)
-        .bind(char.appearance.head as i16)
-        .bind(char.appearance.hair as i16)
-        .bind(char.appearance.hair_r as i16)
-        .bind(char.appearance.hair_g as i16)
-        .bind(char.appearance.hair_b as i16)
-        .bind(char.appearance.prop_x)
-        .bind(char.appearance.prop_y)
-        .bind(&char.techs.as_bytes().to_vec())
-        .bind(&char.config.as_bytes().to_vec())
-        .bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0)))
-        .bind(char.guildcard.description)
-        .bind(char.materials.power as i16)
-        .bind(char.materials.mind as i16)
-        .bind(char.materials.def as i16)
-        .bind(char.materials.evade as i16)
-        .bind(char.materials.luck as i16)
-        .bind(char.materials.hp as i16)
-        .bind(char.materials.tp as i16)
-        .bind(char.tech_menu.tech_menu.to_vec())
-        .bind(char.option_flags as i32)
-        .bind(0)
-        .fetch_one(conn).await?;
-
-    Ok(character.into())
-}
-
-async fn get_characters_by_user(conn: &mut sqlx::PgConnection, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError>
-{
-    let stream = sqlx::query_as::<_, PgCharacter>("select * from player_character where user_account = $1 and slot < 4 order by created_at;")
-        .bind(user.id.0 as i32)
-        .fetch(conn);
-
-    Ok(stream.fold(core::array::from_fn(|_| None), |mut acc, char| async move {
-        if let Ok(char) = char {
-            let slot = char.slot as usize;
-            acc[slot] = Some(char.into())
-        }
-        acc
-    }).await)
-}
-
-async fn save_character(conn: &mut sqlx::PgConnection, char: &CharacterEntity) -> Result<(), GatewayError>
-{
-    let q = r#"update player_character set
-                   user_account=$1, slot=$2, name=$3, exp=$4, class=$5, section_id=$6, costume=$7, skin=$8, face=$9, head=$10, hair=$11, hair_r=$12,
-                   hair_g=$13, hair_b=$14, prop_x=$15, prop_y=$16, techs=$17, config=$18, infoboard=$19, guildcard=$20, power=$21, mind=$22, def=$23,
-                   evade=$24, luck=$25, hp=$26, tp=$27, tech_menu=$28, option_flags=$29, playtime=$30
-               where id=$31;"#;
-    sqlx::query(q)
-        .bind(char.user_id.0 as i32) // $1
-        .bind(char.slot as i16) // $2
-        .bind(&char.name) // $3
-        .bind(char.exp as i32) // $4
-        .bind(char.char_class.to_string()) // $5
-        .bind(char.section_id.to_string()) // $6
-        .bind(char.appearance.costume as i16) // $7
-        .bind(char.appearance.skin as i16) // $8
-        .bind(char.appearance.face as i16) // $9
-        .bind(char.appearance.head as i16) // $10
-        .bind(char.appearance.hair as i16) // $11
-        .bind(char.appearance.hair_r as i16) // $12
-        .bind(char.appearance.hair_g as i16) // $13
-        .bind(char.appearance.hair_b as i16) // $14
-        .bind(char.appearance.prop_x) // $15
-        .bind(char.appearance.prop_y) // $16
-        .bind(&char.techs.as_bytes().to_vec()) // $17
-        .bind(&char.config.as_bytes().to_vec()) // $18
-        .bind(String::from_utf16_lossy(&char.info_board.board).trim_matches(char::from(0))) // $19
-        .bind(&char.guildcard.description) // $20
-        .bind(char.materials.power as i16) // $21
-        .bind(char.materials.mind as i16) // $22
-        .bind(char.materials.def as i16) // $23
-        .bind(char.materials.evade as i16) // $24
-        .bind(char.materials.luck as i16) // $25
-        .bind(char.materials.hp as i16) // $26
-        .bind(char.materials.tp as i16) // $27
-        .bind(char.tech_menu.tech_menu.to_vec()) // $28
-        .bind(char.option_flags as i32) // $29
-        .bind(char.playtime as i32) // $30
-        .bind(char.id.0 as i32) // $31
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn create_item(conn: &mut sqlx::PgConnection, item: NewItemEntity) -> Result<ItemEntity, GatewayError>
-{
-    let new_item = sqlx::query_as::<_, PgItem>("insert into item (item) values ($1) returning *;")
-        .bind(sqlx::types::Json(PgItemDetail::from(item.item)))
-        .fetch_one(conn).await?;
-
-    Ok(ItemEntity {
-        id: ItemEntityId(new_item.id as u32),
-        item: new_item.item.0.into(),
-    })
-}
-
-async fn add_item_note(conn: &mut sqlx::PgConnection, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into item_note(item, note) values ($1, $2)")
-        .bind(item_id.0 as i32)
-        .bind(sqlx::types::Json(PgItemNoteDetail::from(item_note)))
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn feed_mag(conn: &mut sqlx::PgConnection, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
-        .bind(mag_item_id.0 as i32)
-        .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::FeedMag{food: *tool_item_id})))
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn change_mag_owner(conn: &mut sqlx::PgConnection, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
-        .bind(mag_item_id.0 as i32)
-        .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::OwnerChange(character.char_class, character.section_id))))
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn use_mag_cell(conn: &mut sqlx::PgConnection, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into mag_modifier (mag, modifier) values ($1, $2);")
-        .bind(mag_item_id.0 as i32)
-        .bind(sqlx::types::Json(PgMagModifierDetail::from(mag::MagModifier::MagCell(*mag_cell_id))))
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn add_weapon_modifier(conn: &mut sqlx::PgConnection, item_id: &ItemEntityId, modifier: &weapon::WeaponModifier) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into weapon_modifier (weapon, modifier) values ($1, $2);")
-        .bind(item_id.0 as i32)
-        .bind(sqlx::types::Json(modifier))
-        .execute(conn).await?;
-    Ok(())
-}
-
-async fn get_character_inventory(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError>
-{
-    let conn = Arc::new(Mutex::new(conn.begin().await?)); // this is some degen shit
-    let inventory = sqlx::query_as::<_, PgInventoryEntity>("select * from inventory where pchar = $1")
-        .bind(char_id.0 as i32)
-        .fetch_one(&mut **conn.lock().await).await?;
-
-    Ok(InventoryEntity::new(
-        inventory.items.0
-            .into_iter()
-            .map(move |item| {
-                let conn = conn.clone();
-                async move {
-                    fetch_item(&mut **conn.lock().await, item, InventoryItemEntity::Individual, InventoryItemEntity::Stacked).await
-                }
-            })
-            .collect::<FuturesOrdered<_>>()
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()?))
-}
-
-async fn get_character_bank(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError>
-{
-    let conn = Arc::new(Mutex::new(conn.begin().await?)); // this is some degen shit
-    let bank = match bank_identifier {
-        BankIdentifier::Character => {
-            sqlx::query_as::<_, PgInventoryEntity>("select * from bank where pchar = $1")
-                .bind(char_id.0 as i32)
-                .fetch_one(&mut **conn.lock().await).await?
-        },
-        BankIdentifier::Shared(bank_name) => {
-            sqlx::query_as::<_, PgInventoryEntity>("select player_character.id as pchar, shared_bank.items as items from shared_bank
-                                                    join player_character on shared_bank.user_account = player_character.user_account
-                                                    where player_character.id = $1 and shared_bank.name = $2")
-                .bind(char_id.0 as i32)
-                .bind(&bank_name.0)
-                .fetch_optional(&mut **conn.lock().await)
-                .await?
-                .unwrap_or_else(|| PgInventoryEntity {
-                    pchar: char_id.0 as i32,
-                    items: sqlx::types::Json::default(),
-                })
-        }
-    };
-
-    Ok(BankEntity::new(
-        bank.items.0
-            .into_iter()
-            .map(move |item| {
-                let conn = conn.clone();
-                async move {
-                    fetch_item(&mut **conn.lock().await, item, BankItemEntity::Individual, BankItemEntity::Stacked).await
-                }
-            })
-            .collect::<FuturesOrdered<_>>()
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, _>>()?))
-}
-
-async fn set_character_inventory(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError>
-{
-    let inventory = inventory.items.iter()
-        .map(|item| {
-            match item {
-                InventoryItemEntity::Individual(item) => {
-                    PgInventoryItemEntity::Individual(item.id.0 as i32)
-                },
-                InventoryItemEntity::Stacked(items) => {
-                    PgInventoryItemEntity::Stacked(items.iter().map(|i| i.id.0 as i32).collect())
-                },
-            }
-        })
-        .collect::<Vec<_>>();
-
-    sqlx::query("insert into inventory (pchar, items) values ($1, $2) on conflict (pchar) do update set items = $2")
-        .bind(char_id.0 as i32)
-        .bind(sqlx::types::Json(inventory))
-        .execute(conn)
-        .await?;
-    Ok(())
-}
-
-
-async fn set_character_bank(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, bank: &BankEntity, bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
-    let bank = bank.items.iter()
-        .map(|item| {
-            match item {
-                BankItemEntity::Individual(item) => {
-                    PgInventoryItemEntity::Individual(item.id.0 as i32)
-                },
-                BankItemEntity::Stacked(items) => {
-                    PgInventoryItemEntity::Stacked(items.iter().map(|i| i.id.0 as i32).collect())
-                },
-            }
-        })
-        .collect::<Vec<_>>();
-
-    match bank_identifier {
-        BankIdentifier::Character => {
-            sqlx::query("insert into bank (pchar, items, name) values ($1, $2, '') on conflict (pchar, name) do update set items = $2")
-                .bind(char_id.0 as i32)
-                .bind(sqlx::types::Json(bank))
-                .execute(conn)
-                .await?;
-        },
-        BankIdentifier::Shared(bank_name) => {
-            sqlx::query("insert into shared_bank (user_account, items, name)
-                         select player_character.user_account, $2, $3 from player_character
-                         where player_character.id = $1
-                         on conflict (user_account, name) do update set items = $2;")
-                .bind(char_id.0 as i32)
-                .bind(sqlx::types::Json(bank))
-                .bind(&bank_name.0)
-                .execute(conn)
-                .await?;
-        }
-    }
-    Ok(())
-}
-
-async fn get_character_equips(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError>
-{
-    let equips = sqlx::query_as::<_, PgEquipped>("select * from equipped where pchar = $1")
-        .bind(char_id.0 as i32)
-        .fetch_one(conn)
-        .await?;
-
-    Ok(equips.into())
-}
-
-async fn set_character_equips(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, equips: &EquippedEntity) -> Result<(), GatewayError>
-{
-    sqlx::query(r#"insert into equipped (pchar, weapon, armor, shield, unit0, unit1, unit2, unit3, mag) values ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-                       on conflict (pchar) do update set weapon=$2, armor=$3, shield=$4, unit0=$5, unit1=$6, unit2=$7, unit3=$8, mag=$9"#)
-        .bind(char_id.0 as i32)
-        .bind(equips.weapon.map(|i| i.0 as i32))
-        .bind(equips.armor.map(|i| i.0 as i32))
-        .bind(equips.shield.map(|i| i.0 as i32))
-        .bind(equips.unit[0].map(|i| i.0 as i32))
-        .bind(equips.unit[1].map(|i| i.0 as i32))
-        .bind(equips.unit[2].map(|i| i.0 as i32))
-        .bind(equips.unit[3].map(|i| i.0 as i32))
-        .bind(equips.mag.map(|i| i.0 as i32))
-        .execute(conn)
-        .await?;
-    Ok(())
-}
-
-
-async fn set_character_meseta(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError>
-{
-    sqlx::query("insert into character_meseta values ($1, $2) on conflict (pchar) do update set meseta = $2")
-        .bind(char_id.0 as i32)
-        .bind(meseta.0 as i32)
-        .execute(conn)
-        .await?;
-    Ok(())
-}
-
-async fn get_character_meseta(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError>
-{
-    #[derive(sqlx::FromRow)]
-    struct PgMeseta(i32);
-    let meseta = sqlx::query_as::<_, PgMeseta>(r#"select meseta from character_meseta where pchar = $1"#)
-        .bind(char_id.0 as i32)
-        .fetch_one(conn)
-        .await?;
-    Ok(Meseta(meseta.0 as u32))
-}
-
-async fn set_bank_meseta(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier, meseta: Meseta) -> Result<(), GatewayError>
-{
-    match bank_identifier {
-        BankIdentifier::Character => {
-            sqlx::query("insert into bank_meseta values ($1, '', $2) on conflict (pchar, bank) do update set meseta = $2")
-                .bind(char_id.0 as i32)
-                .bind(meseta.0 as i32)
-                .execute(conn)
-                .await?;
-        },
-        BankIdentifier::Shared(bank_name) => {
-            sqlx::query("insert into shared_bank_meseta (user_account, name, meseta)
-                         select player_character.user_account, $2, $3 from player_character
-                         where player_character.id = $1
-                         on conflict (user_account, name) do update set meseta = $3")
-                .bind(char_id.0 as i32)
-                .bind(&bank_name.0)
-                .bind(meseta.0 as i32)
-                .execute(conn)
-                .await?;
-        }
-    }
-
-    Ok(())
-}
-
-async fn get_bank_meseta(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError>
-{
-    #[derive(sqlx::FromRow)]
-    struct PgMeseta(i32);
-
-    let meseta = match bank_identifier {
-        BankIdentifier::Character => {
-            sqlx::query_as::<_, PgMeseta>(r#"select meseta from bank_meseta where pchar = $1"#)
-                .bind(char_id.0 as i32)
-                .fetch_one(conn)
-                .await?
-        },
-        BankIdentifier::Shared(bank_name) => {
-            sqlx::query_as::<_, PgMeseta>(r#"select shared_bank_meseta.meseta from shared_bank_meseta
-                                             join player_character on shared_bank_meseta.user_account = player_character.user_account
-                                             where player_character.id = $1 and shared_bank_meseta.name = $2"#)
-                .bind(char_id.0 as i32)
-                .bind(&bank_name.0)
-                .fetch_optional(conn)
-                .await?
-                .unwrap_or(PgMeseta(0))
-        }
-    };
-    Ok(Meseta(meseta.0 as u32))
-}
-
-async fn create_trade(conn: &mut sqlx::PgConnection, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError>
-{
-    let trade = sqlx::query_as::<_, PgTradeEntity>(r#"insert into trades (character1, character2) values ($1, $2) returning *;"#)
-        .bind(char_id1.0 as i32)
-        .bind(char_id2.0 as i32)
-        .fetch_one(conn)
-        .await?;
-    Ok(trade.into())
-}
-
-async fn set_character_playtime(conn: &mut sqlx::PgConnection, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError>
-{
-    sqlx::query(r#"update player_character set playtime=$2 where id=$1;"#)
-        .bind(char_id.0 as i32)
-        .bind(playtime as i32)
-        .execute(conn)
-        .await?;
-    Ok(())
-}
-
-async fn create_room(conn: &mut sqlx::PgConnection, room: NewRoomEntity) -> Result<RoomEntity, GatewayError> {
-    sqlx::query_as::<_, PgRoomEntity>("insert into room (name, section_id, mode, episode, difficulty) values ($1, $2, $3, $4, $5) returning *")
-        .bind(room.name)
-        .bind(u8::from(room.section_id) as i8)
-        .bind(u8::from(room.mode) as i8)
-        .bind(u8::from(room.episode) as i8)
-        .bind(u8::from(room.difficulty) as i8)
-        .fetch_one(conn)
-        .await
-        .map(|room| room.into())
-        .map_err(|err| err.into())
-}
-
-async fn add_room_note(conn: &mut sqlx::PgConnection, room_id: RoomEntityId, note: RoomNote) -> Result<(), GatewayError> {
-    sqlx::query("insert into room_note (room, note) values ($1, $2)")
-        .bind(room_id.0 as i32)
-        .bind(sqlx::types::Json(note))
-        .execute(conn)
-        .await?;
-    Ok(())
-}
-
-#[async_trait::async_trait]
-impl EntityGateway for PostgresGateway {
-    type Transaction<'t> = PostgresTransaction<'t> where Self: 't;
-
-    fn with_transaction<'a, F, Fut, R>(&'a mut self, func: F) -> BoxFuture<'a, Result<R, anyhow::Error>>
-    where
-        Fut: Future<Output = Result<(Self::Transaction<'a>, R), anyhow::Error>> + Send + 'a,
-        F: FnOnce(Self::Transaction<'a>) -> Fut + Send + 'a,
-        R: Send,
-    {
-        Box::pin(async move {
-            let transaction = PostgresTransaction {
-                pgtransaction: Arc::new(Mutex::new(self.pool.begin().await?))
-            };
-            let (transaction, result) = func(transaction).await?;
-            transaction.commit().await?;
-            Ok(result)
-        })
-    }
-
-    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
-        create_user(&mut *self.pool.acquire().await?, user).await
-    }
-
-    async fn get_user_by_id(&mut self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
-        get_user_by_id(&mut *self.pool.acquire().await?, id).await
-    }
-
-    async fn get_user_by_name(&mut self, username: String) -> Result<UserAccountEntity, GatewayError> {
-        get_user_by_name(&mut *self.pool.acquire().await?, username).await
-    }
-
-    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> {
-        save_user(&mut *self.pool.acquire().await?, user).await
-    }
-
-    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
-        create_user_settings(&mut *self.pool.acquire().await?, settings).await
-    }
-
-    async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
-        get_user_settings_by_user(&mut *self.pool.acquire().await?, user).await
-    }
-
-    async fn save_user_settings(&mut self, settings: &UserSettingsEntity) -> Result<(), GatewayError> {
-        save_user_settings(&mut *self.pool.acquire().await?, settings).await
-    }
-
-    async fn create_character(&mut self, char: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
-        create_character(&mut *self.pool.acquire().await?, char).await
-    }
-
-    async fn get_characters_by_user(&mut self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
-        get_characters_by_user(&mut *self.pool.acquire().await?, user).await
-    }
-
-    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> {
-        save_character(&mut *self.pool.acquire().await?, char).await
-    }
-
-    async fn get_guild_card_data_by_user(&mut self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
-        Ok(GuildCardDataEntity {
-            id: GuildCardDataId(0),
-            user_id: user.id,
-            guildcard: guildcard::GuildCardData::default(),
-        })
-    }
-
-    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
-        create_item(&mut *self.pool.acquire().await?, item).await
-    }
-
-    async fn add_item_note(&mut self, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError> {
-        add_item_note(&mut *self.pool.acquire().await?, item_id, item_note).await
-    }
-
-    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
-        feed_mag(&mut *self.pool.acquire().await?, mag_item_id, tool_item_id).await
-    }
-
-    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
-        change_mag_owner(&mut *self.pool.acquire().await?, mag_item_id, character).await
-    }
-
-    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
-        use_mag_cell(&mut *self.pool.acquire().await?, mag_item_id, mag_cell_id).await
-    }
-
-    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: &weapon::WeaponModifier) -> Result<(), GatewayError> {
-        add_weapon_modifier(&mut *self.pool.acquire().await?, item_id, modifier).await
-    }
-
-    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
-        get_character_inventory(&mut *self.pool.acquire().await?, char_id).await
-    }
-
-    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError> {
-        get_character_bank(&mut *self.pool.acquire().await?, char_id, bank_identifier).await
-    }
-
-    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
-        set_character_inventory(&mut *self.pool.acquire().await?, char_id, inventory).await
-    }
-
-    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
-        set_character_bank(&mut *self.pool.acquire().await?, char_id, bank, bank_identifier).await
-    }
-
-    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
-        get_character_equips(&mut *self.pool.acquire().await?, char_id).await
-    }
-
-    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equips: &EquippedEntity) -> Result<(), GatewayError> {
-        set_character_equips(&mut *self.pool.acquire().await?, char_id, equips).await
-    }
-
-    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
-        set_character_meseta(&mut *self.pool.acquire().await?, char_id, meseta).await
-    }
-
-    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
-        get_character_meseta(&mut *self.pool.acquire().await?, char_id).await
-    }
-
-    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier, meseta: Meseta) -> Result<(), GatewayError> {
-        set_bank_meseta(&mut *self.pool.acquire().await?, char_id, bank_identifier, meseta).await
-    }
-
-    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError> {
-        get_bank_meseta(&mut *self.pool.acquire().await?, char_id, bank_identifier).await
-    }
-
-    async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
-        create_trade(&mut *self.pool.acquire().await?, char_id1, char_id2).await
-    }
-
-    async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> {
-        set_character_playtime(&mut *self.pool.acquire().await?, char_id, playtime).await
-    }
-
-    async fn create_room(&mut self, room: NewRoomEntity) -> Result<RoomEntity, GatewayError> {
-        create_room(&mut *self.pool.acquire().await?, room).await
-    }
-
-    async fn add_room_note(&mut self, room_id: RoomEntityId, note: RoomNote) -> Result<(), GatewayError> {
-        add_room_note(&mut *self.pool.acquire().await?, room_id, note).await
-    }
-}
-
-
-#[async_trait::async_trait]
-impl<'c> EntityGateway for PostgresTransaction<'c> {
-    type Transaction<'t> = PostgresTransaction<'c> where Self: 't;
-
-    async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
-        create_user(&mut *self.pgtransaction.lock().await, user).await
-    }
-
-    async fn get_user_by_id(&mut self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
-        get_user_by_id(&mut *self.pgtransaction.lock().await, id).await
-    }
-
-    async fn get_user_by_name(&mut self, username: String) -> Result<UserAccountEntity, GatewayError> {
-        get_user_by_name(&mut *self.pgtransaction.lock().await, username).await
-    }
-
-    async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> {
-        save_user(&mut *self.pgtransaction.lock().await, user).await
-    }
-
-    async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
-        create_user_settings(&mut *self.pgtransaction.lock().await, settings).await
-    }
-
-    async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
-        get_user_settings_by_user(&mut *self.pgtransaction.lock().await, user).await
-    }
-
-    async fn save_user_settings(&mut self, settings: &UserSettingsEntity) -> Result<(), GatewayError> {
-        save_user_settings(&mut *self.pgtransaction.lock().await, settings).await
-    }
-
-    async fn create_character(&mut self, char: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
-        create_character(&mut *self.pgtransaction.lock().await, char).await
-    }
-
-    async fn get_characters_by_user(&mut self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
-        get_characters_by_user(&mut *self.pgtransaction.lock().await, user).await
-    }
-
-    async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> {
-        save_character(&mut *self.pgtransaction.lock().await, char).await
-    }
-
-    async fn get_guild_card_data_by_user(&mut self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
-        Ok(GuildCardDataEntity {
-            id: GuildCardDataId(0),
-            user_id: user.id,
-            guildcard: guildcard::GuildCardData::default(),
-        })
-    }
-
-    async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
-        create_item(&mut *self.pgtransaction.lock().await, item).await
-    }
-
-    async fn add_item_note(&mut self, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError> {
-        add_item_note(&mut *self.pgtransaction.lock().await, item_id, item_note).await
-    }
-
-    async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
-        feed_mag(&mut *self.pgtransaction.lock().await, mag_item_id, tool_item_id).await
-    }
-
-    async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
-        change_mag_owner(&mut *self.pgtransaction.lock().await, mag_item_id, character).await
-    }
-
-    async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
-        use_mag_cell(&mut *self.pgtransaction.lock().await, mag_item_id, mag_cell_id).await
-    }
-
-    async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: &weapon::WeaponModifier) -> Result<(), GatewayError> {
-        add_weapon_modifier(&mut *self.pgtransaction.lock().await, item_id, modifier).await
-    }
-
-    async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
-        get_character_inventory(&mut *self.pgtransaction.lock().await, char_id).await
-    }
-
-    async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<BankEntity, GatewayError> {
-        get_character_bank(&mut *self.pgtransaction.lock().await, char_id, bank_identifier).await
-    }
-
-    async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
-        set_character_inventory(&mut *self.pgtransaction.lock().await, char_id, inventory).await
-    }
-
-    async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_identifier: &BankIdentifier) -> Result<(), GatewayError> {
-        set_character_bank(&mut *self.pgtransaction.lock().await, char_id, bank, bank_identifier).await
-    }
-
-    async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
-        get_character_equips(&mut *self.pgtransaction.lock().await, char_id).await
-    }
-
-    async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equips: &EquippedEntity) -> Result<(), GatewayError> {
-        set_character_equips(&mut *self.pgtransaction.lock().await, char_id, equips).await
-    }
-
-    async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
-        set_character_meseta(&mut *self.pgtransaction.lock().await, char_id, meseta).await
-    }
-
-    async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
-        get_character_meseta(&mut *self.pgtransaction.lock().await, char_id).await
-    }
-
-    async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier, meseta: Meseta) -> Result<(), GatewayError> {
-        set_bank_meseta(&mut *self.pgtransaction.lock().await, char_id, bank_identifier, meseta).await
-    }
-
-    async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank_identifier: &BankIdentifier) -> Result<Meseta, GatewayError> {
-        get_bank_meseta(&mut *self.pgtransaction.lock().await, char_id, bank_identifier).await
-    }
-
-    async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
-        create_trade(&mut *self.pgtransaction.lock().await, char_id1, char_id2).await
-    }
-
-    async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> {
-        set_character_playtime(&mut *self.pgtransaction.lock().await, char_id, playtime).await
-    }
-
-    async fn create_room(&mut self, room: NewRoomEntity) -> Result<RoomEntity, GatewayError> {
-        create_room(&mut *self.pgtransaction.lock().await, room).await
-    }
-
-    async fn add_room_note(&mut self, room_id: RoomEntityId, note: RoomNote) -> Result<(), GatewayError> {
-        add_room_note(&mut *self.pgtransaction.lock().await, room_id, note).await
-    }
-}
-

src/entity/src/room.rs

@@ -1,83 +0,0 @@
-use serde::{Serialize, Deserialize};
-
-
-use crate::character::{CharacterEntityId, SectionID};
-use maps::room::{Episode, Difficulty};
-
-
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct RoomEntityId(pub u32);
-
-
-#[derive(Debug, Copy, Clone)]
-pub enum RoomEntityMode {
-    Multi,
-    Single,
-    Challenge,
-    Battle,
-}
-
-impl From<u8> for RoomEntityMode {
-    fn from(other: u8) -> RoomEntityMode {
-        match other {
-            0 => RoomEntityMode::Multi,
-            1 => RoomEntityMode::Single,
-            2 => RoomEntityMode::Challenge,
-            3 => RoomEntityMode::Battle,
-            _ => unreachable!()
-        }
-    }
-}
-
-impl From<RoomEntityMode> for u8 {
-    fn from(other: RoomEntityMode) -> u8 {
-        match other {
-            RoomEntityMode::Multi => 0,
-            RoomEntityMode::Single => 1,
-            RoomEntityMode::Challenge => 2,
-            RoomEntityMode::Battle => 3,
-        }
-    }
-}
-
-
-#[derive(Debug, Clone)]
-pub struct RoomEntity {
-    pub id: RoomEntityId,
-    pub name: String,
-    pub section_id: SectionID,
-    pub mode: RoomEntityMode,
-    pub episode: Episode,
-    pub difficulty: Difficulty,
-}
-
-
-
-#[derive(Debug, Clone)]
-pub struct NewRoomEntity {
-    pub name: String,
-    pub section_id: SectionID,
-    pub mode: RoomEntityMode,
-    pub episode: Episode,
-    pub difficulty: Difficulty,
-}
-
-#[derive(Debug, Copy, Clone, Serialize)]
-pub enum RoomNote {
-    Create {
-        character_id: CharacterEntityId,
-    },
-    PlayerJoin {
-        character_id: CharacterEntityId,
-    },
-    PlayerLeave {
-        character_id: CharacterEntityId,
-    },
-    QuestStart {
-        // quest id
-    },
-    QuestComplete {
-        // quest id
-    },
-    
-}

src/entity/src/team.rs

@@ -1,31 +0,0 @@
-use serde::{Serialize, Deserialize};
-
-use super::account::UserAccountId;
-
-// [2022-10-23 00:11:18][elseware::common::mainloop::client][WARN] error RecvServerPacket::from_bytes: WrongPacketForServerType(490, [40, 0, 234, 1, 0, 0, 0, 0, 9, 0, 74, 0, 97, 0, 115, 0, 100, 0, 102, 0, 0, 0, 0, 0, 192, 52, 67, 3, 60, 159, 129, 0, 32, 64, 233, 10, 196, 156, 152, 0])
-// [2022-10-23 00:20:14][elseware::common::mainloop::client][WARN] error RecvServerPacket::from_bytes: WrongPacketForServerType(490, [40, 0, 234, 1, 0, 0, 0, 0, 9, 0, 74, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 97, 0, 0, 0, 152, 0])
-
-
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct TeamEntityId(pub u32);
-
-pub struct NewTeamEntity {
-    pub created_by: UserAccountId,
-    pub name: String,
-}
-
-
-#[derive(Debug, Clone)]
-pub struct TeamEntity {
-    pub id: TeamEntityId,
-    pub owner: UserAccountId,
-    pub name: String,
-
-    pub team_flag: [u8; 2048],
-}
-
-
-
-
-
-

src/items/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "items"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-entity = { workspace = true }
-maps = { workspace = true }
-shops = { workspace = true }
-location = { workspace = true }
-drops = { workspace = true }
-
-libpso = { workspace = true }
-
-enum-utils = { workspace = true }
-derive_more = { workspace = true }
-serde = { workspace = true }
-rand = { workspace = true }
-rand_chacha = { workspace = true }
-async-recursion = { workspace = true }
-async-std = { workspace = true }
-async-trait = { workspace = true }
-futures = { workspace = true }
-anyhow = { workspace = true }
-thiserror = { workspace = true }

src/items/src/apply_item.rs

@@ -1,395 +0,0 @@
-use std::convert::TryInto;
-use futures::future::join_all;
-use thiserror::Error;
-use anyhow::Context;
-use rand::SeedableRng;
-use rand::distributions::{WeightedIndex, Distribution};
-use entity::gateway::{EntityGateway, GatewayError};
-use entity::character::{CharacterEntity, TechLevel};
-use entity::item::mag::{MagCell, MagCellError};
-use entity::item::tool::{Tool, ToolType};
-use entity::item::tech::TechniqueDisk;
-use entity::item::{ItemDetail, ItemEntityId};
-use entity::item::weapon::WeaponModifier;
-use crate::state::ItemStateProxy;
-use crate::inventory::InventoryItemDetail;
-
-
-#[derive(Error, Debug)]
-pub enum ApplyItemError {
-    #[error("no character")]
-    NoCharacter,
-    #[error("item not equipped")]
-    ItemNotEquipped,
-    #[error("could not use item invalid item")]
-    InvalidItem,
-    #[error("invalid tool")]
-    InvalidTool,
-    #[error("gateway error {0}")]
-    GatewayError(#[from] GatewayError),
-    #[error("magcell error {0}")]
-    MagCellError(#[from] MagCellError),
-}
-
-#[derive(Debug, Clone)]
-pub enum ApplyItemAction {
-    UpdateCharacter(Box<CharacterEntity>),
-    CreateItem(ItemDetail),
-    //TransformItem(ItemDetail),
-    //RemoveItem,
-}
-
-async fn power_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.power += 1;
-    entity_gateway.save_character(character).await?;
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn mind_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.mind += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn evade_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.evade += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn def_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.def += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn luck_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.luck += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn hp_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.hp += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-async fn tp_material<EG: EntityGateway + ?Sized>(entity_gateway: &mut EG, character: &mut CharacterEntity) -> Result<Vec<ApplyItemAction>, anyhow::Error> {
-    character.materials.tp += 1;
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-}
-
-/*
-async fn mag_cell<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory, mag_cell_type: MagCell) -> Result<(), ApplyItemError> {
-    let mut mag_handle = inventory.get_equipped_mag_handle().ok_or(ApplyItemError::ItemNotEquipped)?;
-    let mag_item = mag_handle.item_mut()
-        .ok_or(ApplyItemError::InvalidItem)?;
-    let actual_mag = mag_item
-        .individual_mut()
-        .ok_or(ApplyItemError::InvalidItem)?
-        .mag_mut()
-        .ok_or(ApplyItemError::InvalidItem)?;
-    actual_mag.apply_mag_cell(mag_cell_type);
-    for mag_entity_id in mag_item.entity_ids() {
-        for cell_entity_id in used_cell.entity_ids() {
-            entity_gateway.use_mag_cell(&mag_entity_id, &cell_entity_id).await.unwrap();
-        }
-    }
-
-    Ok(())
-}
- */
-
-
-async fn mag_cell<'a, EG>(item_state: &mut ItemStateProxy,
-                          entity_gateway: &mut EG,
-                          character: &CharacterEntity,
-                          cell_entity_id: ItemEntityId,
-                          mag_cell_type: MagCell)
-                          -> Result<Vec<ApplyItemAction>, anyhow::Error>
-where
-    EG: EntityGateway + ?Sized,
-{
-    let mut inventory = item_state.inventory(&character.id).await?;
-
-    let (mag_entity_id, mag) = inventory.equipped_mag_mut()
-        .ok_or(ApplyItemError::ItemNotEquipped)?;
-    mag.apply_mag_cell(mag_cell_type)?;
-
-    entity_gateway.use_mag_cell(&mag_entity_id, &cell_entity_id).await?;
-    entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?;
-    item_state.set_inventory(inventory).await;
-
-    Ok(Vec::new())
-}
-
-/*
-pub async fn cell_of_mag_502<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, inventory, MagCell::CellOfMag502).await
-}
-
-pub async fn cell_of_mag_213<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::CellOfMag213).await
-}
-
-pub async fn parts_of_robochao<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::PartsOfRobochao).await
-}
-
-pub async fn heart_of_opaopa<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeartOfOpaOpa).await
-}
-
-pub async fn heart_of_pian<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeartOfPian).await
-}
-
-pub async fn heart_of_chao<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeartOfChao).await
-}
-
-pub async fn heart_of_angel<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeartOfAngel).await
-}
-
-pub async fn kit_of_hamburger<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfHamburger).await
-}
-
-pub async fn panthers_spirit<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::PanthersSpirit).await
-}
-
-pub async fn kit_of_mark3<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfMark3).await
-}
-
-pub async fn kit_of_master_system<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfMasterSystem).await
-}
-
-pub async fn kit_of_genesis<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfGenesis).await
-}
-
-pub async fn kit_of_sega_saturn<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfSegaSaturn).await
-}
-
-pub async fn kit_of_dreamcast<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::KitOfDreamcast).await
-}
-
-pub async fn tablet<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::Tablet).await
-}
-
-pub async fn dragon_scale<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::DragonScale).await
-}
-
-pub async fn heaven_striker_coat<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeavenStrikerCoat).await
-}
-
-pub async fn pioneer_parts<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::PioneerParts).await
-}
-
-pub async fn amities_memo<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::AmitiesMemo).await
-}
-
-pub async fn heart_of_morolian<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::HeartOfMorolian).await
-}
-
-pub async fn rappys_beak<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::RappysBeak).await
-}
-
-pub async fn yahoos_engine<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::YahoosEngine).await
-}
-
-pub async fn d_photon_core<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::DPhotonCore).await
-}
-
-pub async fn liberta_kit<EG: EntityGateway>(entity_gateway: &mut EG, used_cell: &ConsumedItem, inventory: &mut CharacterInventory) -> Result<(), ApplyItemError> {
-    mag_cell(entity_gateway, used_cell, inventory, MagCell::LibertaKit).await
-}
-*/
-
-
-fn jack_o_lantern() -> Result<Vec<ApplyItemAction>, anyhow::Error>
-{
-    let mag_rate = WeightedIndex::new([13, 13, 13, 13, 12, 12, 12, 12]).unwrap();
-    let mag_type = match mag_rate.sample(&mut rand_chacha::ChaChaRng::from_entropy()) {
-        0 => ToolType::CellOfMag502,
-        1 => ToolType::CellOfMag213,
-        2 => ToolType::HeartOfChuChu,
-        3 => ToolType::HeartOfKapuKapu,
-        4 => ToolType::PartsOfRobochao,
-        5 => ToolType::HeartOfOpaOpa,
-        6 => ToolType::HeartOfPian,
-        7 => ToolType::HeartOfChao,
-        _ => unreachable!(),
-    };
-
-    Ok(vec![ApplyItemAction::CreateItem(ItemDetail::Tool(Tool {tool: mag_type}))])
-}
-
-async fn weapon_grind<'a, EG>(item_state: &mut ItemStateProxy,
-                              entity_gateway: &mut EG,
-                              character: &mut CharacterEntity,
-                              entity_id: ItemEntityId,
-                              grind: u32,)
-                              -> Result<Vec<ApplyItemAction>, anyhow::Error>
-where
-    EG: EntityGateway + ?Sized,
-{
-    let modifier = WeaponModifier::AddGrind {
-        amount: grind,
-        grinder: entity_id,
-    };
-
-    let mut inventory = item_state.inventory(&character.id).await?;
-    let (weapon_entity_id, weapon) = inventory.equipped_weapon_mut()
-        .ok_or(ApplyItemError::ItemNotEquipped)?;
-    weapon.apply_modifier(&modifier);
-    entity_gateway.add_weapon_modifier(&weapon_entity_id, &modifier).await?;
-    item_state.set_inventory(inventory).await;
-
-    Ok(Vec::new())
-}
-
-async fn apply_tool<'a, EG>(item_state: &mut ItemStateProxy,
-                            entity_gateway: &mut EG,
-                            character: &mut CharacterEntity,
-                            entity_id: ItemEntityId,
-                            tool: ToolType)
-                            -> Result<Vec<ApplyItemAction>, anyhow::Error>
-where
-    EG: EntityGateway + ?Sized,
-{
-    match tool {
-        ToolType::PowerMaterial => power_material(entity_gateway, character).await,
-        ToolType::MindMaterial => mind_material(entity_gateway, character).await,
-        ToolType::EvadeMaterial => evade_material(entity_gateway, character).await,
-        ToolType::DefMaterial => def_material(entity_gateway, character).await,
-        ToolType::LuckMaterial => luck_material(entity_gateway, character).await,
-        ToolType::HpMaterial => hp_material(entity_gateway, character).await,
-        ToolType::TpMaterial => tp_material(entity_gateway, character).await,
-        ToolType::Monomate => Ok(Vec::new()),
-        ToolType::Dimate => Ok(Vec::new()),
-        ToolType::Trimate => Ok(Vec::new()),
-        ToolType::Monofluid => Ok(Vec::new()),
-        ToolType::Difluid => Ok(Vec::new()),
-        ToolType::Trifluid => Ok(Vec::new()),
-        ToolType::SolAtomizer => Ok(Vec::new()),
-        ToolType::MoonAtomizer => Ok(Vec::new()),
-        ToolType::StarAtomizer => Ok(Vec::new()),
-        ToolType::Telepipe => Ok(Vec::new()),
-        ToolType::Antidote => Ok(Vec::new()),
-        ToolType::Antiparalysis => Ok(Vec::new()),
-        ToolType::TrapVision => Ok(Vec::new()),
-        ToolType::ScapeDoll => Ok(Vec::new()),
-        ToolType::Monogrinder => weapon_grind(item_state, entity_gateway, character, entity_id, 1).await,
-        ToolType::Digrinder => weapon_grind(item_state, entity_gateway, character, entity_id, 2).await,
-        ToolType::Trigrinder => weapon_grind(item_state, entity_gateway, character, entity_id, 3).await,
-        ToolType::HuntersReport => Ok(Vec::new()),
-        ToolType::CellOfMag502
-            | ToolType::CellOfMag213
-            | ToolType::PartsOfRobochao
-            | ToolType::HeartOfOpaOpa
-            | ToolType::HeartOfPian
-            | ToolType::HeartOfChao
-            | ToolType::HeartOfAngel
-            | ToolType::KitOfHamburger
-            | ToolType::PanthersSpirit
-            | ToolType::KitOfMark3
-            | ToolType::KitOfMasterSystem
-            | ToolType::KitOfGenesis
-            | ToolType::KitOfSegaSaturn
-            | ToolType::KitOfDreamcast
-            | ToolType::Tablet
-            | ToolType::DragonScale
-            | ToolType::HeavenStrikerCoat
-            | ToolType::PioneerParts
-            | ToolType::AmitiesMemo
-            | ToolType::HeartOfMorolian
-            | ToolType::RappysBeak
-            | ToolType::YahoosEngine
-            | ToolType::DPhotonCore
-            | ToolType::LibertaKit => {
-                mag_cell(item_state, entity_gateway, character, entity_id, tool.try_into()?).await
-            }
-        ToolType::JackOLantern => jack_o_lantern(),
-        // TODO: rest of these
-        _ => Err(anyhow::Error::from(ApplyItemError::InvalidTool))
-            .with_context(|| {
-                format!("invalid tool {tool:?}")
-            })
-
-    }
-    
-}
-
-async fn apply_tech<'a, EG>(_item_state: &mut ItemStateProxy,
-                            entity_gateway: &mut EG,
-                            character: &mut CharacterEntity,
-                            _entity_id: ItemEntityId,
-                            tech: TechniqueDisk)
-                            -> Result<Vec<ApplyItemAction>, anyhow::Error>
-where
-    EG: EntityGateway + ?Sized,
-{
-    // TODO: make sure the class can learn that specific tech
-    character.techs.set_tech(tech.tech, TechLevel(tech.level as u8));
-    entity_gateway.save_character(character).await.unwrap();
-    Ok(vec![ApplyItemAction::UpdateCharacter(Box::new(character.clone()))])
-
-}
-
-pub async fn apply_item<'a, EG>(item_state: &'a mut ItemStateProxy,
-                                entity_gateway: &'a mut EG,
-                                character: &'a mut CharacterEntity,
-                                item: InventoryItemDetail
-) -> Result<Vec<ApplyItemAction>, anyhow::Error>
-where
-    EG: EntityGateway + ?Sized + Clone + 'a
-{
-    match item {
-        InventoryItemDetail::Individual(individual_item) => {
-            match individual_item.item {
-                ItemDetail::Tool(tool) => apply_tool(item_state, entity_gateway, character, individual_item.entity_id, tool.tool).await,
-                ItemDetail::TechniqueDisk(tech) => apply_tech(item_state, entity_gateway, character, individual_item.entity_id, tech).await,
-                _ => Err(anyhow::Error::from(ApplyItemError::InvalidItem))
-                    .with_context(|| {
-                        format!("item {individual_item:?}")
-                    })
-            }
-        },
-        InventoryItemDetail::Stacked(stacked_item) => {
-            Ok(join_all(stacked_item.entity_ids.iter()
-                        .map(|entity_id| {
-                            let mut entity_gateway = entity_gateway.clone();
-                            let mut character = character.clone();
-                            let mut item_state = item_state.clone();
-                            async move {
-                                apply_tool(&mut item_state, &mut entity_gateway, &mut character, *entity_id, stacked_item.tool.tool).await
-                            }
-                        })
-                        .collect::<Vec<_>>())
-               .await
-               .into_iter()
-               .collect::<Result<Vec<Vec<_>>, _>>()?
-               .into_iter()
-               .flatten()
-               .collect())
-        },
-    }
-}

src/items/src/bank.rs

@@ -1,366 +0,0 @@
-use std::cmp::Ordering;
-use libpso::character::character;
-use crate::ClientItemId;
-use entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, BankEntity, BankItemEntity};
-use std::future::Future;
-use async_std::sync::{Arc, Mutex};
-
-use entity::character::CharacterEntityId;
-use entity::item::BankIdentifier;
-use crate::state::ItemStateError;
-use crate::state::{IndividualItemDetail, StackedItemDetail, AddItemResult};
-use crate::inventory::{InventoryItem, InventoryItemDetail};
-
-
-#[derive(thiserror::Error, Debug)]
-pub enum BankError {
-    #[error("bank full")]
-    BankFull,
-    #[error("stack full")]
-    StackFull,
-    #[error("meseta full")]
-    MesetaFull,
-}
-
-
-
-#[derive(Clone, Debug)]
-pub enum BankItemDetail {
-    Individual(IndividualItemDetail),
-    Stacked(StackedItemDetail),
-}
-
-impl BankItemDetail {
-    fn stacked_mut(&mut self) -> Option<&mut StackedItemDetail> {
-        match self {
-            BankItemDetail::Stacked(sitem) => Some(sitem),
-            _ => None,
-        }
-    }
-
-    pub fn as_client_bytes(&self) -> [u8; 16] {
-        match self {
-            BankItemDetail::Individual(item) => {
-                match &item.item {
-                    ItemDetail::Weapon(w) => w.as_bytes(),
-                    ItemDetail::Armor(a) => a.as_bytes(),
-                    ItemDetail::Shield(s) => s.as_bytes(),
-                    ItemDetail::Unit(u) => u.as_bytes(),
-                    ItemDetail::Tool(t) => t.as_individual_bytes(),
-                    ItemDetail::TechniqueDisk(d) => d.as_bytes(),
-                    ItemDetail::Mag(m) => m.as_bytes(),
-                    ItemDetail::ESWeapon(e) => e.as_bytes(),
-                }
-            },
-            BankItemDetail::Stacked(item) => {
-                item.tool.as_stacked_bytes(item.entity_ids.len())
-            },
-        }
-    }
-}
-
-
-#[derive(Clone, Debug)]
-pub struct BankItem {
-    pub item_id: ClientItemId,
-    pub item: BankItemDetail,
-}
-
-impl BankItem {
-    pub async fn with_entity_id<F, Fut, T>(&self, mut param: T, mut func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId) -> Fut,
-        Fut: Future<Output=Result<T, anyhow::Error>>,
-    {
-        match &self.item {
-            BankItemDetail::Individual(individual_item) => {
-                param = func(param, individual_item.entity_id).await?;
-            },
-            BankItemDetail::Stacked(stacked_item) => {
-                for entity_id in &stacked_item.entity_ids {
-                    param = func(param, *entity_id).await?;
-                }
-            }
-        }
-        Ok(param)
-    }
-}
-
-
-#[derive(Clone, Debug)]
-pub struct Bank(Vec<BankItem>);
-
-impl Bank {
-    pub fn new(items: Vec<BankItem>) -> Bank {
-        Bank(items)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct BankState {
-    pub character_id: CharacterEntityId,
-    pub item_id_counter: Arc<Mutex<u32>>,
-    pub identifier: BankIdentifier,
-    pub bank: Bank,
-    pub meseta: Meseta,
-}
-
-async fn new_item_id(item_id_counter: &Arc<Mutex<u32>>) -> ClientItemId {
-    let mut item_id_counter = item_id_counter.lock().await;
-    let item_id = *item_id_counter;
-    *item_id_counter += 1;
-
-    ClientItemId(item_id)
-}
-
-impl BankState {
-    pub fn new(character_id: CharacterEntityId, identifier: BankIdentifier, mut bank: Bank, meseta: Meseta) -> BankState {
-        bank.0.sort();
-        BankState {
-            character_id,
-            item_id_counter: Arc::new(Mutex::new(0)),
-            identifier,
-            bank,
-            meseta,
-        }
-    }
-
-    pub fn count(&self) -> usize {
-        self.bank.0.len()
-    }
-
-    pub async fn initialize_item_ids(&mut self, base_item_id: Arc<Mutex<u32>>) {
-        self.item_id_counter = base_item_id;
-        let mut bitem_id = self.item_id_counter.lock().await;
-        for (i, item) in self.bank.0.iter_mut().enumerate() {
-            item.item_id = ClientItemId(*bitem_id + i as u32);
-        }
-
-        *bitem_id += self.bank.0.len() as u32;
-    }
-
-    pub fn add_meseta(&mut self, amount: u32) -> Result<(), anyhow::Error> {
-        if self.meseta.0 + amount > 999999 {
-            return Err(ItemStateError::FullOfMeseta.into())
-        }
-        self.meseta.0 += amount;
-        Ok(())
-    }
-
-    pub fn remove_meseta(&mut self, amount: u32) -> Result<(), anyhow::Error> {
-        if amount > self.meseta.0 {
-            return Err(ItemStateError::InvalidMesetaRemoval(amount).into())
-        }
-        self.meseta.0 -= amount;
-        Ok(())
-    }
-
-    pub fn add_inventory_item(&mut self, item: InventoryItem) -> Result<AddItemResult, anyhow::Error> {
-        match item.item {
-            InventoryItemDetail::Individual(iitem) => {
-                if self.bank.0.len() >= 30 {
-                    Err(BankError::BankFull.into())
-                }
-                else {
-                    self.bank.0.push(BankItem {
-                        item_id: item.item_id,
-                        item: BankItemDetail::Individual(iitem)
-                    });
-                    self.bank.0.sort();
-                    Ok(AddItemResult::NewItem)
-                }
-            },
-            InventoryItemDetail::Stacked(sitem) => {
-                let existing_stack = self.bank.0
-                    .iter_mut()
-                    .filter_map(|item| item.item.stacked_mut())
-                    .find(|item| {
-                        item.tool == sitem.tool
-                    });
-                match existing_stack {
-                    Some(existing_stack) => {
-                        if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() {
-                            Err(BankError::StackFull.into())
-                        }
-                        else {
-                            existing_stack.entity_ids.append(&mut sitem.entity_ids.clone());
-                            Ok(AddItemResult::AddToStack)
-                        }
-                    },
-                    None => {
-                        if self.bank.0.len() >= 30 {
-                            Err(BankError::BankFull.into())
-                        }
-                        else {
-                            self.bank.0.push(BankItem {
-                                item_id: item.item_id,
-                                item: BankItemDetail::Stacked(sitem)
-                            });
-                            self.bank.0.sort();
-                            Ok(AddItemResult::NewItem)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub async fn take_item(&mut self, item_id: &ClientItemId, amount: u32) -> Option<BankItem> {
-        let idx = self.bank.0
-            .iter()
-            .position(|i| i.item_id == *item_id)?;
-        match &mut self.bank.0[idx].item {
-            BankItemDetail::Individual(_individual_item) => {
-                Some(self.bank.0.remove(idx))
-            },
-            BankItemDetail::Stacked(stacked_item) => {
-                let remove_all = match stacked_item.entity_ids.len().cmp(&(amount as usize)) {
-                    Ordering::Equal => true,
-                    Ordering::Greater => false,
-                    Ordering::Less => return None,
-                };
-
-                if remove_all {
-                    Some(self.bank.0.remove(idx))
-                }
-                else {
-                    let entity_ids = stacked_item.entity_ids.drain(..(amount as usize)).collect();
-                    Some(BankItem {
-                        item_id: new_item_id(&self.item_id_counter).await,
-                        item: BankItemDetail::Stacked(StackedItemDetail {
-                            entity_ids,
-                            tool: stacked_item.tool,
-                        })})
-                }
-            }
-        }
-    }
-
-    pub fn as_client_bank_items(&self) -> character::Bank {
-        self.bank.0.iter()
-            .enumerate()
-            .fold(character::Bank::default(), |mut bank, (slot, item)| {
-                bank.item_count = (slot + 1) as u32;
-                let bytes = item.item.as_client_bytes();
-                bank.items[slot].data1.copy_from_slice(&bytes[0..12]);
-                bank.items[slot].data2.copy_from_slice(&bytes[12..16]);
-                bank.items[slot].item_id = item.item_id.0;
-
-                bank
-            })
-    }
-
-    pub fn as_client_bank_request(&self) -> Vec<character::BankItem> {
-        self.bank.0.iter()
-            .map(|item| {
-                let bytes = item.item.as_client_bytes();
-                let mut data1 = [0; 12];
-                let mut data2 = [0; 4];
-                data1.copy_from_slice(&bytes[0..12]);
-                data2.copy_from_slice(&bytes[12..16]);
-                let amount = match &item.item {
-                    BankItemDetail::Individual(_individual_bank_item) => {
-                        1
-                    },
-                    BankItemDetail::Stacked(stacked_bank_item) => {
-                        stacked_bank_item.count()
-                    },
-                };
-                character::BankItem {
-                    data1,
-                    data2,
-                    item_id: item.item_id.0,
-                    amount: amount as u16,
-                    flags: 1,
-                }
-            })
-            .collect()
-    }
-
-    pub fn as_bank_entity(&self) -> BankEntity {
-        BankEntity {
-            items: self.bank.0.iter()
-                .map(|item| {
-                    match &item.item {
-                        BankItemDetail::Individual(item) => {
-                            BankItemEntity::Individual(ItemEntity {
-                                id: item.entity_id,
-                                item: item.item.clone(),
-                            })
-                        },
-                        BankItemDetail::Stacked(items) => {
-                            BankItemEntity::Stacked(items.entity_ids.iter()
-                                                    .map(|id| {
-                                                        ItemEntity {
-                                                            id: *id,
-                                                            item: ItemDetail::Tool(items.tool)
-                                                        }
-                                                    })
-                                                    .collect())
-                        },
-                    }
-                })
-                .collect()
-        }
-    }
-}
-
-
-
-impl std::cmp::PartialEq for BankItemDetail {
-    fn eq(&self, other: &BankItemDetail) -> bool {
-        let mut self_bytes = [0u8; 4];
-        let mut other_bytes = [0u8; 4];
-        self_bytes.copy_from_slice(&self.as_client_bytes()[0..4]);
-        other_bytes.copy_from_slice(&other.as_client_bytes()[0..4]);
-
-        let self_value = u32::from_be_bytes(self_bytes);
-        let other_value = u32::from_be_bytes(other_bytes);
-
-        self_value.eq(&other_value)
-    }
-}
-
-impl std::cmp::Eq for BankItemDetail {}
-
-impl std::cmp::PartialOrd for BankItemDetail {
-    fn partial_cmp(&self, other: &BankItemDetail) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl std::cmp::Ord for BankItemDetail {
-    fn cmp(&self, other: &BankItemDetail) -> std::cmp::Ordering {
-        let mut self_bytes = [0u8; 4];
-        let mut other_bytes = [0u8; 4];
-        self_bytes.copy_from_slice(&self.as_client_bytes()[0..4]);
-        other_bytes.copy_from_slice(&other.as_client_bytes()[0..4]);
-
-        let self_value = u32::from_be_bytes(self_bytes);
-        let other_value = u32::from_be_bytes(other_bytes);
-
-        self_value.cmp(&other_value)
-    }
-}
-
-
-impl std::cmp::PartialEq for BankItem {
-    fn eq(&self, other: &BankItem) -> bool {
-        self.item.eq(&other.item)
-    }
-}
-
-impl std::cmp::Eq for BankItem {}
-
-impl std::cmp::PartialOrd for BankItem {
-    fn partial_cmp(&self, other: &BankItem) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl std::cmp::Ord for BankItem {
-    fn cmp(&self, other: &BankItem) -> std::cmp::Ordering {
-        self.item.cmp(&other.item)
-    }
-}
-

src/items/src/floor.rs

@@ -1,139 +0,0 @@
-use crate::ClientItemId;
-use entity::item::{Meseta, ItemEntityId, ItemDetail};
-use std::future::Future;
-
-use maps::area::MapArea;
-use entity::character::CharacterEntityId;
-use entity::item::mag::Mag;
-
-use crate::state::ItemStateError;
-use crate::state::{IndividualItemDetail, StackedItemDetail};
-use crate::inventory::{InventoryItem, InventoryItemDetail};
-
-pub enum FloorType {
-    Local,
-    Shared,
-}
-
-#[derive(Debug, Clone)]
-pub enum FloorItemDetail {
-    Individual(IndividualItemDetail),
-    Stacked(StackedItemDetail),
-    Meseta(Meseta),
-}
-
-#[derive(Debug, Clone)]
-pub struct FloorItem {
-    pub item_id: ClientItemId,
-    pub item: FloorItemDetail,
-    pub map_area: MapArea,
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
-}
-
-impl FloorItem {
-    pub async fn with_entity_id<F, Fut, T>(&self, mut param: T, mut func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId) -> Fut,
-        Fut: Future<Output=Result<T, ItemStateError>>,
-    {
-        match &self.item {
-            FloorItemDetail::Individual(individual_item) => {
-                param = func(param, individual_item.entity_id).await?;
-            },
-            FloorItemDetail::Stacked(stacked_item) => {
-                for entity_id in &stacked_item.entity_ids {
-                    param = func(param, *entity_id).await?;
-                }
-            },
-            FloorItemDetail::Meseta(_meseta) => {},
-        }
-
-        Ok(param)
-    }
-
-    pub async fn with_mag<F, Fut, T>(&self, mut param: T, mut func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId, Mag) -> Fut,
-        Fut: Future<Output=Result<T, anyhow::Error>>,
-    {
-        if let FloorItemDetail::Individual(individual_item) = &self.item {
-            if let ItemDetail::Mag(mag) = &individual_item.item {
-                param = func(param, individual_item.entity_id, mag.clone()).await?;
-            }
-        }
-        Ok(param)
-    }
-
-    pub fn as_client_bytes(&self) -> [u8; 16] {
-        match &self.item {
-            FloorItemDetail::Individual(individual_floor_item) => {
-                individual_floor_item.item.as_client_bytes()
-            },
-            FloorItemDetail::Stacked(stacked_floor_item) => {
-                stacked_floor_item.tool.as_stacked_bytes(stacked_floor_item.entity_ids.len())
-            },
-            FloorItemDetail::Meseta(meseta_floor_item) => {
-                meseta_floor_item.as_bytes()
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct LocalFloor(pub Vec<FloorItem>);
-#[derive(Debug, Clone, Default)]
-pub struct SharedFloor(pub Vec<FloorItem>);
-
-#[derive(Debug)]
-pub struct FloorState {
-    pub character_id: CharacterEntityId,
-    pub local: LocalFloor,
-    pub shared: SharedFloor,
-}
-
-impl FloorState {
-    pub fn take_item(&mut self, item_id: &ClientItemId) -> Option<FloorItem> {
-        let item = self.local.0
-            .extract_if(|item| {
-                item.item_id == *item_id
-            })
-            .next();
-        item.or_else(|| {
-            self.shared.0
-                .extract_if(|item| {
-                    item.item_id == *item_id
-                })
-                .next()
-        })
-    }
-
-    pub fn add_inventory_item(&mut self, inventory_item: InventoryItem, map_area: MapArea, position: (f32, f32, f32)) -> &FloorItem {
-        let floor_item = FloorItem {
-            item_id: inventory_item.item_id,
-            item: match inventory_item.item {
-                InventoryItemDetail::Individual(individual_item) => FloorItemDetail::Individual(individual_item),
-                InventoryItemDetail::Stacked(stacked_item) => FloorItemDetail::Stacked(stacked_item),
-            },
-            map_area,
-            x: position.0,
-            y: position.1,
-            z: position.2,
-        };
-
-        self.shared.0.push(floor_item);
-        &self.shared.0[self.shared.0.len()-1]
-    }
-
-    pub fn add_shared_item(&mut self, floor_item: FloorItem) -> &FloorItem {
-        self.shared.0.push(floor_item);
-        &self.shared.0[self.shared.0.len()-1]
-    }
-
-    pub fn add_local_item(&mut self, floor_item: FloorItem) -> &FloorItem {
-        self.local.0.push(floor_item);
-        &self.local.0[self.local.0.len()-1]
-    }
-}
-

src/items/src/inventory.rs

@@ -1,593 +0,0 @@
-use std::cmp::Ordering;
-use libpso::character::character;
-use crate::ClientItemId;
-use entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, InventoryEntity, InventoryItemEntity, EquippedEntity};
-use std::future::Future;
-use async_std::sync::{Arc, Mutex};
-
-use entity::character::CharacterEntityId;
-use entity::item::tool::ToolType;
-use entity::item::mag::Mag;
-use entity::item::weapon::Weapon;
-use shops::{ShopItem, ArmorShopItem, ToolShopItem, WeaponShopItem};
-use crate::state::ItemStateError;
-use crate::state::{IndividualItemDetail, StackedItemDetail, AddItemResult};
-use crate::floor::{FloorItem, FloorItemDetail};
-
-#[derive(Clone, Debug)]
-pub enum InventoryItemDetail {
-    Individual(IndividualItemDetail),
-    Stacked(StackedItemDetail),
-}
-
-impl InventoryItemDetail {
-    // TODO: rename as_stacked for consistency
-    pub fn stacked(&self) -> Option<&StackedItemDetail> {
-        match self {
-            InventoryItemDetail::Stacked(sitem) => Some(sitem),
-            _ => None,
-        }
-    }
-    // TODO: rename as_stacked_mut for consistency
-    pub fn stacked_mut(&mut self) -> Option<&mut StackedItemDetail> {
-        match self {
-            InventoryItemDetail::Stacked(sitem) => Some(sitem),
-            _ => None,
-        }
-    }
-
-    pub fn as_individual(&self) -> Option<&IndividualItemDetail> {
-        match self {
-            InventoryItemDetail::Individual(iitem) => Some(iitem),
-            _ => None,
-        }
-    }
-
-    pub fn as_individual_mut(&mut self) -> Option<&mut IndividualItemDetail> {
-        match self {
-            InventoryItemDetail::Individual(iitem) => Some(iitem),
-            _ => None,
-        }
-    }
-
-    pub fn as_client_bytes(&self) -> [u8; 16] {
-        match self {
-            InventoryItemDetail::Individual(item) => {
-                item.as_client_bytes()
-            },
-            InventoryItemDetail::Stacked(item) => {
-                item.tool.as_stacked_bytes(item.entity_ids.len())
-            },
-        }
-    }
-
-    // TODO: this should probably go somewhere a bit more fundamental like ItemDetail
-    pub fn sell_price(&self) -> Result<u32, anyhow::Error> {
-        match self {
-            InventoryItemDetail::Individual(individual_item) => {
-                match &individual_item.item {
-                    // TODO: can wrapped items be sold?
-                    ItemDetail::Weapon(w) => {
-                        if !w.tekked {
-                            return Ok(1u32)
-                        }
-                        if w.is_rare_item() {
-                            return Ok(10u32)
-                        }
-                        Ok((WeaponShopItem::from(w).price() / 8) as u32)
-                    },
-                    ItemDetail::Armor(a) => {
-                        if a.is_rare_item() {
-                            return Ok(10u32)
-                        }
-                        Ok((ArmorShopItem::from(a).price() / 8) as u32)
-                    },
-                    ItemDetail::Shield(s) => {
-                        if s.is_rare_item() {
-                            return Ok(10u32)
-                        }
-                        Ok((ArmorShopItem::from(s).price() / 8) as u32)
-                    },
-                    ItemDetail::Unit(u) => {
-                        if u.is_rare_item() {
-                            return Ok(10u32)
-                        }
-                        Ok((ArmorShopItem::from(u).price() / 8) as u32)
-                    },
-                    ItemDetail::Tool(t) => {
-                        if !matches!(t.tool, ToolType::PhotonDrop | ToolType::PhotonSphere | ToolType::PhotonCrystal) && t.is_rare_item() {
-                            return Ok(10u32)
-                        }
-                        Ok((ToolShopItem::from(t).price() / 8) as u32)
-                    },
-                    ItemDetail::TechniqueDisk(d) => {
-                        Ok((ToolShopItem::from(d).price() / 8) as u32)
-                    },
-                    ItemDetail::Mag(_m) => {
-                        Err(ItemStateError::ItemNotSellable.into())
-                    },
-                    ItemDetail::ESWeapon(_e) => {
-                        Ok(10u32)
-                    },
-                }
-            },
-            // the number of stacked items sold is handled by the caller. this is just the price of 1
-            InventoryItemDetail::Stacked(stacked_item) => {
-                Ok(((ToolShopItem::from(&stacked_item.tool).price() / 8) as u32) * stacked_item.count() as u32)
-            },
-        }
-    }
-
-    pub async fn with_entity_id<F, Fut, T>(&self, mut param: T, mut func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId) -> Fut,
-        Fut: Future<Output=Result<T, anyhow::Error>>,
-    {
-        match &self {
-            InventoryItemDetail::Individual(individual_item) => {
-                param = func(param, individual_item.entity_id).await?;
-            },
-            InventoryItemDetail::Stacked(stacked_item) => {
-                for entity_id in &stacked_item.entity_ids {
-                    param = func(param, *entity_id).await?;
-                }
-            }
-        }
-
-        Ok(param)
-    }
-}
-
-
-#[derive(Clone, Debug)]
-pub struct InventoryItem {
-    pub item_id: ClientItemId,
-    pub item: InventoryItemDetail,
-}
-
-impl InventoryItem {
-    pub async fn with_entity_id<F, Fut, T>(&self, param: T, func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId) -> Fut,
-        Fut: Future<Output=Result<T, anyhow::Error>>,
-    {
-        self.item.with_entity_id(param, func).await
-    }
-
-    pub async fn with_mag<F, Fut, T>(&self, mut param: T, mut func: F) -> Result<T, anyhow::Error>
-    where
-        F: FnMut(T, ItemEntityId, Mag) -> Fut,
-        Fut: Future<Output=Result<T, anyhow::Error>>,
-    {
-        if let InventoryItemDetail::Individual(individual_item) = &self.item {
-            if let ItemDetail::Mag(mag) = &individual_item.item {
-                param = func(param, individual_item.entity_id, mag.clone()).await?;
-            }
-        }
-        Ok(param)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct Inventory(Vec<InventoryItem>);
-
-impl Inventory {
-    pub fn new(items: Vec<InventoryItem>) -> Inventory {
-        Inventory(items)
-    }
-}
-
-
-#[derive(thiserror::Error, Debug)]
-pub enum InventoryError {
-    #[error("inventory full")]
-    InventoryFull,
-    #[error("stack full")]
-    StackFull,
-    #[error("meseta full")]
-    MesetaFull,
-}
-
-#[derive(Clone, Debug)]
-pub struct InventoryState {
-    pub character_id: CharacterEntityId,
-    pub item_id_counter: Arc<Mutex<u32>>,
-    pub inventory: Inventory,
-    pub equipped: EquippedEntity,
-    pub meseta: Meseta,
-}
-
-async fn new_item_id(item_id_counter: &Arc<Mutex<u32>>) -> ClientItemId {
-    let mut item_id_counter = item_id_counter.lock().await;
-    let item_id = *item_id_counter;
-    *item_id_counter += 1;
-
-    ClientItemId(item_id)
-}
-
-impl InventoryState {
-    pub async fn initialize_item_ids(&mut self, base_item_id: Arc<Mutex<u32>>) {
-        self.item_id_counter = base_item_id;
-        let mut bitem_id = self.item_id_counter.lock().await;
-
-        for (i, item) in self.inventory.0.iter_mut().enumerate() {
-            item.item_id = ClientItemId(*bitem_id + i as u32);
-        }
-
-        *bitem_id += self.inventory.0.len() as u32;
-    }
-
-    pub async fn new_item_id(&mut self) -> ClientItemId {
-        let mut item_id_counter = self.item_id_counter.lock().await;
-        let item_id = *item_id_counter;
-        *item_id_counter += 1;
-
-        ClientItemId(item_id)
-    }
-
-    pub fn count(&self) -> usize {
-        self.inventory.0.len()
-    }
-
-    pub fn add_floor_item(&mut self, item: FloorItem) -> Result<AddItemResult, anyhow::Error> {
-        match item.item {
-            FloorItemDetail::Individual(iitem) => {
-                if self.inventory.0.len() >= 30 {
-                    Err(InventoryError::InventoryFull.into())
-                }
-                else {
-                    self.inventory.0.push(InventoryItem {
-                        item_id: item.item_id,
-                        item: InventoryItemDetail::Individual(iitem)
-                    });
-                    Ok(AddItemResult::NewItem)
-                }
-            },
-            FloorItemDetail::Stacked(sitem) => {
-                let existing_stack = self.inventory.0
-                    .iter_mut()
-                    .filter_map(|item| item.item.stacked_mut())
-                    .find(|item| {
-                        item.tool == sitem.tool
-                    });
-                match existing_stack {
-                    Some(existing_stack) => {
-                        if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() {
-                            Err(InventoryError::StackFull.into())
-                        }
-                        else {
-                            existing_stack.entity_ids.append(&mut sitem.entity_ids.clone());
-                            Ok(AddItemResult::AddToStack)
-                        }
-                    },
-                    None => {
-                        if self.inventory.0.len() >= 30 {
-                            Err(InventoryError::InventoryFull.into())
-                        }
-                        else {
-                            self.inventory.0.push(InventoryItem {
-                                item_id: item.item_id,
-                                item: InventoryItemDetail::Stacked(sitem)
-                            });
-                            Ok(AddItemResult::NewItem)
-                        }
-                    }
-                }
-
-            },
-            FloorItemDetail::Meseta(meseta) => {
-                if self.meseta == Meseta(999999) {
-                    Err(InventoryError::MesetaFull.into())
-                }
-                else {
-                    self.meseta.0 = std::cmp::min(self.meseta.0 + meseta.0, 999999);
-                    Ok(AddItemResult::Meseta)
-                }
-            },
-        }
-    }
-
-    pub fn add_item(&mut self, item: InventoryItem) -> Result<(AddItemResult, InventoryItem), anyhow::Error> {
-        match &item.item {
-            InventoryItemDetail::Individual(_) => {
-                if self.inventory.0.len() >= 30 {
-                    Err(InventoryError::InventoryFull.into())
-                }
-                else {
-                    self.inventory.0.push(item);
-                    Ok((
-                        AddItemResult::NewItem,
-                        self.inventory.0
-                            .last()
-                            .unwrap()
-                            .clone()
-                    ))
-                }
-            },
-            InventoryItemDetail::Stacked(sitem) => {
-                let existing_stack = self.inventory.0
-                    .iter_mut()
-                    .filter_map(|item| item.item.stacked_mut())
-                    .find(|item| {
-                        item.tool == sitem.tool
-                    });
-                match existing_stack {
-                    Some(existing_stack) => {
-                        if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() {
-                            Err(InventoryError::StackFull.into())
-                        }
-                        else {
-                            existing_stack.entity_ids.append(&mut sitem.entity_ids.clone());
-                            Ok((
-                                AddItemResult::AddToStack,
-                                self.inventory.0[self.inventory.0
-                                                 .iter()
-                                                 .filter_map(|item| item.item.stacked())
-                                                 .position(|item| item.tool == sitem.tool)
-                                                 .unwrap()]
-                                    .clone()
-                            ))
-                        }
-                    },
-                    None => {
-                        if self.inventory.0.len() >= 30 {
-                            Err(InventoryError::InventoryFull.into())
-                        }
-                        else {
-                            self.inventory.0.push(item);
-                            Ok((
-                                AddItemResult::NewItem,
-                                self.inventory.0
-                                    .last()
-                                    .unwrap()
-                                    .clone()
-                            ))
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub async fn remove_item(&mut self, item_id: &ClientItemId, amount: u32) -> Option<InventoryItemDetail> {
-        let idx = self.inventory.0
-            .iter()
-            .position(|i| i.item_id == *item_id)?;
-        match &mut self.inventory.0[idx].item {
-            InventoryItemDetail::Individual(_individual_item) => {
-                Some(self.inventory.0.remove(idx).item)
-            },
-            InventoryItemDetail::Stacked(stacked_item) => {
-                let remove_all = (amount == 0) || match stacked_item.entity_ids.len().cmp(&(amount as usize)) {
-                    Ordering::Equal => true,
-                    Ordering::Greater => false,
-                    Ordering::Less => return None,
-                };
-
-                if remove_all {
-                    Some(self.inventory.0.remove(idx).item)
-                }
-                else {
-                    let entity_ids = stacked_item.entity_ids.drain(..(amount as usize)).collect();
-                    Some(InventoryItemDetail::Stacked(StackedItemDetail {
-                        entity_ids,
-                        tool: stacked_item.tool,
-                    }))
-                }
-            }
-        }
-    }
-
-    pub async fn take_item(&mut self, item_id: &ClientItemId, amount: u32) -> Option<InventoryItem> {
-        let idx = self.inventory.0
-            .iter()
-            .position(|i| i.item_id == *item_id)?;
-        match &mut self.inventory.0[idx].item {
-            InventoryItemDetail::Individual(_individual_item) => {
-                Some(self.inventory.0.remove(idx))
-            },
-            InventoryItemDetail::Stacked(stacked_item) => {
-                let remove_all = (amount == 0) || match stacked_item.entity_ids.len().cmp(&(amount as usize)) {
-                    Ordering::Equal => true,
-                    Ordering::Greater => false,
-                    Ordering::Less => return None,
-                };
-
-                if remove_all {
-                    Some(self.inventory.0.remove(idx))
-                }
-                else {
-                    let entity_ids = stacked_item.entity_ids.drain(..(amount as usize)).collect();
-                    Some(InventoryItem {
-                        item_id: new_item_id(&self.item_id_counter).await,
-                        item: InventoryItemDetail::Stacked(StackedItemDetail {
-                            entity_ids,
-                            tool: stacked_item.tool,
-                        })})
-                }
-            }
-        }
-    }
-
-    // TODO: rename get_item_by_client_id
-    pub fn get_by_client_id(&self, item_id: &ClientItemId) -> Option<&InventoryItem> {
-        self.inventory.0
-            .iter()
-            .find(|i| i.item_id == *item_id)
-    }
-
-    pub fn get_by_client_id_mut(&mut self, item_id: &ClientItemId) -> Option<&mut InventoryItem> {
-        self.inventory.0
-            .iter_mut()
-            .find(|i| i.item_id == *item_id)
-    }
-
-    pub fn add_meseta(&mut self, amount: u32) -> Result<(), anyhow::Error> {
-        if self.meseta.0 == 999999 {
-            return Err(ItemStateError::FullOfMeseta.into())
-        }
-        self.meseta.0 = std::cmp::min(self.meseta.0 + amount, 999999);
-        Ok(())
-    }
-
-    pub fn add_meseta_no_overflow(&mut self, amount: u32) -> Result<(), anyhow::Error> {
-        if self.meseta.0 + amount > 999999 {
-            return Err(ItemStateError::FullOfMeseta.into())
-        }
-        self.meseta.0 += amount;
-        Ok(())
-    }
-
-    pub fn remove_meseta(&mut self, amount: u32) -> Result<(), anyhow::Error> {
-        if amount > self.meseta.0 {
-            return Err(ItemStateError::InvalidMesetaRemoval(amount).into())
-        }
-        self.meseta.0 -= amount;
-        Ok(())
-    }
-
-    pub fn equip(&mut self, item_id: &ClientItemId, equip_slot: u8) {
-        for item in &self.inventory.0 {
-            if let InventoryItemDetail::Individual(inventory_item) = &item.item {
-                if item.item_id == *item_id {
-                    match inventory_item.item {
-                        ItemDetail::Weapon(_) => self.equipped.weapon = Some(inventory_item.entity_id),
-                        ItemDetail::Armor(_) => self.equipped.armor = Some(inventory_item.entity_id),
-                        ItemDetail::Shield(_) => self.equipped.shield = Some(inventory_item.entity_id),
-                        ItemDetail::Unit(_) => {
-                            if let Some(unit) = self.equipped.unit.get_mut(equip_slot as usize) {
-                                *unit = Some(inventory_item.entity_id)
-                            }
-                        }
-                        ItemDetail::Mag(_) => self.equipped.mag = Some(inventory_item.entity_id),
-                        _ => {}
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn unequip(&mut self, item_id: &ClientItemId) {
-        for item in &self.inventory.0 {
-            if let InventoryItemDetail::Individual(inventory_item) = &item.item {
-                if item.item_id == *item_id {
-                    match inventory_item.item {
-                        ItemDetail::Weapon(_) => self.equipped.weapon = None,
-                        ItemDetail::Armor(_) => {
-                            self.equipped.armor = None;
-                            self.equipped.unit = [None; 4];
-                        }
-                        ItemDetail::Shield(_) => self.equipped.shield = None,
-                        ItemDetail::Unit(_) => {
-                            for unit in self.equipped.unit.iter_mut() {
-                                if *unit == Some(inventory_item.entity_id) {
-                                    *unit = None
-                                }
-                            }
-                        }
-                        ItemDetail::Mag(_) => self.equipped.mag = Some(inventory_item.entity_id),
-                        _ => {}
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn equipped_mag_mut(&mut self) -> Option<(ItemEntityId, &mut Mag)> {
-        let mag_id = self.equipped.mag?;
-        self.inventory.0
-            .iter_mut()
-            .filter_map(|i| {
-                let individual = i.item.as_individual_mut()?;
-                let entity_id = individual.entity_id;
-                Some((entity_id, individual.as_mag_mut()?))
-            })
-            .find(|(entity_id, _)| *entity_id == mag_id)
-    }
-
-    pub fn equipped_weapon_mut(&mut self) -> Option<(ItemEntityId, &mut Weapon)> {
-        let weapon_id = self.equipped.weapon?;
-        self.inventory.0
-            .iter_mut()
-            .filter_map(|i| {
-                let individual = i.item.as_individual_mut()?;
-                let entity_id = individual.entity_id;
-                Some((entity_id, individual.as_weapon_mut()?))
-            })
-            .find(|(entity_id, _)| *entity_id == weapon_id)
-    }
-
-    pub fn sort(&mut self, item_ids: &[ClientItemId]) {
-        self.inventory.0.sort_by(|a, b| {
-            let a_index = item_ids.iter().position(|item_id| *item_id == a.item_id);
-            let b_index = item_ids.iter().position(|item_id| *item_id == b.item_id);
-
-            match (a_index, b_index) {
-                (Some(a_index), Some(b_index)) => {
-                    a_index.cmp(&b_index)
-                },
-                _ => Ordering::Equal
-            }
-        });
-    }
-
-    pub fn as_inventory_entity(&self, _character_id: &CharacterEntityId) -> InventoryEntity {
-        InventoryEntity {
-            items: self.inventory.0.iter()
-                .map(|item| {
-                    match &item.item {
-                        InventoryItemDetail::Individual(item) => {
-                            InventoryItemEntity::Individual(ItemEntity {
-                                id: item.entity_id,
-                                item: item.item.clone(),
-                            })
-                        },
-                        InventoryItemDetail::Stacked(items) => {
-                            InventoryItemEntity::Stacked(items.entity_ids.iter()
-                                                         .map(|id| {
-                                                             ItemEntity {
-                                                                 id: *id,
-                                                                 item: ItemDetail::Tool(items.tool)
-                                                             }
-                                                         })
-                                                         .collect())
-                        },
-                    }
-                })
-                .collect()
-        }
-    }
-
-    pub fn as_equipped_entity(&self) -> EquippedEntity {
-        self.equipped.clone()
-    }
-
-
-    pub fn as_client_inventory_items(&self) -> [character::InventoryItem; 30] {
-        self.inventory.0.iter()
-            .enumerate()
-            .fold([character::InventoryItem::default(); 30], |mut inventory, (slot, item)| {
-                let bytes = item.item.as_client_bytes();
-                inventory[slot].data1.copy_from_slice(&bytes[0..12]);
-                inventory[slot].data2.copy_from_slice(&bytes[12..16]);
-                inventory[slot].item_id = item.item_id.0;
-                inventory[slot].equipped = 0;
-                inventory[slot].flags = 0;
-
-                if let InventoryItemDetail::Individual(individual_item) = &item.item {
-                    if self.equipped.is_equipped(&individual_item.entity_id) {
-                        if let ItemDetail::Unit(_) = individual_item.item {
-                            inventory[slot].data1[4] = self.equipped.unit.iter()
-                                .enumerate()
-                                .find(|(_, u_id)| **u_id == Some(individual_item.entity_id))
-                                .map(|(a, _)| a)
-                                .unwrap_or(0) as u8
-                        }
-                        inventory[slot].equipped = 1;
-                        inventory[slot].flags |= 8;
-                    }
-                }
-                inventory
-            })
-    }
-}

src/items/src/itemstateaction.rs

@@ -1,140 +0,0 @@
-use std::future::Future;
-
-#[async_trait::async_trait]
-pub trait ItemAction {
-    type Input;
-    type Output;
-    type Start;
-    type Error;
-
-    async fn action(&self, s: Self::Start, i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error>;
-    async fn commit(&self, v: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error>;
-}
-
-
-pub struct ItemStateAction<T, S, E> {
-    _t: std::marker::PhantomData<T>,
-    _s: std::marker::PhantomData<S>,
-    _e: std::marker::PhantomData<E>,
-}
-
-impl<T, S, E> Default for ItemStateAction<T, S, E> {
-    fn default() -> ItemStateAction<T, S, E> {
-        ItemStateAction {
-            _t: std::marker::PhantomData,
-            _s: std::marker::PhantomData,
-            _e: std::marker::PhantomData,
-        }
-    }
-}
-
-impl<T, S, E> ItemStateAction<T, S, E>
-where
-    T: Send + Sync,
-    S: Send + Sync,
-    E: Send + Sync,
-{
-    pub fn act<'a, O, F, Fut>(self, f: F) -> ItemActionStage<'a, O, ItemStateAction<T, S, E>, F, Fut, S, E>
-    where
-        F: Fn(S, ()) -> Fut + Send + Sync + 'a,
-        Fut: Future<Output=Result<(S, O), E>> + Send + 'a
-    {
-        ItemActionStage {
-            _s: Default::default(),
-            _e: std::marker::PhantomData,
-            _a: Default::default(),
-            prev: self,
-            actionf: f,
-        }
-    }
-}
-
-pub struct ItemActionStage<'a, O, P, F, Fut, S, E>
-where
-    P: ItemAction,
-    F: Fn(S, P::Output) -> Fut + Send + Sync + 'a,
-    Fut: Future<Output=Result<(S, O) , E>> + Send + 'a,
-{
-    _s: std::marker::PhantomData<S>,
-    _e: std::marker::PhantomData<E>,
-    _a: std::marker::PhantomData<&'a ()>,
-    prev: P,
-    actionf: F,
-}
-
-#[async_trait::async_trait]
-impl<'a, O, P: ItemAction, F, Fut, S, E> ItemAction for ItemActionStage<'a, O, P, F, Fut, S, E>
-where
-    P: ItemAction + ItemAction<Start = S, Error = E> + Send + Sync,
-    F: Fn(S, P::Output) -> Fut + Send + Sync + 'a,
-    Fut: Future<Output=Result<(S, O), E>> + Send + 'a,
-    S: Send + Sync,
-    P::Output: Send + Sync,
-    E: Send + Sync,
-    O: Send + Sync,
-    P::Error: Send + Sync,
-{
-    type Input = P::Output;
-    type Output = O;
-    type Start = S;
-    type Error = P::Error;
-
-    async fn action(&self, s: Self::Start, i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error> {
-        (self.actionf)(s, i).await
-    }
-
-    async fn commit(&self, i: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error> {
-        let (i, prev) = self.prev.commit(i).await?;
-        self.action(i, prev).await
-    }
-}
-
-impl<'a, O, P: ItemAction, F, Fut, S, E> ItemActionStage<'a, O, P, F, Fut, S, E>
-where
-    P: ItemAction<Start = S, Error = E> + Send + Sync,
-    F: Fn(S, P::Output) -> Fut + Send + Sync + 'a,
-    Fut: Future<Output=Result<(S, O), E>> + Send + 'a,
-    S: Send + Sync,
-    P::Output: Send + Sync,
-    E: Send + Sync,
-    O: Send + Sync,
-    P::Error: Send + Sync,
-{
-    #[allow(clippy::type_complexity)]
-    pub fn act<'b, O2, G, GFut>(self, g: G) -> ItemActionStage<'b, O2, ItemActionStage<'a, O, P, F, Fut, S, E>, G, GFut, S, E>
-    where
-        S: Send + Sync,
-        G: Fn(S, <ItemActionStage<'a, O, P, F, Fut, S, E> as ItemAction>::Output) -> GFut + Send + Sync + 'b,
-        GFut: Future<Output=Result<(S, O2), E>> + Send + 'b,
-        O2: Send + Sync,
-    {
-        ItemActionStage {
-            _s: Default::default(),
-            _e: Default::default(),
-            _a: Default::default(),
-            prev: self,
-            actionf: g,
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl<T, S, E> ItemAction for ItemStateAction<T, S, E>
-where
-    T: Send + Sync,
-    S: Send + Sync,
-    E: Send + Sync,
-{
-    type Input = T;
-    type Output = ();
-    type Start = T;
-    type Error = E;
-
-    async fn action(&self, s: Self::Start, _i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error> {
-        Ok((s, ()))
-    }
-
-    async fn commit(&self, i: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error> {
-        Ok((i, ()))
-    }
-}

src/items/src/lib.rs

@@ -1,14 +0,0 @@
-#![feature(extract_if)]
-
-pub mod state;
-pub mod actions;
-pub mod apply_item;
-pub mod itemstateaction;
-pub mod inventory;
-pub mod floor;
-pub mod bank;
-pub mod tasks;
-pub mod trade;
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, serde::Serialize, serde::Deserialize, derive_more::Display)]
-pub struct ClientItemId(pub u32);

src/items/src/state.rs

@@ -1,561 +0,0 @@
-use std::collections::{HashMap, BinaryHeap};
-use std::cmp::Reverse;
-use async_std::sync::{Arc, RwLock, Mutex};
-use futures::stream::{FuturesOrdered, StreamExt};
-use anyhow::Context;
-
-use entity::gateway::{EntityGateway, GatewayError};
-use entity::character::{CharacterEntity, CharacterEntityId};
-use entity::item::{ItemEntityId, ItemDetail, ItemEntity, InventoryItemEntity, BankItemEntity, BankIdentifier};
-use entity::item::tool::Tool;
-use entity::item::weapon::Weapon;
-use entity::item::mag::Mag;
-use drops::ItemDrop;
-use crate::ClientItemId;
-use crate::inventory::{Inventory, InventoryItem, InventoryItemDetail, InventoryError, InventoryState};
-use crate::floor::{FloorState, FloorItem, LocalFloor, SharedFloor, FloorType};
-use crate::bank::{Bank, BankState, BankItem, BankItemDetail, BankError};
-use location::{AreaClient, RoomId};
-
-#[derive(thiserror::Error, Debug)]
-pub enum ItemStateError {
-    #[error("character {0} not found")]
-    NoCharacter(CharacterEntityId),
-    #[error("room {0} not found")]
-    NoRoom(RoomId),
-    #[error("inventory item {0} not found")]
-    NoInventoryItem(ClientItemId),
-    #[error("floor item {0} not found")]
-    NoFloorItem(ClientItemId),
-    #[error("expected {0} to be a tool")]
-    NotATool(ClientItemId),
-    #[error("bank item {0} not found")]
-    NoBankItem(ClientItemId),
-    #[error("inventory error {0}")]
-    InventoryError(#[from] InventoryError),
-    #[error("bank error {0}")]
-    BankError(#[from] BankError),
-    #[error("invalid item id {0}")]
-    InvalidItemId(ClientItemId),
-    #[error("invalid drop? {0:?} (this shouldn't occur)")]
-    BadItemDrop(ItemDrop),
-    #[error("idk")]
-    Dummy,
-    #[error("gateway")]
-    GatewayError(#[from] GatewayError),
-    #[error("tried to remove more meseta than exists: {0}")]
-    InvalidMesetaRemoval(u32),
-    #[error("tried to add meseta when there is no more room")]
-    FullOfMeseta,
-    #[error("stacked item")]
-    StackedItemError(Vec<ItemEntity>),
-    #[error("apply item {0}")]
-    ApplyItemError(#[from] crate::apply_item::ApplyItemError),
-    #[error("item is not a mag {0}")]
-    NotAMag(ClientItemId),
-    #[error("item is not mag food {0}")]
-    NotMagFood(ClientItemId),
-    #[error("item is not sellable")]
-    ItemNotSellable,
-    #[error("could not modify item")]
-    InvalidModifier,
-    #[error("wrong item type {0}")]
-    WrongItemType(ClientItemId),
-}
-
-
-#[derive(Clone, Debug)]
-pub struct IndividualItemDetail {
-    pub entity_id: ItemEntityId,
-    pub item: ItemDetail,
-}
-
-impl IndividualItemDetail {
-    pub fn as_weapon(&self) -> Option<&Weapon> {
-        match &self.item {
-            ItemDetail::Weapon(weapon) => Some(weapon),
-            _ => None
-        }
-    }
-
-    pub fn as_mag(&self) -> Option<&Mag> {
-        match &self.item {
-            ItemDetail::Mag(mag) => Some(mag),
-            _ => None
-        }
-    }
-
-    pub fn as_mag_mut(&mut self) -> Option<&mut Mag> {
-        match &mut self.item {
-            ItemDetail::Mag(mag) => Some(mag),
-            _ => None
-        }
-    }
-
-    pub fn as_weapon_mut(&mut self) -> Option<&mut Weapon> {
-        match &mut self.item {
-            ItemDetail::Weapon(weapon) => Some(weapon),
-            _ => None
-        }
-    }
-
-
-    pub fn as_client_bytes(&self) -> [u8; 16] {
-        match &self.item {
-            ItemDetail::Weapon(w) => w.as_bytes(),
-            ItemDetail::Armor(a) => a.as_bytes(),
-            ItemDetail::Shield(s) => s.as_bytes(),
-            ItemDetail::Unit(u) => u.as_bytes(),
-            ItemDetail::Tool(t) => t.as_individual_bytes(),
-            ItemDetail::TechniqueDisk(d) => d.as_bytes(),
-            ItemDetail::Mag(m) => m.as_bytes(),
-            ItemDetail::ESWeapon(e) => e.as_bytes(),
-        }
-    }
-
-}
-
-#[derive(Clone, Debug)]
-pub struct StackedItemDetail {
-    pub entity_ids: Vec<ItemEntityId>,
-    pub tool: Tool,
-}
-
-impl StackedItemDetail {
-    pub fn count(&self) -> usize {
-        self.entity_ids.len()
-    }
-}
-
-
-#[derive(Clone)]
-pub enum AddItemResult {
-    NewItem,
-    AddToStack,
-    Meseta,
-}
-
-#[derive(Clone, Debug)]
-struct RoomGemItemIdCounter {
-    inventory: [Arc<Mutex<u32>>; 4],
-    bank: [Arc<Mutex<u32>>; 4],
-}
-
-impl Default for RoomGemItemIdCounter {
-    fn default() -> RoomGemItemIdCounter {
-        RoomGemItemIdCounter {
-            inventory: core::array::from_fn(|gem| Arc::new(Mutex::new(((gem as u32) << 21) | 0x10000))),
-            bank: core::array::from_fn(|gem| Arc::new(Mutex::new(((gem as u32) << 21) | 0x20000))),
-        }
-    }
-}
-
-impl RoomGemItemIdCounter {
-    fn inventory(&self, area_client: &AreaClient) -> Arc<Mutex<u32>> {
-        self.inventory[area_client.local_client.id() as usize].clone()
-    }
-
-    fn bank(&self, area_client: &AreaClient) -> Arc<Mutex<u32>> {
-        self.bank[area_client.local_client.id() as usize].clone()
-    }
-}
-
-
-#[derive(Clone, Debug)]
-pub struct ItemState {
-    character_inventory: Arc<RwLock<HashMap<CharacterEntityId, RwLock<InventoryState>>>>,
-    character_bank: Arc<RwLock<HashMap<CharacterEntityId, RwLock<BankState>>>>,
-    character_room: Arc<RwLock<HashMap<CharacterEntityId, RoomId>>>,
-    character_floor: Arc<RwLock<HashMap<CharacterEntityId, RwLock<LocalFloor>>>>,
-    room_floor: Arc<RwLock<HashMap<RoomId, RwLock<SharedFloor>>>>,
-    room_gem_item_ids: Arc<RwLock<HashMap<RoomId, RoomGemItemIdCounter>>>,
-
-    room_item_id_counter: Arc<RwLock<u32>>,
-}
-
-impl Default for ItemState {
-    fn default() -> ItemState {
-        ItemState {
-            character_inventory: Arc::new(RwLock::new(HashMap::new())),
-            character_bank: Arc::new(RwLock::new(HashMap::new())),
-            character_room: Arc::new(RwLock::new(HashMap::new())),
-            character_floor: Arc::new(RwLock::new(HashMap::new())),
-            room_floor: Arc::new(RwLock::new(HashMap::new())),
-            room_gem_item_ids: Arc::new(RwLock::new(HashMap::new())),
-            room_item_id_counter: Arc::new(RwLock::new(0x00810000)),
-        }
-    }
-}
-
-impl ItemState {
-    pub async fn get_character_inventory(&self, character: &CharacterEntity) -> Result<InventoryState, anyhow::Error> {
-        Ok(self.character_inventory
-           .read()
-           .await
-           .get(&character.id)
-           .ok_or_else(|| ItemStateError::NoCharacter(character.id))?
-           .read()
-           .await
-           .clone())
-    }
-
-    pub async fn get_character_bank(&self, character: &CharacterEntity) -> Result<BankState, anyhow::Error> {
-        Ok(self.character_bank
-           .read()
-           .await
-           .get(&character.id)
-           .ok_or_else(|| ItemStateError::NoCharacter(character.id))?
-           .read()
-           .await
-           .clone())
-    }
-}
-
-impl ItemState {
-    async fn new_item_id(&mut self) -> Result<ClientItemId, anyhow::Error> {
-        *self.room_item_id_counter
-            .write()
-            .await += 1;
-        Ok(ClientItemId(*self.room_item_id_counter.read().await))
-    }
-
-    pub async fn load_character_inventory<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) -> Result<(), anyhow::Error> {
-        let inventory = entity_gateway.get_character_inventory(&character.id).await?;
-        let equipped = entity_gateway.get_character_equips(&character.id).await?;
-
-        let inventory_items = inventory.items.into_iter()
-            .map(|item| -> Result<InventoryItem, anyhow::Error> {
-                Ok(match item {
-                    InventoryItemEntity::Individual(item) => {
-                        InventoryItem {
-                            item_id: ClientItemId(0),
-                            item: InventoryItemDetail::Individual(IndividualItemDetail {
-                                entity_id: item.id,
-                                item: item.item,
-                            }),
-                        }
-                    },
-                    InventoryItemEntity::Stacked(items) => {
-                        InventoryItem {
-                            item_id: ClientItemId(0),
-                            item: InventoryItemDetail::Stacked(StackedItemDetail {
-                                entity_ids: items.iter().map(|i| i.id).collect(),
-                                tool: items.get(0)
-                                    .ok_or_else(|| ItemStateError::StackedItemError(items.clone()))?
-                                    .item
-                                    .clone()
-                                    .as_tool()
-                                    .ok_or_else(|| ItemStateError::StackedItemError(items.clone()))?
-                            })
-                        }
-                    },
-                })
-            })
-            .collect::<Result<Vec<_>, anyhow::Error>>()?;
-
-        let character_meseta = entity_gateway.get_character_meseta(&character.id).await?;
-        let inventory_state = InventoryState {
-            character_id: character.id,
-            item_id_counter: Arc::new(Mutex::new(0)),
-            inventory: Inventory::new(inventory_items),
-            equipped,
-            meseta: character_meseta,
-        };
-
-        self.character_inventory
-            .write()
-            .await
-            .insert(character.id, RwLock::new(inventory_state));
-        Ok(())
-    }
-
-    pub async fn load_character_bank<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, bank_identifier: BankIdentifier) -> Result<(), anyhow::Error> {
-        let bank = entity_gateway.get_character_bank(&character.id, &bank_identifier).await?;
-        let bank_items = bank.items
-            .into_iter()
-            .map(|item| {
-                Ok(Reverse(match item {
-                    BankItemEntity::Individual(item) => {
-                        BankItemDetail::Individual(IndividualItemDetail {
-                            entity_id: item.id,
-                            item: item.item,
-                        })
-                    },
-                    BankItemEntity::Stacked(items) => {
-                        BankItemDetail::Stacked(StackedItemDetail {
-                            entity_ids: items.iter().map(|i| i.id).collect(),
-                            tool: items.get(0)
-                                .ok_or_else(|| ItemStateError::StackedItemError(items.clone()))?
-                                .item
-                                .clone()
-                                .as_tool()
-                                .ok_or_else(|| ItemStateError::StackedItemError(items.clone()))?
-                        })
-                    }
-                }))
-            })
-            .collect::<Result<BinaryHeap<_>, anyhow::Error>>()?
-            .into_iter()
-            .map(|item| {
-                let mut citem_state = self.clone();
-                async move {
-                    Ok(BankItem {
-                        item_id: citem_state.new_item_id().await?,
-                        item: item.0,
-                    })
-                }
-            })
-            .collect::<FuturesOrdered<_>>()
-            .collect::<Vec<_>>()
-            .await
-            .into_iter()
-            .collect::<Result<Vec<_>, anyhow::Error>>()?;
-
-        let bank_meseta = entity_gateway.get_bank_meseta(&character.id, &bank_identifier).await?;
-        let bank_state = BankState::new(character.id, bank_identifier, Bank::new(bank_items), bank_meseta);
-
-        self.character_bank
-            .write()
-            .await
-            .insert(character.id, RwLock::new(bank_state));
-        Ok(())
-    }
-
-    pub async fn load_character<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) -> Result<(), anyhow::Error> {
-        self.load_character_inventory(entity_gateway, character).await?;
-        self.load_character_bank(entity_gateway, character, BankIdentifier::Character).await?;
-
-        Ok(())
-    }
-
-    pub async fn add_character_to_room(&mut self, room_id: RoomId, character: &CharacterEntity, area_client: AreaClient) {
-        let mut base_item_ids = self.room_gem_item_ids
-            .write()
-            .await;
-        let base_item_ids = base_item_ids
-            .entry(room_id)
-            .or_insert_with(RoomGemItemIdCounter::default);
-
-        self.character_inventory
-            .read()
-            .await
-            .get(&character.id)
-            .unwrap()
-            .write()
-            .await
-            .initialize_item_ids(base_item_ids.inventory(&area_client).clone())
-            .await;
-        self.character_bank
-            .read()
-            .await
-            .get(&character.id)
-            .unwrap()
-            .write()
-            .await
-            .initialize_item_ids(base_item_ids.bank(&area_client))
-            .await;
-        self.character_room
-            .write()
-            .await
-            .insert(character.id, room_id);
-        self.character_floor
-            .write()
-            .await
-            .insert(character.id, RwLock::new(LocalFloor::default()));
-        self.room_floor
-            .write()
-            .await
-            .entry(room_id)
-            .or_insert_with(Default::default);
-    }
-
-    pub async fn remove_character_from_room(&mut self, character: &CharacterEntity) {
-        self.character_inventory
-            .write()
-            .await
-            .remove(&character.id);
-        self.character_floor
-            .write()
-            .await
-            .remove(&character.id);
-
-        let removed = {
-            self.character_room.write().await.remove(&character.id)
-        };
-
-        if let Some(room) = removed.as_ref() {
-            // TODO: this looks wrong, .all(r != room) maybe?
-            if self.character_room.read().await.iter().any(|(_, r)| r == room) {
-                self.room_floor
-                    .write()
-                    .await
-                    .remove(room);
-            }
-        }
-    }
-
-    pub async fn get_floor_item(&self, character_id: &CharacterEntityId, item_id: &ClientItemId) -> Result<(FloorItem, FloorType), anyhow::Error> {
-        let local_floors = self.character_floor
-            .read()
-            .await;
-        let local_floor = local_floors
-            .get(character_id)
-            .ok_or_else(|| ItemStateError::NoCharacter(*character_id))?
-            .read()
-            .await;
-        let rooms = self.character_room
-            .read()
-            .await;
-        let room = rooms
-            .get(character_id)
-            .ok_or_else(||ItemStateError::NoCharacter(*character_id))?;
-        let shared_floors = self.room_floor
-            .read()
-            .await;
-        let shared_floor = shared_floors
-            .get(room)
-            .ok_or_else(||ItemStateError::NoCharacter(*character_id))?
-            .read()
-            .await;
-
-        local_floor.0
-            .iter()
-            .find(|item| item.item_id == *item_id)
-            .map(|item| (item.clone(), FloorType::Local))
-            .or_else(|| {
-                shared_floor.0
-                    .iter()
-                    .find(|item| item.item_id == *item_id)
-                    .map(|item| (item.clone(), FloorType::Shared))
-            })
-            .ok_or_else(|| ItemStateError::NoFloorItem(*item_id))
-            .with_context(|| format!("character {character_id}\nlocal floors: {local_floors:#?}\nshared floors: {shared_floors:#?}"))
-    }
-}
-
-
-#[derive(Default, Clone)]
-struct ProxiedItemState {
-    character_inventory: Arc<Mutex<HashMap<CharacterEntityId, InventoryState>>>,
-    character_bank: Arc<Mutex<HashMap<CharacterEntityId, BankState>>>,
-
-    //character_room: HashMap<CharacterEntityId, RoomId>,
-    character_floor: Arc<Mutex<HashMap<CharacterEntityId, LocalFloor>>>,
-    room_floor: Arc<Mutex<HashMap<RoomId, SharedFloor>>>,
-}
-
-#[derive(Clone)]
-pub struct ItemStateProxy {
-    item_state: ItemState,
-    proxied_state: ProxiedItemState,
-}
-
-impl ItemStateProxy {
-    pub async fn commit(self) {
-        async fn copy_back<K, V>(master: &Arc<RwLock<HashMap<K, RwLock<V>>>>,
-                                 proxy: Arc<Mutex<HashMap<K, V>>>)
-        where
-            K: Eq + std::hash::Hash,
-            V: Clone,
-        {
-            for (key, value) in proxy.lock().await.iter() {
-                if let Some(element) = master
-                    .read()
-                    .await
-                    .get(key) {
-                        *element
-                            .write()
-                            .await = value.clone();
-                    }
-            }
-        }
-
-        copy_back(&self.item_state.character_inventory, self.proxied_state.character_inventory).await;
-        copy_back(&self.item_state.character_bank, self.proxied_state.character_bank).await;
-        //copy_back(self.item_state.character_room, self.proxied_state.character_room).await;
-        copy_back(&self.item_state.character_floor, self.proxied_state.character_floor).await;
-        copy_back(&self.item_state.room_floor, self.proxied_state.room_floor).await;
-    }
-}
-
-
-async fn get_or_clone<K, V>(master: &Arc<RwLock<HashMap<K, RwLock<V>>>>,
-                            proxy: &Arc<Mutex<HashMap<K, V>>>,
-                            key: K,
-                            err: fn(K) -> ItemStateError) -> Result<V, anyhow::Error>
-where
-    K: Eq + std::hash::Hash + Copy,
-    V: Clone
-{
-    let existing_element = master
-        .read()
-        .await
-        .get(&key)
-        .ok_or_else(|| err(key))?
-        .read()
-        .await
-        .clone();
-    Ok(proxy
-       .lock()
-       .await
-       .entry(key)
-       .or_insert_with(|| existing_element)
-       .clone())
-
-}
-
-impl ItemStateProxy {
-    pub fn new(item_state: ItemState) -> Self {
-        ItemStateProxy {
-            item_state,
-            proxied_state: Default::default(),
-        }
-    }
-
-    pub async fn inventory(&mut self, character_id: &CharacterEntityId) -> Result<InventoryState, anyhow::Error> {
-        get_or_clone(&self.item_state.character_inventory,
-                     &self.proxied_state.character_inventory,
-                     *character_id,
-                     ItemStateError::NoCharacter).await
-    }
-
-    pub async fn set_inventory(&mut self, inventory: InventoryState) {
-        self.proxied_state.character_inventory.lock().await.insert(inventory.character_id, inventory);
-    }
-
-    pub async fn bank(&mut self, character_id: &CharacterEntityId) -> Result<BankState, anyhow::Error> {
-        get_or_clone(&self.item_state.character_bank,
-                     &self.proxied_state.character_bank,
-                     *character_id,
-                     ItemStateError::NoCharacter).await
-    }
-
-    pub async fn set_bank(&mut self, bank: BankState) {
-        self.proxied_state.character_bank.lock().await.insert(bank.character_id, bank);
-    }
-
-    pub async fn floor(&mut self, character_id: &CharacterEntityId) -> Result<FloorState, anyhow::Error> {
-        let room_id = *self.item_state.character_room.read().await.get(character_id)
-            .ok_or_else(|| anyhow::Error::from(ItemStateError::NoCharacter(*character_id)))
-            .with_context(|| format!("character {character_id}\nrooms: {:#?}", self.item_state.character_room))?;
-        Ok(FloorState {
-            character_id: *character_id,
-            local: get_or_clone(&self.item_state.character_floor, &self.proxied_state.character_floor, *character_id, ItemStateError::NoCharacter).await
-                .with_context(|| format!("no local_floor state: {character_id:?} {:#?}\nproxy: {:#?}", self.item_state.character_floor, self.proxied_state.character_floor))?,
-            shared: get_or_clone(&self.item_state.room_floor, &self.proxied_state.room_floor, room_id, ItemStateError::NoRoom).await
-                .with_context(|| format!("no share_floor state: {character_id:?} {:#?}\nproxy: {:#?}", self.item_state.room_floor, self.proxied_state.room_floor))?,
-        })
-    }
-
-    pub async fn set_floor(&mut self, floor: FloorState) {
-        let room_id = *self.item_state.character_room.read().await.get(&floor.character_id)
-            .ok_or_else(|| anyhow::Error::from(ItemStateError::NoCharacter(floor.character_id)))
-            .with_context(|| format!("character {}\nrooms: {:#?}", floor.character_id, self.item_state.character_room)).unwrap();
-        self.proxied_state.character_floor.lock().await.insert(floor.character_id, floor.local);
-        self.proxied_state.room_floor.lock().await.insert(room_id, floor.shared);
-    }
-
-    pub async fn new_item_id(&mut self) -> Result<ClientItemId, anyhow::Error> {
-        self.item_state.new_item_id().await
-    }
-}

src/items/src/tasks.rs

@@ -1,564 +0,0 @@
-use futures::future::BoxFuture;
-use crate::ClientItemId;
-use entity::item::Meseta;
-
-use maps::area::MapArea;
-use entity::character::{CharacterEntity, CharacterEntityId};
-use entity::gateway::{EntityGateway, EntityGatewayTransaction};
-use entity::item::ItemModifier;
-use entity::room::RoomEntityId;
-use crate::state::{ItemState, ItemStateProxy, IndividualItemDetail};
-use crate::itemstateaction::{ItemStateAction, ItemAction};
-use crate::inventory::InventoryItem;
-use crate::floor::FloorItem;
-use shops::ShopItem;
-use crate::trade::TradeItem;
-use location::AreaClient;
-use drops::ItemDrop;
-use maps::monster::MonsterType;
-
-use crate::actions;
-
-pub fn pick_up_item<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-) -> BoxFuture<'a, Result<actions::TriggerCreateItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-    EG::Transaction<'a>: Clone,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_floor(character.id, *item_id))
-            .act(actions::add_floor_item_to_inventory(character))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-pub fn drop_item<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    map_area: MapArea,
-    drop_position: (f32, f32, f32),
-)-> BoxFuture<'a, Result<FloorItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-    EG::Transaction<'a>: Clone,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, *item_id, 0))
-            .act(actions::add_inventory_item_to_shared_floor(character.id, map_area, drop_position))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-pub fn drop_partial_item<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    map_area: MapArea,
-    drop_position: (f32, f32),
-    amount: u32
-) -> BoxFuture<'a, Result<FloorItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, *item_id, amount))
-            .act(actions::add_inventory_item_to_shared_floor(character.id, map_area, (drop_position.0, 0.0, drop_position.1)))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-
-pub fn drop_meseta<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    map_area: MapArea,
-    drop_position: (f32, f32),
-    amount: u32,
-) -> BoxFuture<'a, Result<FloorItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_meseta_from_inventory(character.id, amount))
-            .act(actions::add_meseta_to_shared_floor(character.id, amount, map_area, drop_position))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn withdraw_meseta<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    amount: u32,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_meseta_from_bank(character.id, amount))
-            .act(actions::add_meseta_from_bank_to_inventory(character.id, amount))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn deposit_meseta<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    amount: u32,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), _) = ItemStateAction::default()
-            .act(actions::take_meseta_from_inventory(character.id, amount))
-            .act(actions::add_meseta_to_bank(character.id, amount))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, ()))
-    })
-}
-
-
-pub fn withdraw_item<'a, EG>(
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    amount: u32,
-) -> BoxFuture<'a, Result<InventoryItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_bank(character.id, *item_id, amount))
-            //.act(bank_item_to_inventory_item)
-            //.act(add_item_to_inventory)
-            .act(actions::add_bank_item_to_inventory(character))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn deposit_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    amount: u32,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, *item_id, amount))
-            .act(actions::add_inventory_item_to_bank(character.id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-pub fn equip_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    equip_slot: u8,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::equip_inventory_item(character.id, *item_id, equip_slot))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn unequip_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::unequip_inventory_item(character.id, *item_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn sort_inventory<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_ids: Vec<ClientItemId>,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::sort_inventory_items(character.id, item_ids))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn use_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a mut CharacterEntity,
-    area_client: AreaClient,
-    item_id: &'a ClientItemId,
-    amount: u32,
-) -> BoxFuture<'a, Result<Vec<actions::CreateItem>, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), (pkts, new_character)) = ItemStateAction::default()
-            .act(actions::remove_item_from_inventory(character.id, *item_id, amount))
-            .act(actions::use_consumed_item(character))
-            .act(actions::fork(
-                actions::foreach(actions::apply_item_action_packets(character.id, area_client)),
-                actions::apply_item_action_character(character)
-            ))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-
-        *character = new_character;
-        Ok((transaction, pkts.into_iter().flatten().collect()))
-    })
-}
-
-
-pub fn feed_mag<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    mag_item_id: &'a ClientItemId,
-    tool_item_id: &'a ClientItemId,
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), _) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, *tool_item_id, 1))
-            .act(actions::feed_mag_item(character.clone(), *mag_item_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, ()))
-    })
-}
-
-
-pub fn buy_shop_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    shop_item: &'a (dyn ShopItem + Send + Sync),
-    item_id: ClientItemId,
-    amount: u32,
-) -> BoxFuture<'a, Result<InventoryItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    let item_price = shop_item.price() as u32 * amount;
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_meseta_from_inventory(character.id, item_price))
-            //.act(bought_item_to_inventory_item)
-            //.act(add_item_to_inventory)
-            .act(actions::add_bought_item_to_inventory(character.id, shop_item, item_id, amount))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-
-pub fn sell_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: ClientItemId,
-    amount: u32,
-) -> BoxFuture<'a, Result<InventoryItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, item_id, amount))
-            .act(actions::sell_inventory_item(character.id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}
-
-#[allow(clippy::type_complexity)]
-pub fn trade_items<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    p1: (&'a AreaClient, &'a CharacterEntity, &'a Vec<TradeItem>, Meseta),
-    p2: (&'a AreaClient, &'a CharacterEntity, &'a Vec<TradeItem>, Meseta))
-    -> BoxFuture<'a, Result<(Vec<InventoryItem>, Vec<InventoryItem>), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    let p1_trade_items = p1.2
-        .iter()
-        .map(|item| {
-            match item {
-                TradeItem::Individual(item_id) => (*item_id, 1),
-                TradeItem::Stacked(item_id, amount) => (*item_id, *amount as u32),
-            }
-        })
-        .collect();
-    let p2_trade_items = p2.2
-        .iter()
-        .map(|item| {
-            match item {
-                TradeItem::Individual(item_id) => (*item_id, 1),
-                TradeItem::Stacked(item_id, amount) => (*item_id, *amount as u32),
-            }
-        })
-        .collect();
-    entity_gateway.with_transaction(move |mut transaction| async move {
-        let p1_id = p1.1.id;
-        let p2_id = p2.1.id;
-        let trade = transaction.gateway().create_trade(&p1_id, &p2_id).await?;
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), p1_removed_items) = ItemStateAction::default()
-            .act(actions::iterate(p1_trade_items, move |p1_trade_item| actions::take_item_from_inventory(p1_id, p1_trade_item.0, p1_trade_item.1) ))
-            .act(actions::foreach(actions::assign_new_item_id()))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        let ((item_state_proxy, transaction), p2_removed_items) = ItemStateAction::default()
-            .act(actions::iterate(p2_trade_items, move |p2_trade_item| actions::take_item_from_inventory(p2_id, p2_trade_item.0, p2_trade_item.1) ))
-            .act(actions::foreach(actions::assign_new_item_id()))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-        let ((item_state_proxy, transaction), p2_new_items) = ItemStateAction::default()
-            .act(actions::insert(p1_removed_items))
-            .act(actions::foreach(actions::add_item_to_inventory(p2.1.clone())))
-            .act(actions::record_trade(trade.id, p1_id, p2_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-        let ((item_state_proxy, transaction), p1_new_items) = ItemStateAction::default()
-            .act(actions::insert(p2_removed_items))
-            .act(actions::foreach(actions::add_item_to_inventory(p1.1.clone())))
-            .act(actions::record_trade(trade.id, p2_id, p1_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-        let ((item_state_proxy, transaction), _) = ItemStateAction::default()
-            .act(actions::take_meseta_from_inventory(p1_id, p1.3.0))
-            .act(actions::take_meseta_from_inventory(p2_id, p2.3.0))
-            .act(actions::add_meseta_to_inventory(p1_id, p2.3.0))
-            .act(actions::add_meseta_to_inventory(p2_id, p1.3.0))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-            item_state_proxy.commit().await;
-        Ok((transaction, (p1_new_items, p2_new_items)))
-    })
-}
-
-
-pub fn take_meseta<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character_id: &'a CharacterEntityId,
-    meseta: Meseta)
-    -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), _) = ItemStateAction::default()
-            .act(actions::take_meseta_from_inventory(*character_id, meseta.0))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-            item_state_proxy.commit().await;
-        Ok((transaction, ()))
-    })
-}
-
-pub fn enemy_drops_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character_id: CharacterEntityId,
-    room_id: RoomEntityId,
-    monster_type: MonsterType,
-    item_drop: ItemDrop)
-    -> BoxFuture<'a, Result<FloorItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), floor_item) = ItemStateAction::default()
-            .act(actions::convert_item_drop_to_floor_item(item_drop))
-            .act(actions::item_note_enemy_drop(character_id, room_id, monster_type))
-            .act(actions::add_item_to_local_floor(character_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-            item_state_proxy.commit().await;
-        Ok((transaction, floor_item))
-    })
-}
-
-pub fn box_drops_item<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character_id: CharacterEntityId,
-    room_id: RoomEntityId,
-    item_drop: ItemDrop)
-    -> BoxFuture<'a, Result<FloorItem, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), floor_item) = ItemStateAction::default()
-            .act(actions::convert_item_drop_to_floor_item(item_drop))
-            .act(actions::item_note_box_drop(character_id, room_id))
-            .act(actions::add_item_to_local_floor(character_id))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-            item_state_proxy.commit().await;
-        Ok((transaction, floor_item))
-    })
-}
-
-
-pub fn apply_modifier<'a, EG> (
-    item_state: &'a mut ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: ClientItemId,
-    modifier: ItemModifier)
-    -> BoxFuture<'a, Result<IndividualItemDetail, anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let ((item_state_proxy, transaction), item) = ItemStateAction::default()
-            .act(actions::take_item_from_inventory(character.id, item_id, 1))
-            .act(actions::apply_modifier_to_inventory_item(modifier))
-            .act(actions::add_item_to_inventory(character.clone()))
-            .act(actions::as_individual_item())
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-            item_state_proxy.commit().await;
-        Ok((transaction, item))
-    })
-}
-
-pub fn floor_item_limit_reached<'a, EG> (
-    item_state: &'a ItemState,
-    entity_gateway: &'a mut EG,
-    character: &'a CharacterEntity,
-    item_id: &'a ClientItemId,
-    map_area: MapArea
-) -> BoxFuture<'a, Result<(), anyhow::Error>>
-where
-    EG: EntityGateway + 'static,
-    EG::Transaction<'a>: Clone,
-{
-    entity_gateway.with_transaction(move |transaction| async move {
-        let item_state_proxy = ItemStateProxy::new(item_state.clone());
-        let((item_state_proxy, transaction), result) = ItemStateAction::default()
-            .act(actions::take_item_from_floor(character.id, *item_id))
-            .act(actions::delete_item_from_floor(map_area))
-            .commit((item_state_proxy, transaction))
-            .await?;
-
-        item_state_proxy.commit().await;
-        Ok((transaction, result))
-    })
-}

src/items/src/trade.rs

@@ -1,38 +0,0 @@
-use crate::ClientItemId;
-
-#[derive(Debug, Clone)]
-pub enum TradeItem {
-    Individual(ClientItemId),
-    Stacked(ClientItemId, usize),
-}
-
-impl TradeItem {
-    pub fn stacked(&self) -> Option<(ClientItemId, usize)> {
-        match self {
-            TradeItem::Stacked(item_id, amount) => Some((*item_id, *amount)),
-            _ => None
-        }
-    }
-
-    pub fn stacked_mut(&mut self) -> Option<(ClientItemId, &mut usize)> {
-        match self {
-            TradeItem::Stacked(item_id, ref mut amount) => Some((*item_id, amount)),
-            _ => None
-        }
-    }
-
-    pub fn item_id(&self) -> ClientItemId  {
-        match self {
-            TradeItem::Individual(item_id) => *item_id,
-            TradeItem::Stacked(item_id, _) => *item_id,
-        }
-    }
-
-    pub fn amount(&self) -> usize {
-        match self {
-            TradeItem::Individual(_) => 1,
-            TradeItem::Stacked(_, amount) => *amount,
-        }
-    }
-}
-

src/lib.rs

@@ -0,0 +1,12 @@
+#![allow(incomplete_features)]
+#![feature(inline_const)]
+#![feature(drain_filter)]
+#![feature(try_blocks)]
+
+
+
+pub mod common;
+pub mod entity;
+pub mod patch;
+pub mod login;
+pub mod ship;

src/location/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "location"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-networking = { workspace = true }
-
-async-std = { workspace = true }
-derive_more = { workspace = true }
-futures= { workspace = true }
-thiserror = { workspace = true }

src/location/src/lib.rs

@@ -1,676 +0,0 @@
-#![allow(dead_code, unused_must_use)]
-use std::collections::HashMap;
-use std::time::SystemTime;
-use thiserror::Error;
-use networking::serverstate::ClientId;
-
-use async_std::sync::{Arc, RwLock};
-use futures::{stream, StreamExt};
-use std::pin::pin;
-
-pub const MAX_ROOMS: usize = 128;
-
-pub enum AreaType {
-    Room,
-    Lobby,
-}
-
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct LobbyId(pub usize);
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, derive_more::Display)]
-pub struct RoomId(pub usize);
-
-impl LobbyId {
-    pub fn id(&self) -> u8 {
-        self.0 as u8
-    }
-}
-
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum CreateRoomError {
-    #[error("no open slots")]
-    NoOpenSlots,
-    #[error("client already in area")]
-    ClientInAreaAlready,
-    #[error("join error")]
-    JoinError,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum JoinRoomError {
-    #[error("room does not exist")]
-    RoomDoesNotExist,
-    #[error("room is full")]
-    RoomFull,
-    #[error("client already in area")]
-    ClientInAreaAlready,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum JoinLobbyError {
-    #[error("lobby does not exist")]
-    LobbyDoesNotExist,
-    #[error("lobby is full")]
-    LobbyFull,
-    #[error("client already in area")]
-    ClientInAreaAlready,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum GetAreaError {
-    #[error("not in a room")]
-    NotInRoom,
-    #[error("not in a lobby")]
-    NotInLobby,
-    #[error("get area: invalid client")]
-    InvalidClient,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum ClientRemovalError {
-    #[error("client removal: client not in area")]
-    ClientNotInArea,
-    #[error("client removal: invalid area")]
-    InvalidArea,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum GetClientsError {
-    #[error("invalid client")]
-    InvalidClient,
-    #[error("invalid area")]
-    InvalidArea,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum GetNeighborError {
-    #[error("get neighbor: invalid client")]
-    InvalidClient,
-    #[error("get neighbor: invalid area")]
-    InvalidArea,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum GetLeaderError {
-    #[error("get leader: invalid client")]
-    InvalidClient,
-    #[error("get leader: invalid area")]
-    InvalidArea,
-    #[error("get leader: client not in area")]
-    NoClientInArea,
-}
-
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum ClientLocationError {
-    #[error("create room error {0}")]
-    CreateRoomError(#[from] CreateRoomError),
-    #[error("join room error {0}")]
-    JoinRoomError(#[from] JoinRoomError),
-    #[error("join lobby error {0}")]
-    JoinLobbyError(#[from] JoinLobbyError),
-    #[error("get area error {0}")]
-    GetAreaError(#[from] GetAreaError),
-    #[error("client removal error {0}")]
-    ClientRemovalError(#[from] ClientRemovalError),
-    #[error("get clients error {0}")]
-    GetClientsError(#[from] GetClientsError),
-    #[error("get neighbor error {0}")]
-    GetNeighborError(#[from] GetNeighborError),
-    #[error("get leader error {0}")]
-    GetLeaderError(#[from] GetLeaderError)
-}
-
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct LocalClientId(usize);
-
-impl LocalClientId {
-    pub fn id(&self) -> u8 {
-        self.0 as u8
-    }
-}
-
-impl PartialEq<u8> for LocalClientId {
-    fn eq(&self, other: &u8) -> bool {
-        self.0 == *other as usize
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct AreaClient {
-    pub client: ClientId,
-    pub local_client: LocalClientId,
-    time_join: SystemTime,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct Lobby([Option<AreaClient>; 12]);
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-struct Room([Option<AreaClient>; 4]);
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum RoomLobby {
-    Room(RoomId),
-    Lobby(LobbyId),
-}
-
-#[derive(Clone, Debug)]
-pub struct ClientLocation {
-    lobbies: [Arc<RwLock<Lobby>>; 15],
-    rooms: [Arc<RwLock<Option<Room>>>; MAX_ROOMS],
-    client_location: Arc<RwLock<HashMap<ClientId, RoomLobby>>>,
-}
-
-impl Default for ClientLocation {
-    fn default() -> ClientLocation {
-        ClientLocation {
-            lobbies: core::array::from_fn(|_| Arc::new(RwLock::new(Lobby([None; 12])))),
-            rooms: core::array::from_fn(|_| Arc::new(RwLock::new(None))),
-            client_location: Arc::new(RwLock::new(HashMap::new())),
-        }
-    }
-}
-
-
-impl ClientLocation {
-    pub async fn add_client_to_lobby(&self, id: ClientId, lobby_id: LobbyId) -> Result<(), JoinLobbyError> {
-        {
-            let lobby = self.lobbies
-                .get(lobby_id.0)
-                .ok_or(JoinLobbyError::LobbyDoesNotExist)?
-                .read()
-                .await;
-            if lobby.0.iter().all(|c| c.is_some()) {
-                return Err(JoinLobbyError::LobbyFull);
-            }
-        }
-        self.remove_client_from_area(id).await;
-
-        let mut lobby = self.lobbies
-            .get(lobby_id.0)
-            .ok_or(JoinLobbyError::LobbyDoesNotExist)?
-            .write()
-            .await;
-        let (index, empty_slot) = lobby.0.iter_mut()
-            .enumerate()
-            .find(|(_, k)| k.is_none())
-            .ok_or(JoinLobbyError::LobbyFull)?;
-        *empty_slot = Some(AreaClient {
-            client: id,
-            local_client: LocalClientId(index),
-            time_join: SystemTime::now(),
-        });
-        self.client_location
-            .write()
-            .await
-            .insert(id, RoomLobby::Lobby(lobby_id));
-        Ok(())
-    }
-
-    pub async fn add_client_to_next_available_lobby(&self, id: ClientId, lobby: LobbyId) -> Result<LobbyId, JoinLobbyError> {
-        pin!(stream::iter(0..15)
-            .filter_map(|lobby_index| async move {
-                let new_lobby = LobbyId((lobby.0 + lobby_index) % 15);
-                Some((new_lobby, self.add_client_to_lobby(id, new_lobby).await.ok()?))
-            }))
-            .next()
-            .await
-            .map(|l| l.0)
-            .ok_or(JoinLobbyError::LobbyFull)
-    }
-
-    pub async fn create_new_room(&mut self, id: ClientId) -> Result<RoomId, CreateRoomError> {
-        let (index, empty_slot) = Box::pin(stream::iter(self.rooms.iter())
-            .enumerate()
-            .filter(|(_, r)| async {r.read().await.is_none()}))
-            .next()
-            .await
-            .ok_or(CreateRoomError::NoOpenSlots)?;
-        *empty_slot.write().await = Some(Room([None; 4]));
-        self.add_client_to_room(id, RoomId(index))
-            .await
-            .map_err(|_err| CreateRoomError::JoinError)?;
-        Ok(RoomId(index))
-    }
-
-    pub async fn add_client_to_room(&mut self, id: ClientId, room: RoomId) -> Result<(), JoinRoomError> {
-        let mut r = self.rooms.get(room.0)
-            .ok_or(JoinRoomError::RoomDoesNotExist)?
-            .as_ref()
-            .write()
-            .await;
-        let r = r.as_mut()
-            .ok_or(JoinRoomError::RoomDoesNotExist)?;
-        let (index, empty_slot) = r.0.iter_mut()
-            .enumerate()
-            .find(|(_, k)| k.is_none())
-            .ok_or(JoinRoomError::RoomFull)?;
-        *empty_slot = Some(AreaClient {
-            client: id,
-            local_client: LocalClientId(index),
-            time_join: SystemTime::now(),
-        });
-        self.remove_client_from_area(id).await;
-        self.client_location
-            .write()
-            .await
-            .insert(id, RoomLobby::Room(room));
-        Ok(())
-    }
-
-    pub async fn get_all_clients_by_client(&self, id: ClientId) -> Result<Vec<AreaClient>, GetNeighborError> {
-        let area = self.client_location
-            .read()
-            .await;
-        let area = area
-            .get(&id)
-            .ok_or(GetNeighborError::InvalidClient)?;
-        match area {
-            RoomLobby::Room(room) => {
-                Ok(self.get_clients_in_room(*room).await.map_err(|_| GetNeighborError::InvalidArea)?
-                   .into_iter()
-                   .collect())
-            },
-            RoomLobby::Lobby(lobby) => {
-                Ok(self.get_clients_in_lobby(*lobby).await.map_err(|_| GetNeighborError::InvalidArea)?
-                   .into_iter()
-                   .collect())
-            }
-        }
-    }
-
-    pub async fn get_client_neighbors(&self, id: ClientId) -> Result<Vec<AreaClient>, GetNeighborError> {
-        let area = self.client_location
-            .read()
-            .await;
-        let area = area
-            .get(&id)
-            .ok_or(GetNeighborError::InvalidClient)?;
-        match area {
-            RoomLobby::Room(room) => {
-                Ok(self.get_clients_in_room(*room).await.map_err(|_| GetNeighborError::InvalidArea)?
-                   .into_iter()
-                   .filter(|c| c.client != id)
-                   .collect())
-            },
-            RoomLobby::Lobby(lobby) => {
-                Ok(self.get_clients_in_lobby(*lobby).await.map_err(|_| GetNeighborError::InvalidArea)?
-                   .into_iter()
-                   .filter(|c| c.client != id)
-                   .collect())
-            }
-        }
-    }
-
-    pub async fn get_room_leader(&self, room: RoomId) -> Result<AreaClient, GetLeaderError> {
-        let r = self.rooms[room.0]
-            .as_ref()
-            .read()
-            .await
-            .ok_or(GetLeaderError::InvalidArea)?;
-        let mut r = r
-            .0
-            .iter()
-            .flatten()
-            .collect::<Vec<_>>();
-        r.sort_by_key(|k| k.time_join);
-        let c = r.get(0)
-            .ok_or(GetLeaderError::NoClientInArea)?;
-        Ok(**c)
-    }
-
-    pub async fn get_lobby_leader(&self, lobby: LobbyId) -> Result<AreaClient, GetLeaderError> {
-        let l = self.lobbies[lobby.0]
-            .read()
-            .await;
-        let mut l = l
-            .0
-            .iter()
-            .flatten()
-            .collect::<Vec<_>>();
-        l.sort_by_key(|k| k.time_join);
-        let c = l.get(0).ok_or(GetLeaderError::NoClientInArea)?;
-        Ok(**c)
-    }
-
-    pub async fn get_area_leader(&self, roomlobby: RoomLobby) -> Result<AreaClient, GetLeaderError> {
-        match roomlobby {
-            RoomLobby::Room(room) => {
-                self.get_room_leader(room).await
-            },
-            RoomLobby::Lobby(lobby) => {
-                self.get_lobby_leader(lobby).await
-            }
-        }
-    }
-
-    pub async fn get_leader_by_client(&self, id: ClientId) -> Result<AreaClient, GetLeaderError> {
-        let area = self.client_location
-            .read()
-            .await;
-        let area = area
-            .get(&id)
-            .ok_or(GetLeaderError::InvalidClient)?;
-        match area {
-            RoomLobby::Room(room) => {
-                self.get_room_leader(*room).await
-            },
-            RoomLobby::Lobby(lobby) => {
-                self.get_lobby_leader(*lobby).await
-            }
-        }
-    }
-
-    pub async fn get_clients_in_lobby(&self, lobby: LobbyId) -> Result<Vec<AreaClient>, GetClientsError> {
-        Ok(self.lobbies
-           .get(lobby.0)
-           .ok_or(GetClientsError::InvalidArea)?
-           .read()
-           .await
-           .0
-           .iter()
-           .filter_map(|client| {
-               client.map(|c| {
-                   c
-               })
-           }).collect())
-    }
-
-    pub async fn get_clients_in_room(&self, room: RoomId) -> Result<Vec<AreaClient>, GetClientsError> {
-        Ok(self.rooms.get(room.0)
-           .ok_or(GetClientsError::InvalidArea)?
-           .as_ref()
-           .read()
-           .await
-           .ok_or(GetClientsError::InvalidArea)?
-           .0
-           .iter()
-           .filter_map(|client| {
-               client.map(|c| {
-                   c
-               })
-           }).collect())
-    }
-
-    pub async fn get_local_client(&self, id: ClientId) -> Result<AreaClient, GetClientsError> {
-        let area = self.client_location
-            .read()
-            .await;
-        let area = area
-            .get(&id)
-            .ok_or(GetClientsError::InvalidClient)?;
-        match area {
-            RoomLobby::Room(room) => {
-                self.get_clients_in_room(*room)
-                    .await
-                    .map_err(|_| GetClientsError::InvalidArea)?
-                    .into_iter()
-                    .find(|c| c.client == id)
-                    .ok_or(GetClientsError::InvalidClient)
-            },
-            RoomLobby::Lobby(lobby) => {
-                self.get_clients_in_lobby(*lobby)
-                    .await
-                    .map_err(|_| GetClientsError::InvalidArea)?
-                    .into_iter()
-                    .find(|c| c.client == id)
-                    .ok_or(GetClientsError::InvalidClient)
-            }
-        }
-    }
-
-    pub async fn get_area(&self, id: ClientId) -> Result<RoomLobby, GetAreaError> {
-        self.client_location
-            .read()
-            .await
-            .get(&id)
-            .ok_or(GetAreaError::InvalidClient)
-            .map(Clone::clone)
-    }
-
-    pub async fn get_room(&self, id: ClientId) -> Result<RoomId, GetAreaError> {
-        if let RoomLobby::Room(room) = self.client_location.read().await.get(&id).ok_or(GetAreaError::InvalidClient)? {
-            Ok(*room)
-        }
-        else {
-            Err(GetAreaError::NotInRoom)
-        }
-    }
-
-    pub async fn get_lobby(&self, id: ClientId) -> Result<LobbyId, GetAreaError> {
-        if let RoomLobby::Lobby(lobby) = self.client_location.read().await.get(&id).ok_or(GetAreaError::InvalidClient)? {
-            Ok(*lobby)
-        }
-        else {
-            Err(GetAreaError::NotInLobby)
-        }
-    }
-
-    pub async fn remove_client_from_area(&self, id: ClientId) -> Result<(), ClientRemovalError> {
-        fn remove_client<const N: usize>(id: ClientId, client_list : &mut [Option<AreaClient>; N]) {
-            client_list
-                .iter_mut()
-                .filter(|client| {
-                    client.map_or(false, |c| {
-                        c.client == id
-                    })
-                })
-                .for_each(|client| {
-                    *client = None
-                });
-        }
-
-        let area = self.client_location
-            .read()
-            .await;
-        let area = area
-            .get(&id)
-            .ok_or(ClientRemovalError::ClientNotInArea)?;
-        match area {
-            RoomLobby::Room(room) => {
-                let mut r = self.rooms.get(room.0)
-                    .ok_or(ClientRemovalError::InvalidArea)?
-                    .as_ref()
-                    .write()
-                    .await;
-                if let Some(r) = r.as_mut() {
-                    remove_client(id, &mut r.0)
-                }
-                else {
-                    return Err(ClientRemovalError::InvalidArea)
-                }
-            },
-            RoomLobby::Lobby(lobby) => {
-                remove_client(id, &mut self.lobbies[lobby.0].write().await.0)
-            }
-        };
-
-        Ok(())
-    }
-}
-
-
-
-
-
-
-
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[async_std::test]
-    async fn test_add_client_to_lobby() {
-        let cl = ClientLocation::default();
-        cl.add_client_to_lobby(ClientId(12), LobbyId(0)).await.unwrap();
-        cl.add_client_to_lobby(ClientId(13), LobbyId(1)).await.unwrap();
-        cl.add_client_to_lobby(ClientId(14), LobbyId(0)).await.unwrap();
-
-        assert!(cl.get_clients_in_lobby(LobbyId(0)).await.into_iter().flatten().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(12), LocalClientId(0)),
-            (ClientId(14), LocalClientId(1)),
-        ]);
-    }
-
-    #[async_std::test]
-    async fn test_add_client_to_full_lobby() {
-        let cl = ClientLocation::default();
-        for i in 0..12 {
-            cl.add_client_to_lobby(ClientId(i), LobbyId(0)).await.unwrap();
-        }
-        assert!(cl.add_client_to_lobby(ClientId(99), LobbyId(0)).await == Err(JoinLobbyError::LobbyFull));
-    }
-
-    #[async_std::test]
-    async fn test_add_client_to_next_available_lobby() {
-        let cl = ClientLocation::default();
-        for lobby in 1..4 {
-            for i in 0..12 {
-                cl.add_client_to_lobby(ClientId(lobby*12+i), LobbyId(lobby)).await.unwrap();
-            }
-        }
-        assert!(cl.add_client_to_next_available_lobby(ClientId(99), LobbyId(1)).await == Ok(LobbyId(4)));
-    }
-
-    #[async_std::test]
-    async fn test_add_to_lobby_when_all_are_full() {
-        let cl = ClientLocation::default();
-        for lobby in 0..15 {
-            for i in 0..12 {
-                cl.add_client_to_lobby(ClientId(lobby*12+i), LobbyId(lobby)).await.unwrap();
-            }
-        }
-        assert_eq!(cl.add_client_to_next_available_lobby(ClientId(99), LobbyId(1)).await, Err(JoinLobbyError::LobbyFull));
-    }
-
-    #[async_std::test]
-    async fn test_new_room() {
-        let mut cl = ClientLocation::default();
-        assert!(cl.create_new_room(ClientId(12)).await == Ok(RoomId(0)));
-    }
-
-    #[async_std::test]
-    async fn test_add_client_to_room() {
-        let mut cl = ClientLocation::default();
-        let room = cl.create_new_room(ClientId(12)).await.unwrap();
-        assert!(cl.add_client_to_room(ClientId(234), room).await == Ok(()));
-        assert!(cl.get_clients_in_room(room).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(12), LocalClientId(0)),
-            (ClientId(234), LocalClientId(1)),
-        ]);
-    }
-
-    #[async_std::test]
-    async fn test_no_new_room_slots() {
-        let mut cl = ClientLocation::default();
-        for i in 0..128 {
-            cl.create_new_room(ClientId(i)).await;
-        }
-        assert!(cl.create_new_room(ClientId(234)).await == Err(CreateRoomError::NoOpenSlots));
-    }
-
-    #[async_std::test]
-    async fn test_joining_full_room() {
-        let mut cl = ClientLocation::default();
-        let room = cl.create_new_room(ClientId(0)).await.unwrap();
-        assert!(cl.add_client_to_room(ClientId(1), room).await == Ok(()));
-        assert!(cl.add_client_to_room(ClientId(2), room).await == Ok(()));
-        assert!(cl.add_client_to_room(ClientId(3), room).await == Ok(()));
-        assert!(cl.add_client_to_room(ClientId(234), room).await == Err(JoinRoomError::RoomFull));
-    }
-
-    #[async_std::test]
-    async fn test_adding_client_to_room_removes_from_lobby() {
-        let mut cl = ClientLocation::default();
-        cl.add_client_to_lobby(ClientId(93), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(23), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(51), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(12), LobbyId(0)).await;
-
-        let room = cl.create_new_room(ClientId(51)).await.unwrap();
-        assert!(cl.add_client_to_room(ClientId(93), room).await == Ok(()));
-        assert!(cl.get_clients_in_lobby(LobbyId(0)).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(23), LocalClientId(1)),
-            (ClientId(12), LocalClientId(3)),
-        ]);
-        assert!(cl.get_clients_in_room(room).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(51), LocalClientId(0)),
-            (ClientId(93), LocalClientId(1)),
-        ]);
-    }
-
-    #[async_std::test]
-    async fn test_getting_neighbors() {
-        let cl = ClientLocation::default();
-        cl.add_client_to_lobby(ClientId(93), LobbyId(0)).await.unwrap();
-        cl.add_client_to_lobby(ClientId(23), LobbyId(0)).await.unwrap();
-        cl.add_client_to_lobby(ClientId(51), LobbyId(0)).await.unwrap();
-        cl.add_client_to_lobby(ClientId(12), LobbyId(0)).await.unwrap();
-
-        assert!(cl.get_client_neighbors(ClientId(23)).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(93), LocalClientId(0)),
-            (ClientId(51), LocalClientId(2)),
-            (ClientId(12), LocalClientId(3)),
-        ]);
-    }
-
-    #[async_std::test]
-    async fn test_failing_to_join_lobby_does_not_remove_from_current_area() {
-        let cl = ClientLocation::default();
-        for i in 0..12 {
-            cl.add_client_to_lobby(ClientId(i), LobbyId(0)).await.unwrap();
-        }
-        assert!(cl.add_client_to_lobby(ClientId(99), LobbyId(1)).await.is_ok());
-        assert!(cl.add_client_to_lobby(ClientId(99), LobbyId(0)).await.is_err());
-        assert_eq!(cl.get_clients_in_lobby(LobbyId(0)).await.unwrap().len(), 12);
-        assert_eq!(
-            cl.get_clients_in_lobby(LobbyId(1)).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>(),
-            vec![(ClientId(99), LocalClientId(0))]
-        );
-    }
-
-    #[async_std::test]
-    async fn test_get_leader() {
-        let cl = ClientLocation::default();
-        cl.add_client_to_lobby(ClientId(93), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(23), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(51), LobbyId(0)).await;
-        cl.add_client_to_lobby(ClientId(12), LobbyId(0)).await;
-
-        assert!(cl.get_leader_by_client(ClientId(51)).await.map(|c| (c.client, c.local_client)) == Ok((ClientId(93), LocalClientId(0))));
-    }
-
-    #[async_std::test]
-    async fn test_remove_client_from_room() {
-        let mut cl = ClientLocation::default();
-        let room = cl.create_new_room(ClientId(51)).await.unwrap();
-        cl.add_client_to_room(ClientId(93), room).await;
-        cl.add_client_to_room(ClientId(23), room).await;
-        cl.remove_client_from_area(ClientId(51)).await;
-        cl.add_client_to_room(ClientId(12), room).await;
-
-        assert!(cl.get_clients_in_room(room).await.unwrap().into_iter().map(|c| (c.client, c.local_client)).collect::<Vec<_>>() == vec![
-            (ClientId(12), LocalClientId(0)),
-            (ClientId(93), LocalClientId(1)),
-            (ClientId(23), LocalClientId(2)),
-        ]);
-    }
-
-    #[async_std::test]
-    async fn test_leader_changes_on_leader_leaving() {
-        let mut cl = ClientLocation::default();
-        let room = cl.create_new_room(ClientId(51)).await.unwrap();
-        cl.add_client_to_room(ClientId(93), room).await.unwrap();
-        cl.add_client_to_room(ClientId(23), room).await.unwrap();
-        cl.remove_client_from_area(ClientId(51)).await.unwrap();
-        cl.add_client_to_room(ClientId(12), room).await.unwrap();
-        cl.remove_client_from_area(ClientId(23)).await.unwrap();
-        cl.add_client_to_room(ClientId(99), room).await.unwrap();
-
-        assert!(cl.get_leader_by_client(ClientId(12)).await.map(|c| (c.client, c.local_client)) == Ok((ClientId(93), LocalClientId(1))));
-    }
-}

src/login/character.rs

@@ -2,9 +2,6 @@
 use std::io::Read;
 use std::collections::{BTreeMap, BTreeSet, HashMap};
 
-use async_std::sync::{Arc, RwLock};
-use async_std::channel;
-
 use rand::Rng;
 use crc::{crc32, Hasher32};
 
@@ -12,45 +9,39 @@ use libpso::packet::login::*;
 use libpso::packet::ship::{MenuDetail, SmallLeftDialog};
 use libpso::{PacketParseError, PSOPacket};
 use libpso::crypto::bb::PSOBBCipher;
+use crate::entity::item;
 use libpso::character::character;
-use entity::item;
 
-use networking::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
-use networking::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
-use networking::interserver::{ServerId, InterserverActor, LoginMessage, ShipMessage, Ship};
-use stats::leveltable::LEVEL_TABLE;
-use libpso::util::{utf8_to_array, utf8_to_utf16_array};
+use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
+use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
+use crate::common::interserver::{ServerId, InterserverActor, LoginMessage, ShipMessage, Ship};
+use crate::common::leveltable::CharacterLevelTable;
+use libpso::{utf8_to_array, utf8_to_utf16_array};
 
-use entity::gateway::{EntityGateway, GatewayError};
-use entity::account::{UserAccountId, UserAccountEntity, NewUserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
-use entity::item::{NewItemEntity, ItemDetail, ItemNote, InventoryItemEntity, InventoryEntity, BankEntity, BankIdentifier, EquippedEntity, Meseta};
-use entity::item::weapon::Weapon;
-use entity::item::armor::Armor;
-use entity::item::tech::Technique;
-use entity::item::tool::Tool;
-use entity::item::mag::Mag;
-use entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
+use crate::entity::gateway::{EntityGateway, GatewayError};
+use crate::entity::account::{UserAccountId, UserAccountEntity, NewUserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
+use crate::entity::item::{NewItemEntity, ItemDetail, ItemNote, InventoryItemEntity, InventoryEntity, BankEntity, BankName, EquippedEntity, Meseta};
+use crate::entity::item::weapon::Weapon;
+use crate::entity::item::armor::Armor;
+use crate::entity::item::tech::Technique;
+use crate::entity::item::tool::Tool;
+use crate::entity::item::mag::Mag;
+use crate::entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
 
-use crate::login::get_login_status;
-use networking::interserver::AuthToken;
-
-use pktbuilder::ship::SHIP_MENU_ID;
+use crate::login::login::{get_login_status};
+use crate::common::interserver::AuthToken;
 
 pub const CHARACTER_PORT: u16 = 12001;
+pub const SHIP_MENU_ID: u32 = 1;
 
 #[derive(thiserror::Error, Debug)]
+#[error("")]
 pub enum CharacterError {
-    #[error("invalid menu selection {0} {1}")]
     InvalidMenuSelection(u32, u32),
-    #[error("client not found {0}")]
     ClientNotFound(ClientId),
-    #[error("could not load settings {0}")]
-    CouldNotLoadSettings(GatewayError),
-    #[error("could not load characters")]
+    CouldNotLoadSettings,
     CouldNotLoadCharacters,
-    #[error("could not load guildcard")]
     CouldNotLoadGuildcard,
-    #[error("gateway error {0}")]
     GatewayError(#[from] GatewayError),
 }
 
@@ -150,7 +141,7 @@ fn generate_param_data(path: &str) -> (ParamDataHeader, Vec<u8>) {
             size: len as u32,
             checksum: crc.sum32(),
             offset: buffer.len() as u32,
-            filename: utf8_to_array(param.file_name().unwrap().to_str().unwrap()),
+            filename: utf8_to_array!(param.file_name().unwrap().to_str().unwrap(), 0x40),
         });
 
         buffer.append(&mut filebuf);
@@ -177,7 +168,7 @@ impl ClientState {
             user: None,
             characters: None,
             guildcard_data_buffer: None,
-            session: Session::default(),
+            session: Session::new(),
         }
     }
 }
@@ -188,22 +179,22 @@ struct ConnectedClient {
     expires: Option<chrono::DateTime<chrono::Utc>>,
 }
 
-#[derive(Clone)]
-pub struct CharacterServerState<EG: EntityGateway + Clone> {
+pub struct CharacterServerState<EG: EntityGateway> {
     entity_gateway: EG,
     param_header: ParamDataHeader,
-    param_data: Arc<Vec<u8>>,
-    clients: Arc<RwLock<HashMap<ClientId, ClientState>>>,
-    ships: Arc<RwLock<BTreeMap<ServerId, Ship>>>,
+    param_data: Vec<u8>,
+    clients: HashMap<ClientId, ClientState>,
+    ships: BTreeMap<ServerId, Ship>,
+    level_table: CharacterLevelTable,
     auth_token: AuthToken,
 
-    connected_clients: Arc<RwLock<BTreeMap<UserAccountId, ConnectedClient>>>,
-    authenticated_ships: Arc<RwLock<BTreeSet<ServerId>>>,
-    ship_sender: Arc<RwLock<BTreeMap<ServerId, channel::Sender<LoginMessage>>>>,
+    connected_clients: BTreeMap<UserAccountId, ConnectedClient>,
+    authenticated_ships: BTreeSet<ServerId>,
+    ship_sender: BTreeMap<ServerId, Box<dyn Fn(LoginMessage) + Send>>,
 }
 
 
-async fn new_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, user: &UserAccountEntity, preview: &CharacterPreview) -> Result<(), anyhow::Error> {
+async fn new_character<EG: EntityGateway>(entity_gateway: &mut EG, user: &UserAccountEntity, preview: &CharacterPreview) -> Result<(), anyhow::Error> {
     let mut character = new_character_from_preview(user, preview);
     match character.char_class {
         CharacterClass::FOmar | CharacterClass::FOmarl| CharacterClass::FOnewm | CharacterClass::FOnewearl => character.techs.set_tech(Technique::Foie, TechLevel(1)),
@@ -212,7 +203,6 @@ async fn new_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, user:
 
     let character = entity_gateway.create_character(character).await?;
     entity_gateway.set_character_meseta(&character.id, Meseta(300)).await?;
-    entity_gateway.set_bank_meseta(&character.id, &BankIdentifier::Character, Meseta(0)).await?;
 
     let new_weapon = match character.char_class {
         CharacterClass::HUmar | CharacterClass::HUnewearl | CharacterClass::HUcast | CharacterClass::HUcaseal => item::weapon::WeaponType::Saber,
@@ -267,46 +257,41 @@ async fn new_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, user:
         character_id: character.id,
     }).await?;
 
-    entity_gateway.change_mag_owner(&mag.id, &character).await?;
+    let (monomates, monofluids) = futures::future::join_all((0..4usize).map(|_| {
+        let mut eg = entity_gateway.clone();
+        let character_id = character.id;
+        async move {
+            let monomate = eg.create_item(
+                NewItemEntity {
+                    item: ItemDetail::Tool (
+                        Tool {
+                            tool: item::tool::ToolType::Monomate,
+                        })}).await?;
 
-    let mut monomates = Vec::new();
-    for _ in 0..4usize {
-        let monomate = entity_gateway.create_item(
-            NewItemEntity {
-                item: ItemDetail::Tool (
-                    Tool {
-                        tool: item::tool::ToolType::Monomate,
-                    })}).await?;
+            eg.add_item_note(&monomate.id, ItemNote::CharacterCreation {
+                character_id
+            }).await?;
 
-        entity_gateway.add_item_note(&monomate.id, ItemNote::CharacterCreation {
-            character_id: character.id
-        }).await?;
+            let monofluid = eg.create_item(
+                NewItemEntity {
+                    item: ItemDetail::Tool (
+                        Tool {
+                            tool: item::tool::ToolType::Monofluid,
+                        })}).await?;
 
-        monomates.push(monomate);
-    }
+            eg.add_item_note(&monofluid.id, ItemNote::CharacterCreation {
+                character_id
+            }).await?;
 
-    let mut monofluids = Vec::new();
-    for _ in 0..4usize {
-        let monofluid = entity_gateway.create_item(
-            NewItemEntity {
-                item: ItemDetail::Tool (
-                    Tool {
-                        tool: item::tool::ToolType::Monofluid,
-                    })}).await?;
-
-        entity_gateway.add_item_note(&monofluid.id, ItemNote::CharacterCreation {
-            character_id: character.id
-        }).await?;
-
-        monofluids.push(monofluid);
-    }
+            Ok((monomate, monofluid))
+        }})).await.into_iter().collect::<Result<Vec<_>, GatewayError>>()?.into_iter().unzip();
 
     let inventory = InventoryEntity {
         items: vec![InventoryItemEntity::Individual(weapon.clone()), InventoryItemEntity::Individual(armor.clone()), InventoryItemEntity::Individual(mag.clone()),
                     InventoryItemEntity::Stacked(monomates), InventoryItemEntity::Stacked(monofluids)],
     };
     entity_gateway.set_character_inventory(&character.id, &inventory).await?;
-    entity_gateway.set_character_bank(&character.id, &BankEntity::default(), &BankIdentifier::Character).await?;
+    entity_gateway.set_character_bank(&character.id, &BankEntity::default(), BankName("".into())).await?;
     let equipped = EquippedEntity {
         weapon: Some(weapon.id),
         armor: Some(armor.id),
@@ -318,46 +303,49 @@ async fn new_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, user:
 }
 
 
-impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
+impl<EG: EntityGateway> CharacterServerState<EG> {
     pub fn new(entity_gateway: EG, auth_token: AuthToken) -> CharacterServerState<EG> {
         let (param_header, param_data) = generate_param_data("data/param/");
 
         CharacterServerState {
             entity_gateway,
             param_header,
-            param_data: Arc::new(param_data),
-            clients: Default::default(),
-            ships: Default::default(),
-            //level_table: CharacterLevelTable::default(),
+            param_data,
+            clients: HashMap::new(),
+            ships: BTreeMap::new(),
+            level_table: CharacterLevelTable::default(),
             auth_token,
-            authenticated_ships: Default::default(),
-            ship_sender: Default::default(),
-            connected_clients: Default::default(),
+            authenticated_ships: BTreeSet::new(),
+            ship_sender: BTreeMap::new(),
+            connected_clients: BTreeMap::new(),
         }
     }
 
+    pub fn set_sender(&mut self, server_id: ServerId, sender: Box<dyn Fn(LoginMessage) + Send>) {
+        self.ship_sender.insert(server_id, sender);
+    }
+
     async fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        match get_login_status(&mut self.entity_gateway, pkt).await {
+        match get_login_status(&self.entity_gateway, pkt).await {
             Ok(user) => {
-                if let Some(connected_client) = self.connected_clients.read().await.get(&user.id) {
+                if let Some(connected_client) = self.connected_clients.get(&user.id) {
                     if let Some(expires) = connected_client.expires {
                         if expires > chrono::Utc::now() {
-                            return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::default()))]);
+                            return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::new()))]);
                         }
                     }
                     else {
-                        return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::default()))]);
+                        return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::new()))]);
                     }
                 }
 
-                let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::default());
+                let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
                 response.guildcard = user.guildcard;
-                response.team_id = user.team_id.map_or(0, |ti| ti);
+                response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
 
-                let mut client = self.clients.write().await;
-                let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+                let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
 
-                self.connected_clients.write().await.insert(user.id, ConnectedClient {
+                self.connected_clients.insert(user.id, ConnectedClient {
                     ship_id: None,
                     expires: None, //Some(chrono::Utc::now() + chrono::Duration::minutes(1)),
                 });
@@ -367,34 +355,33 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
                 Ok(vec![SendCharacterPacket::LoginResponse(response)])
             },
             Err(err) => {
-                Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, Session::default()))])
+                Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))])
             }
         }
     }
 
-    async fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
+    fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
         Ok(vec![SendCharacterPacket::Timestamp(Timestamp::new(chrono::Utc::now())),
-                SendCharacterPacket::ShipList(ShipList::new(self.ships.read().await.iter().map(|(i, s)| {
+                SendCharacterPacket::ShipList(ShipList::new(self.ships.iter().map(|(i, s)| {
                     ShipListEntry {
                         menu: SHIP_MENU_ID,
                         item: i.0 as u32,
                         flags: 0,
-                        name: utf8_to_utf16_array(&s.name)
+                        name: utf8_to_utf16_array!(s.name, 0x11)
                     }
                 }).collect()))
         ])
     }
 
     async fn get_settings(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
         let user = client.user.as_ref().unwrap();
 
         let settings = match self.entity_gateway.get_user_settings_by_user(user).await {
             Ok(settings) => settings,
             Err(_) => {
                 let user_settings = NewUserSettingsEntity::new(user.id);
-                self.entity_gateway.create_user_settings(user_settings).await.map_err(CharacterError::CouldNotLoadSettings)?
+                self.entity_gateway.create_user_settings(user_settings).await.map_err(|_| CharacterError::CouldNotLoadSettings)?
             }
         };
 
@@ -406,8 +393,7 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
     }
 
     async fn char_select(&mut self, id: ClientId, select: &CharSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
         if client.characters.is_none() {
             client.characters = Some(self.entity_gateway.get_characters_by_user(client.user.as_ref().unwrap()).await.map_err(|_| CharacterError::CouldNotLoadCharacters)?);
         }
@@ -415,7 +401,7 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
         if select.reason == 0 {
             let chars = client.characters.as_ref().unwrap();
             Ok(if let Some(char) = &chars[select.slot as usize] {
-                let (level, _stats) = LEVEL_TABLE.get_stats_from_exp(char.char_class, char.exp);
+                let (level, _stats) = self.level_table.get_stats_from_exp(char.char_class, char.exp);
                 vec![SendCharacterPacket::CharacterPreview(CharacterPreview {
                     slot: select.slot,
                     character: SelectScreenCharacterBuilder::new()
@@ -453,8 +439,7 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
     }
 
     async fn guildcard_data_header(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
         let guildcard_data = self.entity_gateway.get_guild_card_data_by_user(client.user.as_ref().unwrap()).await.map_err(|_| CharacterError::CouldNotLoadGuildcard)?;
 
         let bytes = guildcard_data.guildcard.as_bytes();
@@ -465,16 +450,15 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
         Ok(vec![SendCharacterPacket::GuildcardDataHeader(GuildcardDataHeader::new(bytes.len(), crc.sum32()))])
     }
 
-    async fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+    fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
         Ok(if again != 0 {
             let start = chunk as usize * GUILD_CARD_CHUNK_SIZE;
-            let len = std::cmp::min(GUILD_CARD_CHUNK_SIZE, client.guildcard_data_buffer.as_ref().unwrap().len() - start);
+            let len = std::cmp::min(GUILD_CARD_CHUNK_SIZE, client.guildcard_data_buffer.as_ref().unwrap().len() as usize - start);
             let end = start + len;
 
-            let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE];
-            buf[..len].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);
+            let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE as usize];
+            buf[..len as usize].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);
 
             vec![SendCharacterPacket::GuildcardDataChunk(Box::new(GuildcardDataChunk::new(chunk, buf, len)))]
         } else {
@@ -483,17 +467,15 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
     }
 
     async fn set_flag(&mut self, id: ClientId, setflag: &SetFlag) -> Result<std::option::IntoIter<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
-        let user = client.user.as_mut().unwrap();
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
+        let mut user = client.user.as_mut().unwrap();
         user.flags = setflag.flags;
         self.entity_gateway.save_user(user).await.unwrap();
         Ok(None.into_iter())
     }
 
-    async fn param_data_chunk_request(&mut self, id: ClientId, _request: &ParamDataChunkRequest) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
+    fn param_data_chunk_request(&mut self, id: ClientId, _request: &ParamDataChunkRequest) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
         let chunk = client.param_index;
         client.param_index += 1;
 
@@ -514,9 +496,8 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
 
     // TODO: move USERFLAGS over to SessionAction
     async fn character_preview(&mut self, id: ClientId, preview: &CharacterPreview) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let mut client = self.clients.write().await;
-        let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
-        let user = client.user.as_mut().unwrap();
+        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
+        let mut user = client.user.as_mut().unwrap();
         if user.flags == USERFLAG_NEWCHAR {
             new_character(&mut self.entity_gateway, user, preview).await?
         }
@@ -538,30 +519,26 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
         ])
     }
 
-    async fn select_ship(&mut self, id: ClientId, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
+    fn select_ship(&mut self, id: ClientId, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
         if menuselect.menu != SHIP_MENU_ID {
            return Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item).into());
         }
 
-        if let Some(client) = self.clients.read().await.get(&id) {
+        if let Some(client) = self.clients.get(&id) {
             if let Some(user) = &client.user {
-                if let Some(cc) = self.connected_clients.write().await.get_mut(&user.id) {
+                if let Some(cc) = self.connected_clients.get_mut(&user.id) {
                     cc.ship_id = Some(ServerId(menuselect.item as usize));
                 }
             }
         }
 
-        let ship = self.ships.read().await;
-        let ship = ship.get(&ServerId(menuselect.item as usize))
-            .ok_or_else(|| CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
+        let ship = self.ships.get(&ServerId(menuselect.item as usize))
+            .ok_or(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
         Ok(vec![SendCharacterPacket::RedirectClient(RedirectClient::new(u32::from_le_bytes(ship.ip.octets()), ship.port))])
     }
 
-    async fn ship_detail(&mut self, menudetail: &MenuDetail) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
-        let players = self.connected_clients
-            .read()
-            .await
-            .iter()
+    fn ship_detail(&mut self, menudetail: &MenuDetail) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
+        let players = self.connected_clients.iter()
             .filter(|(_, client)| {
                 client.ship_id == Some(ServerId(menudetail.item as usize))
             })
@@ -572,14 +549,13 @@ impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
 }
 
 #[async_trait::async_trait]
-impl<EG: EntityGateway + Clone> ServerState for CharacterServerState<EG> {
+impl<EG: EntityGateway> ServerState for CharacterServerState<EG> {
     type SendPacket = SendCharacterPacket;
     type RecvPacket = RecvCharacterPacket;
-    type Cipher = PSOBBCipher;
     type PacketError = anyhow::Error;
 
-    async fn on_connect(&mut self, id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket, Self::Cipher>>, anyhow::Error> {
-        self.clients.write().await.insert(id, ClientState::new());
+    async fn on_connect(&mut self, id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket>>, anyhow::Error> {
+        self.clients.insert(id, ClientState::new());
 
         let mut rng = rand::thread_rng();
 
@@ -589,66 +565,65 @@ impl<EG: EntityGateway + Clone> ServerState for CharacterServerState<EG> {
         rng.fill(&mut client_key[..]);
 
         Ok(vec![OnConnect::Packet(SendCharacterPacket::LoginWelcome(LoginWelcome::new(server_key, client_key))),
-                OnConnect::Cipher(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key),
-                                  PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))
-             //OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
-             //                   Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
+             OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
+                                Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
         ])
     }
 
-    async fn handle(&mut self, id: ClientId, pkt: RecvCharacterPacket) -> Result<Vec<(ClientId, SendCharacterPacket)>, anyhow::Error> {
+    async fn handle(&mut self, id: ClientId, pkt: &RecvCharacterPacket)
+              -> Result<Box<dyn Iterator<Item = (ClientId, SendCharacterPacket)> + Send>, anyhow::Error> {
         Ok(match pkt {
             RecvCharacterPacket::Login(login) => {
                 if login.session.action == SessionAction::SelectCharacter {
-                    self.send_ship_list(id, &login).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                    Box::new(self.send_ship_list(id, login)?.into_iter().map(move |pkt| (id, pkt)))
                 }
                 else {
-                    self.validate_login(id, &login).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                    Box::new(self.validate_login(id, login).await?.into_iter().map(move |pkt| (id, pkt)))
                 }
             },
             RecvCharacterPacket::RequestSettings(_req) => {
-                self.get_settings(id).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.get_settings(id).await?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::CharSelect(sel) => {
-                self.char_select(id, &sel).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.char_select(id, sel).await?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::Checksum(_checksum) => {
-                self.validate_checksum().into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.validate_checksum().into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::GuildcardDataRequest(_request) => {
-                self.guildcard_data_header(id).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.guildcard_data_header(id).await?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::GuildcardDataChunkRequest(request) => {
-                self.guildcard_data_chunk(id, request.chunk, request.again).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.guildcard_data_chunk(id, request.chunk, request.again)?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::ParamDataRequest(_request) => {
-                vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::SetFlag(flag) => {
-                self.set_flag(id, &flag).await?.map(move |pkt| (id, pkt)).collect()
+                Box::new(self.set_flag(id, flag).await?.map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::ParamDataChunkRequest(request) => {
-                self.param_data_chunk_request(id, &request).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.param_data_chunk_request(id, request)?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::CharacterPreview(preview) => {
-                self.character_preview(id, &preview).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.character_preview(id, preview).await?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::MenuSelect(menuselect) => {
-                self.select_ship(id, &menuselect).await?.into_iter().map(move |pkt| (id, pkt)).collect()
+                Box::new(self.select_ship(id, menuselect)?.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvCharacterPacket::MenuDetail(menudetail) => {
                 match menudetail.menu {
-                    SHIP_MENU_ID => self.ship_detail(&menudetail).await?.into_iter().map(move |pkt| (id, pkt)).collect(),
-                    _ => Vec::new()
+                    SHIP_MENU_ID => Box::new(self.ship_detail(menudetail)?.into_iter().map(move |pkt| (id, pkt))),
+                    _ => Box::new(Vec::new().into_iter())
                 }
             }
         })
     }
 
     async fn on_disconnect(&mut self, id: ClientId) -> Result<Vec<(ClientId, SendCharacterPacket)>, anyhow::Error> {
-        if let Some(client) = self.clients.write().await.remove(&id) {
+        if let Some(client) = self.clients.remove(&id) {
             if let Some(user) = client.user {
-                self.connected_clients.write().await.remove(&user.id);
+                self.connected_clients.remove(&user.id);
             }
         }
         Ok(Vec::new())
@@ -656,7 +631,7 @@ impl<EG: EntityGateway + Clone> ServerState for CharacterServerState<EG> {
 }
 
 #[async_trait::async_trait]
-impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
+impl<EG: EntityGateway> InterserverActor for CharacterServerState<EG> {
     type SendMessage = LoginMessage;
     type RecvMessage = ShipMessage;
     type Error = ();
@@ -665,26 +640,21 @@ impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
         Vec::new()
     }
 
-    async fn on_action(&mut self, id: ServerId, msg: Self::RecvMessage) -> Result<Vec<(ServerId, Self::SendMessage)>, Self::Error> {
-        dbg!(&id, &msg);
+    async fn action(&mut self, id: ServerId, msg: Self::RecvMessage) -> Result<Vec<(ServerId, Self::SendMessage)>, Self::Error> {
         match msg {
             ShipMessage::Authenticate(auth_token) => {
                 if self.auth_token == auth_token {
-                    self.authenticated_ships.write().await.insert(id);
+                    self.authenticated_ships.insert(id);
                 }
                 Ok(Vec::new())
             },
             ShipMessage::NewShip(new_ship) => {
-                dbg!("adding ship", &id, &new_ship);
-                if self.authenticated_ships.read().await.contains(&id) {
-                    self.ships.write().await.insert(id, new_ship);
+                if self.authenticated_ships.contains(&id) {
+                    self.ships.insert(id, new_ship);
                 }
-                dbg!("ship list", &self.authenticated_ships);
 
-                let ships = self.ships.read().await.iter().map(|(_, s)| s).cloned().collect::<Vec<_>>();
+                let ships = self.ships.iter().map(|(_, s)| s).cloned().collect::<Vec<_>>();
                 Ok(self.ships
-                   .read()
-                   .await
                    .iter()
                    .map(|(id, _)| {
                        (*id, LoginMessage::ShipList{ ships: ships.clone() })
@@ -692,8 +662,8 @@ impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
                    .collect())
             },
             ShipMessage::AddUser(new_user) => {
-                if self.authenticated_ships.read().await.contains(&id) {
-                    self.connected_clients.write().await.insert(new_user, ConnectedClient {
+                if self.authenticated_ships.contains(&id) {
+                    self.connected_clients.insert(new_user, ConnectedClient {
                         ship_id: Some(id),
                         expires: None,
                     });
@@ -701,18 +671,15 @@ impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
                 Ok(Vec::new())
             },
             ShipMessage::RemoveUser(new_user) => {
-                if self.authenticated_ships.read().await.contains(&id) {
-                    self.connected_clients.write().await.remove(&new_user);
+                if self.authenticated_ships.contains(&id) {
+                    self.connected_clients.remove(&new_user);
                 }
                 Ok(Vec::new())
             },
             ShipMessage::RequestShipList => {
-                dbg!("request ship list", &self.authenticated_ships);
-                if self.authenticated_ships.read().await.contains(&id) {
+                if self.authenticated_ships.contains(&id) {
                     Ok(vec![(id, LoginMessage::ShipList {
                         ships: self.ships
-                            .read()
-                            .await
                             .iter()
                             .map(|(_, ship)| {
                                 ship
@@ -732,25 +699,20 @@ impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
     }
 
     async fn on_disconnect(&mut self, id: ServerId) -> Vec<(ServerId, Self::SendMessage)> {
-        self.ships.write().await.remove(&id);
-        self.ship_sender.write().await.remove(&id);
-        self.connected_clients
-            .write()
-            .await
-            .retain(|_, client| {
+        self.ships.remove(&id);
+        self.ship_sender.remove(&id);
+        self.connected_clients = self.connected_clients.clone().into_iter()
+            .filter(|(_, client)| {
                 client.ship_id != Some(id)
-            });
+            })
+            .collect();
         Vec::new()
     }
-
-    async fn set_sender(&mut self, server_id: ServerId, sender: channel::Sender<LoginMessage>) {
-        self.ship_sender.write().await.insert(server_id, sender);
-    }
 }
 
 
 fn new_character_from_preview(user: &UserAccountEntity, preview: &CharacterPreview) -> NewCharacterEntity {
-    let mut character = NewCharacterEntity::new(user.id);
+    let mut character = NewCharacterEntity::new(user.id, 1); // it should not be possible for the client to specify the kbm config preset from the char create screen
     character.slot = preview.slot;
     character.name = String::from_utf16_lossy(&preview.character.name).trim_matches(char::from(0)).into();
     character.section_id = preview.character.section_id.into();
@@ -824,8 +786,8 @@ impl<'a> SelectScreenCharacterBuilder<'a> {
             hair_b: character.appearance.hair_b,
             prop_x: character.appearance.prop_x,
             prop_y: character.appearance.prop_y,
-            name: utf8_to_utf16_array(&character.name),
-            play_time: character.playtime,
+            name: utf8_to_utf16_array!(character.name, 16),
+            //play_time: character.play_time,
             ..character::SelectScreenCharacter::default()
         }
     }
@@ -835,21 +797,9 @@ impl<'a> SelectScreenCharacterBuilder<'a> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use entity::account::*;
+    use crate::entity::account::*;
     use libpso::character::{settings, character};
-    use entity::gateway::{InMemoryGateway, EntityGatewayTransaction, GatewayError};
-
-    #[derive(Clone)]
-    struct CharTestDb;
-    
-    impl EntityGateway for CharTestDb {
-        type Transaction<'t> = CharTestDb where Self: 't;
-    }
-
-    impl EntityGatewayTransaction for CharTestDb {
-        type ParentGateway = CharTestDb;
-    }
-
+    use crate::entity::gateway::{InMemoryGateway, GatewayError};
 
     #[async_std::test]
     async fn test_option_send() {
@@ -859,8 +809,7 @@ mod test {
 
         #[async_trait::async_trait]
         impl EntityGateway for TestData {
-            type Transaction<'a> = CharTestDb where Self: 'a;
-            async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
+            async fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
                 Ok(UserSettingsEntity {
                     id: UserSettingsId(0),
                     user_id: user.id,
@@ -886,9 +835,11 @@ mod test {
             at_character: false,
             at_ship: false,
         });
-        server.clients.write().await.insert(ClientId(5), clientstate);
+        server.clients.insert(ClientId(5), clientstate);
 
-        let send = server.handle(ClientId(5), RecvCharacterPacket::RequestSettings(RequestSettings{})).await.unwrap();
+        let send = server.handle(ClientId(5), &RecvCharacterPacket::RequestSettings(RequestSettings{})).await
+            .unwrap()
+            .collect::<Vec<_>>();
         assert!(send.len() == 1);
 
         assert!(send[0].0 == ClientId(5));
@@ -901,13 +852,11 @@ mod test {
     async fn test_user_checksum() {
         #[derive(Clone)]
         struct TestData;
-        impl EntityGateway for TestData {
-            type Transaction<'a> = CharTestDb where Self: 'a;
-        }
+        impl EntityGateway for TestData {}
         let mut server = CharacterServerState::new(TestData {}, AuthToken("".into()));
-        let send = server.handle(ClientId(1), RecvCharacterPacket::Checksum(Checksum {checksum: 1234,
-                                                                                      padding: 0,
-        })).await.unwrap();
+        let send = server.handle(ClientId(1), &RecvCharacterPacket::Checksum(Checksum {checksum: 1234,
+                                                                                       padding: 0,
+        })).await.unwrap().collect::<Vec<_>>();
         assert!(send.len() == 1);
 
         let bytes = send[0].1.as_bytes();
@@ -916,7 +865,7 @@ mod test {
 
     #[async_std::test]
     async fn test_character_create() {
-        let mut test_data = InMemoryGateway::default();
+        let test_data = InMemoryGateway::default();
         let mut fake_user = ClientState::new();
         fake_user.user = Some(UserAccountEntity {
             id: UserAccountId(3),
@@ -935,10 +884,10 @@ mod test {
         });
 
         let mut server = CharacterServerState::new(test_data.clone(), AuthToken("".into()));
-        server.clients.write().await.insert(ClientId(1), fake_user.clone());
-        let mut send = server.handle(ClientId(1), RecvCharacterPacket::SetFlag(SetFlag {flags: 1})).await.unwrap();
+        server.clients.insert(ClientId(1), fake_user.clone());
+        let mut send = server.handle(ClientId(1), &RecvCharacterPacket::SetFlag(SetFlag {flags: 1})).await.unwrap().collect::<Vec<_>>();
         assert!(test_data.get_user_by_id(UserAccountId(3)).await.unwrap().flags == 1);
-        send = server.handle(ClientId(1), RecvCharacterPacket::CharacterPreview(CharacterPreview {slot: 1, character: character::SelectScreenCharacter {
+        send = server.handle(ClientId(1), &RecvCharacterPacket::CharacterPreview(CharacterPreview {slot: 1, character: character::SelectScreenCharacter {
             exp: 0,
             level: 0,
             guildcard: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
@@ -964,7 +913,7 @@ mod test {
             prop_y: 0.0,
             name: [9, 69, 116, 101, 115, 116, 32, 110, 97, 109, 101, 0, 0, 0, 0, 0], // "\tEtest name"
             play_time: 0,
-        } })).await.unwrap();
+        } })).await.unwrap().collect::<Vec<_>>();
         assert!(send.len() == 2);
 
         let chars = test_data.get_characters_by_user(&fake_user.user.unwrap()).await.unwrap();

src/login/login.rs

@@ -11,18 +11,18 @@ use libpso::{PacketParseError, PSOPacket};
 use libpso::crypto::bb::PSOBBCipher;
 use libpso::util::array_to_utf8;
 
-use networking::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
-use networking::serverstate::{SendServerPacket,  RecvServerPacket, ServerState, OnConnect, ClientId};
+use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
+use crate::common::serverstate::{SendServerPacket,  RecvServerPacket, ServerState, OnConnect, ClientId};
 
-use entity::gateway::EntityGateway;
-use entity::account::{UserAccountEntity};
+use crate::entity::gateway::EntityGateway;
+use crate::entity::account::{UserAccountEntity};
 
 pub const LOGIN_PORT: u16 = 12000;
 pub const COMMUNICATION_PORT: u16 = 12123;
 
 #[derive(thiserror::Error, Debug)]
+#[error("")]
 pub enum LoginError {
-    #[error("dberror")]
     DbError
 }
 
@@ -59,8 +59,7 @@ impl SendServerPacket for SendLoginPacket {
     }
 }
 
-// TODO: MORE impl EntityGateway?
-pub async fn get_login_status(entity_gateway: &mut impl EntityGateway, pkt: &Login) -> Result<UserAccountEntity, AccountStatus> {
+pub async fn get_login_status(entity_gateway: &impl EntityGateway, pkt: &Login) -> Result<UserAccountEntity, AccountStatus> {
     let username = array_to_utf8(pkt.username).map_err(|_err| AccountStatus::Error)?;
     let password = array_to_utf8(pkt.password).map_err(|_err| AccountStatus::Error)?;
     let user = entity_gateway.get_user_by_name(username).await.map_err(|_| AccountStatus::InvalidUser)?;
@@ -83,16 +82,23 @@ pub async fn get_login_status(entity_gateway: &mut impl EntityGateway, pkt: &Log
 
 pub fn check_if_already_online(user: UserAccountEntity) -> Result<UserAccountEntity, AccountStatus> {
     Ok(user)
+    /*
+    if user.is_currently_online() {
+    Err(AccountStatus::PayUp)
+}
+    else {
+    Ok(user)
+}
+     */
 }
 
-#[derive(Clone)]
-pub struct LoginServerState<EG: EntityGateway + Clone> {
+pub struct LoginServerState<EG: EntityGateway> {
     character_server_ip: net::Ipv4Addr,
     entity_gateway: EG,
-    clients: HashMap<ClientId, String>, // TODO: this should be arc/mutex'd?
+    clients: HashMap<ClientId, String>,
 }
 
-impl<EG: EntityGateway + Clone> LoginServerState<EG> {
+impl<EG: EntityGateway> LoginServerState<EG> {
     pub fn new(entity_gateway: EG, character_server_ip: net::Ipv4Addr) -> LoginServerState<EG> {
         LoginServerState {
             entity_gateway,
@@ -102,7 +108,7 @@ impl<EG: EntityGateway + Clone> LoginServerState<EG> {
     }
 
     async fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendLoginPacket>, anyhow::Error> {
-        match get_login_status(&mut self.entity_gateway, pkt).await.and_then(check_if_already_online) {
+        match get_login_status(&self.entity_gateway, pkt).await.and_then(check_if_already_online) {
             Ok(mut user) => {
                 user.at_login = true;
                 self.entity_gateway.save_user(&user).await.map_err(|_| LoginError::DbError)?;
@@ -111,7 +117,7 @@ impl<EG: EntityGateway + Clone> LoginServerState<EG> {
                 let response = SendLoginPacket::LoginResponse(LoginResponse::by_status(AccountStatus::Ok, pkt.session));
                 let ip = u32::from_ne_bytes(self.character_server_ip.octets());
                 Ok(vec![response,
-                        SendLoginPacket::RedirectClient(RedirectClient::new(ip, crate::character::CHARACTER_PORT))])
+                        SendLoginPacket::RedirectClient(RedirectClient::new(ip, crate::login::character::CHARACTER_PORT))])
             },
             Err(err) => {
                 Ok(vec![SendLoginPacket::LoginResponse(LoginResponse::by_status(err, pkt.session))])
@@ -121,14 +127,13 @@ impl<EG: EntityGateway + Clone> LoginServerState<EG> {
 }
 
 #[async_trait::async_trait]
-impl<EG: EntityGateway + Clone> ServerState for LoginServerState<EG> {
+impl<EG: EntityGateway> ServerState for LoginServerState<EG> {
     type SendPacket = SendLoginPacket;
     type RecvPacket = RecvLoginPacket;
-    type Cipher = PSOBBCipher;
     //type PacketError = LoginError;
     type PacketError = anyhow::Error;
 
-    async fn on_connect(&mut self, _id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket, Self::Cipher>>, anyhow::Error> {
+    async fn on_connect(&mut self, _id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket>>, anyhow::Error> {
         let mut rng = rand::thread_rng();
 
         let mut server_key = [0u8; 48];
@@ -137,20 +142,20 @@ impl<EG: EntityGateway + Clone> ServerState for LoginServerState<EG> {
         rng.fill(&mut client_key[..]);
 
         Ok(vec![OnConnect::Packet(SendLoginPacket::LoginWelcome(LoginWelcome::new(server_key, client_key))),
-                OnConnect::Cipher(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key),
-                                  PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))
+             OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
+                                Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
         ])
     }
 
-    async fn handle(&mut self, id: ClientId, pkt: Self::RecvPacket) -> Result<Vec<(ClientId, Self::SendPacket)>, anyhow::Error> {
+    async fn handle(&mut self, id: ClientId, pkt: &Self::RecvPacket)
+              -> Result<Box<dyn Iterator<Item = (ClientId, Self::SendPacket)> + Send>, anyhow::Error> {
         Ok(match pkt {
             RecvLoginPacket::Login(login) => {
-                self.validate_login(id, &login).await?
-                    .into_iter()
-                    .map(move |pkt| {
-                        (id, pkt)
-                    })
-                    .collect()
+                Box::new(self.validate_login(id, login).await?
+                         .into_iter()
+                         .map(move |pkt| {
+                             (id, pkt)
+                         }))
             }
         })
     }
@@ -170,8 +175,8 @@ impl<EG: EntityGateway + Clone> ServerState for LoginServerState<EG> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use entity::account::{UserAccountId};
-    use entity::gateway::{EntityGatewayTransaction, GatewayError};
+    use crate::entity::account::{UserAccountId};
+    use crate::entity::gateway::GatewayError;
 
     const LOGIN_PACKET: RecvLoginPacket = RecvLoginPacket::Login(Login {
         tag: 65536,
@@ -196,17 +201,6 @@ mod test {
             character_slot: 0,
         }
     });
-    
-    #[derive(Clone)]
-    struct LoginTestDb;
-    
-    impl EntityGateway for LoginTestDb {
-        type Transaction<'t> = LoginTestDb where Self: 't;
-    }
-
-    impl EntityGatewayTransaction for LoginTestDb {
-        type ParentGateway = LoginTestDb;
-    }
 
     #[async_std::test]
     async fn test_correct_login() {
@@ -216,8 +210,7 @@ mod test {
 
         #[async_trait::async_trait]
         impl EntityGateway for TestData {
-            type Transaction<'t> = LoginTestDb where Self: 't;
-            async fn get_user_by_name(&mut self, name: String) -> Result<UserAccountEntity, GatewayError> {
+            async fn get_user_by_name(&self, name: String) -> Result<UserAccountEntity, GatewayError> {
                 assert!(name == "testuser");
                 Ok(UserAccountEntity {
                     id: UserAccountId(1),
@@ -243,7 +236,7 @@ mod test {
 
         let mut server = LoginServerState::new(TestData {}, "127.0.0.1".parse().unwrap());
 
-        let send = server.handle(ClientId(1), LOGIN_PACKET).await.unwrap();
+        let send = server.handle(ClientId(1), &LOGIN_PACKET).await.unwrap().collect::<Vec<_>>();
         assert!(send == vec![
             (ClientId(1), SendLoginPacket::LoginResponse(LoginResponse {
                 status: AccountStatus::Ok,
@@ -275,14 +268,13 @@ mod test {
 
         #[async_trait::async_trait]
         impl EntityGateway for TestData {
-            type Transaction<'t> = LoginTestDb where Self: 't;
-            async fn get_user_by_name(&mut self, _name: String) -> Result<UserAccountEntity, GatewayError> {
+            async fn get_user_by_name(&self, _name: String) -> Result<UserAccountEntity, GatewayError> {
                 Err(GatewayError::Error)
             }
         }
 
         let mut server = LoginServerState::new(TestData {}, "127.0.0.1".parse().unwrap());
-        let send = server.handle(ClientId(1), LOGIN_PACKET).await.unwrap();
+        let send = server.handle(ClientId(1), &LOGIN_PACKET).await.unwrap().collect::<Vec<_>>();
 
         assert!(send == vec![
             (ClientId(1), SendLoginPacket::LoginResponse(LoginResponse {
@@ -310,8 +302,7 @@ mod test {
 
         #[async_trait::async_trait]
         impl EntityGateway for TestData {
-            type Transaction<'t> = LoginTestDb where Self: 't;
-            async fn get_user_by_name(&mut self, name: String) -> Result<UserAccountEntity, GatewayError> {
+            async fn get_user_by_name(&self, name: String) -> Result<UserAccountEntity, GatewayError> {
                 assert!(name == "testuser");
                 Ok(UserAccountEntity {
                     id: UserAccountId(1),
@@ -332,7 +323,7 @@ mod test {
         }
 
         let mut server = LoginServerState::new(TestData {}, "127.0.0.1".parse().unwrap());
-        let send = server.handle(ClientId(1), LOGIN_PACKET).await.unwrap();
+        let send = server.handle(ClientId(1), &LOGIN_PACKET).await.unwrap().collect::<Vec<_>>();
 
         assert!(send == vec![
             (ClientId(1), SendLoginPacket::LoginResponse(LoginResponse {
@@ -360,8 +351,7 @@ mod test {
 
         #[async_trait::async_trait]
         impl EntityGateway for TestData {
-            type Transaction<'t> = LoginTestDb where Self: 't;
-            async fn get_user_by_name(&mut self, name: String) -> Result<UserAccountEntity, GatewayError> {
+            async fn get_user_by_name(&self, name: String) -> Result<UserAccountEntity, GatewayError> {
                 assert!(name == "testuser");
                 Ok(UserAccountEntity {
                     id: UserAccountId(1),
@@ -382,7 +372,7 @@ mod test {
         }
 
         let mut server = LoginServerState::new(TestData {}, "127.0.0.1".parse().unwrap());
-        let send = server.handle(ClientId(1), LOGIN_PACKET).await.unwrap();
+        let send = server.handle(ClientId(1), &LOGIN_PACKET).await.unwrap().collect::<Vec<_>>();
 
         assert!(send == vec![
             (ClientId(1), SendLoginPacket::LoginResponse(LoginResponse {

src/login/mod.rs

@@ -0,0 +1,3 @@
+#[allow(clippy::module_inception)]
+pub mod login;
+pub mod character;

src/login/models.rs

@@ -0,0 +1,92 @@
+use std::time::SystemTime;
+use std::io::Write;
+//use diesel::sql_types::Timestamp;
+use diesel::{Insertable, Queryable, Identifiable, Associations, AsExpression, FromSqlRow};
+//use bcrypt::{DEFAULT_COST, hash};
+use diesel::pg::Pg;
+use diesel::sql_types;
+use diesel::deserialize::{self, FromSql};
+use diesel::serialize::{self, ToSql, Output, IsNull};
+use diesel::backend::Backend;
+
+use libpso::character::settings;
+
+use elseware::schema::*;
+
+//const ELSEWHERE_COST: u32 = bcrypt::DEFAULT_COST;
+const ELSEWHERE_COST: u32 = 5;
+
+#[derive(Debug, AsExpression, FromSqlRow)]
+#[sql_type="sql_types::Binary"]
+pub struct EUserSettings(pub settings::UserSettings);
+
+impl std::ops::Deref for EUserSettings {
+    type Target = settings::UserSettings;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Queryable, Identifiable, Debug)]
+pub struct UserAccount {
+    pub id: i32,
+    pub username: String,
+    pub password: String,
+    pub guildcard: Option<i32>,
+    pub team_id: Option<i32>,
+    pub banned: bool,
+    pub muted_until: SystemTime,
+    pub created_at: SystemTime,
+}
+
+#[derive(Insertable)]
+#[table_name="user_accounts"]
+pub struct NewUser {
+    username: String,
+    password: String,
+}
+
+impl NewUser {
+    pub fn new(username: String, password: String) -> NewUser {
+        let crypt_password = bcrypt::hash(password, ELSEWHERE_COST).expect("could not hash password?");
+        NewUser {
+            username: username,
+            password: crypt_password,
+        }
+    }
+}
+
+#[derive(Queryable, Identifiable, Associations)]
+#[belongs_to(UserAccount, foreign_key="user_id")]
+#[table_name="user_settings"]
+pub struct UserSettings {
+    pub id: i32,
+    pub user_id: i32,
+    //settings: Vec<u8>,
+    pub settings: EUserSettings,
+}
+
+#[derive(Insertable, Debug)]
+#[table_name="user_settings"]
+pub struct NewUserSettings {
+    pub user_id: i32,
+    pub settings: EUserSettings,
+}
+
+impl ToSql<sql_types::Binary, Pg> for EUserSettings {
+    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
+        out.write_all(&self.0.as_bytes()[..])
+            .map(|_| IsNull::No)
+            .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
+    }
+}
+
+impl FromSql<sql_types::Binary, Pg> for EUserSettings {
+    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
+        let bytes_vec: Vec<u8> = <Vec<u8> as FromSql<sql_types::Binary, Pg>>::from_sql(bytes)?;
+        let mut static_bytes = [0u8; 0x1160];
+        static_bytes[..0x1160].clone_from_slice(&bytes_vec);
+        Ok(EUserSettings(settings::UserSettings::from_bytes(static_bytes)))
+    }
+}

src/login_server/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "login_server"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-entity = { workspace = true }
-networking = { workspace = true }
-pktbuilder = { workspace = true }
-stats = { workspace = true }
-
-libpso = { workspace = true }
-
-async-std = { workspace = true }
-async-trait = { workspace = true }
-anyhow = { workspace = true }
-bcrypt = { workspace = true }
-crc = { workspace = true }
-thiserror = { workspace = true }
-chrono = { workspace = true }
-rand= { workspace = true }

src/login_server/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod login;
-pub mod character;

src/maps/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "maps"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-byteorder = { workspace = true }
-serde = { workspace = true }
-thiserror = { workspace = true }
-rand = { workspace = true }
-rand_chacha = { workspace = true }
-toml = { workspace = true }
-enum-utils = { workspace = true }
-derive_more = { workspace = true }

src/maps/src/lib.rs

@@ -1,59 +0,0 @@
-pub mod area;
-pub mod enemy;
-pub mod object;
-pub mod variant;
-pub mod maps;
-pub mod monster;
-pub mod room;
-
-#[derive(Clone, Copy)]
-pub enum Holiday {
-    None,
-    Christmas,
-    Valentines,
-    Easter,
-    Halloween,
-    Sonic,
-    NewYear,
-    Summer,
-    White,
-    Wedding,
-    Fall,
-    Spring,
-    Summer2,
-    Spring2,
-}
-
-
-impl From<Holiday> for u32 {
-    fn from(other: Holiday) -> u32 {
-        u16::from(other) as u32
-    }
-}
-
-impl From<Holiday> for u16 {
-    fn from(other: Holiday) -> u16 {
-        u8::from(other) as u16
-    }
-}
-
-impl From<Holiday> for u8 {
-    fn from(other: Holiday) -> u8 {
-        match other {
-            Holiday::None => 0,
-            Holiday::Christmas => 1,
-            Holiday::Valentines => 3,
-            Holiday::Easter => 4,
-            Holiday::Halloween => 5,
-            Holiday::Sonic => 6,
-            Holiday::NewYear => 7,
-            Holiday::Summer => 8,
-            Holiday::White => 9,
-            Holiday::Wedding => 10,
-            Holiday::Fall => 11,
-            Holiday::Spring => 12,
-            Holiday::Summer2 => 13,
-            Holiday::Spring2 => 14,
-        }
-    }
-}

src/maps/src/room.rs

@@ -1,150 +0,0 @@
-#[derive(Debug, Copy, Clone, derive_more::Display)]
-pub enum Episode {
-    #[display(fmt="ep1")]
-    One,
-    #[display(fmt="ep2")]
-    Two,
-    #[display(fmt="ep4")]
-    Four,
-}
-
-impl TryFrom<u8> for Episode {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Episode, ()> {
-        match value {
-            1 => Ok(Episode::One),
-            2 => Ok(Episode::Two),
-            3 => Ok(Episode::Four),
-            _ => Err(())
-        }
-    }
-}
-
-impl From<Episode> for u8 {
-    fn from(other: Episode) -> u8 {
-        match other {
-            Episode::One => 1,
-            Episode::Two => 2,
-            Episode::Four => 3,
-        }
-    }
-}
-
-impl Episode {
-    pub fn from_quest(value: u8) -> Option<Episode> {
-        match value {
-            0 => Some(Episode::One),
-            1 => Some(Episode::Two),
-            2 => Some(Episode::Four),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, derive_more::Display)]
-pub enum Difficulty {
-    Normal,
-    Hard,
-    VeryHard,
-    Ultimate,
-}
-
-impl TryFrom<u8> for Difficulty {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Difficulty, ()> {
-        match value {
-            0 => Ok(Difficulty::Normal),
-            1 => Ok(Difficulty::Hard),
-            2 => Ok(Difficulty::VeryHard),
-            3 => Ok(Difficulty::Ultimate),
-            _ => Err(())
-        }
-    }
-}
-
-impl From<Difficulty> for u8 {
-    fn from(other: Difficulty) -> u8 {
-        match other {
-            Difficulty::Normal => 0,
-            Difficulty::Hard => 1,
-            Difficulty::VeryHard => 2,
-            Difficulty::Ultimate => 3,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum PlayerMode {
-    Single,
-    Multi,
-}
-
-impl PlayerMode {
-    pub fn value(&self) -> u8 {
-        match self {
-            PlayerMode::Single => 1,
-            PlayerMode::Multi => 0,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, derive_more::Display)]
-pub enum RoomMode {
-    #[display(fmt="single")]
-    Single {
-        episode: Episode,
-        difficulty: Difficulty,
-    },
-    #[display(fmt="multi")]
-    Multi {
-        episode: Episode,
-        difficulty: Difficulty,
-    },
-    #[display(fmt="challenge")]
-    Challenge {
-        episode: Episode,
-    },
-    #[display(fmt="battle")]
-    Battle {
-        episode: Episode,
-        difficulty: Difficulty,
-    }
-}
-
-
-impl RoomMode {
-    pub fn difficulty(&self) -> Difficulty {
-        match self {
-            RoomMode::Single {difficulty, ..} => *difficulty,
-            RoomMode::Multi {difficulty, ..} => *difficulty,
-            RoomMode::Battle {difficulty, ..} => *difficulty,
-            RoomMode::Challenge {..} => Difficulty::Normal,
-        }
-    }
-
-    pub fn episode(&self) -> Episode {
-        match self {
-            RoomMode::Single {episode, ..} => *episode,
-            RoomMode::Multi {episode, ..} => *episode,
-            RoomMode::Battle {episode, ..} => *episode,
-            RoomMode::Challenge {episode, ..} => *episode,
-        }
-    }
-
-    pub fn battle(&self) -> bool {
-        matches!(self, RoomMode::Battle {..})
-    }
-
-    pub fn challenge(&self) -> bool {
-        matches!(self, RoomMode::Challenge {..})
-    }
-
-    pub fn player_mode(&self) -> PlayerMode {
-        match self {
-            RoomMode::Single {..} => PlayerMode::Single,
-            _ => PlayerMode::Multi,
-        }
-    }
-}

src/networking/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "networking"
-version = "0.1.0"
-edition = "2021"
-
-
-[dependencies]
-entity = { workspace = true }
-
-libpso = { workspace = true }
-
-async-std = { workspace = true }
-async-trait = { workspace = true }
-futures = { workspace = true }
-log = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-derive_more = { workspace = true }

src/networking/src/lib.rs

@@ -1,4 +0,0 @@
-pub mod cipherkeys;
-pub mod serverstate;
-pub mod mainloop;
-pub mod interserver;

src/networking/src/mainloop/client.rs

@@ -1,296 +0,0 @@
-use std::collections::HashMap;
-use std::fmt::Debug;
-use std::io::Write;
-use async_std::channel;
-use async_std::io::prelude::{ReadExt, WriteExt};
-use async_std::sync::{Arc, RwLock};
-use futures::future::Future;
-use log::{trace, info, warn, error};
-
-use libpso::crypto::{PSOCipher, NullCipher, CipherError};
-use libpso::PacketParseError;
-use crate::serverstate::ClientId;
-use crate::serverstate::{RecvServerPacket, SendServerPacket, ServerState, OnConnect};
-
-
-#[derive(Debug)]
-pub enum NetworkError {
-    CouldNotSend,
-    CipherError(CipherError),
-    PacketParseError(PacketParseError),
-    IOError(std::io::Error),
-    DataNotReady,
-    ClientDisconnected,
-}
-
-impl From<CipherError> for NetworkError {
-    fn from(err: CipherError) -> NetworkError {
-        NetworkError::CipherError(err)
-    }
-}
-
-impl From<std::io::Error> for NetworkError {
-    fn from(err: std::io::Error) -> NetworkError {
-        NetworkError::IOError(err)
-    }
-}
-
-impl From<PacketParseError> for NetworkError {
-    fn from(err: PacketParseError) -> NetworkError {
-        NetworkError::PacketParseError(err)
-    }
-}
-
-pub struct PacketReceiver<C: PSOCipher> {
-    socket: async_std::net::TcpStream,
-    cipher: C,
-    recv_buffer: Vec<u8>,
-    incoming_data: Vec<u8>,
-}
-
-impl<C: PSOCipher> PacketReceiver<C> {
-    pub fn new(socket: async_std::net::TcpStream, cipher: C) -> PacketReceiver<C> {
-        PacketReceiver {
-            socket,
-            cipher,
-            recv_buffer: Vec::new(),
-            incoming_data: Vec::new(),
-        }
-    }
-
-    async fn fill_recv_buffer(&mut self) -> Result<(), NetworkError> {
-        let mut data = [0u8; 0x8000];
-
-        let mut socket = self.socket.clone();
-        let len = socket.read(&mut data).await?;
-        if len == 0 {
-            return Err(NetworkError::ClientDisconnected);
-        }
-
-        self.recv_buffer.extend_from_slice(&data[..len]);
-
-        let mut dec_buf = {
-            //let mut cipher = self.cipher.lock().await;
-            let block_chunk_len = self.recv_buffer.len() / self.cipher.block_size() * self.cipher.block_size();
-            let buf = self.recv_buffer.drain(..block_chunk_len).collect::<Vec<_>>();
-            self.cipher.decrypt(&buf)?
-        };
-        self.incoming_data.append(&mut dec_buf);
-
-        Ok(())
-    }
-
-    pub async fn recv_pkts<R: RecvServerPacket + std::fmt::Debug>(&mut self) -> Result<Vec<R>, NetworkError> {
-        self.fill_recv_buffer().await?;
-
-        let mut result = Vec::new();
-        loop {
-            if self.incoming_data.len() < 2 {
-                break;
-            }
-            let pkt_size = u16::from_le_bytes([self.incoming_data[0], self.incoming_data[1]]) as usize;
-            let mut pkt_len = pkt_size;
-            while pkt_len % self.cipher.block_size() != 0 {
-                pkt_len += 1;
-            }
-
-            if pkt_len > self.incoming_data.len() {
-                break;
-            }
-
-            let pkt_data = self.incoming_data.drain(..pkt_len).collect::<Vec<_>>();
-
-            trace!("[recv buf] {:?}", pkt_data);
-            let pkt = match R::from_bytes(&pkt_data[..pkt_size]) {
-                Ok(p) => p,
-                Err(err) => {
-                    warn!("error RecvServerPacket::from_bytes: {:?}", err);
-                    continue
-                },
-            };
-
-            result.push(pkt);
-        }
-
-        Ok(result)
-    }
-}
-
-async fn recv_loop<STATE, S, R, C, E>(mut state: STATE,
-                                      socket: async_std::net::TcpStream,
-                                      client_id: ClientId,
-                                      cipher: C,
-                                      clients: Arc<RwLock<HashMap<ClientId, channel::Sender<S>>>>)
-where
-    STATE: ServerState<SendPacket=S, RecvPacket=R, Cipher=C, PacketError=E> + Send,
-    S: SendServerPacket + Debug + Send,
-    R: RecvServerPacket + Debug + Send,
-    C: PSOCipher + Send,
-    E: std::fmt::Debug + Send,
-{
-    let mut pkt_receiver = PacketReceiver::new(socket, cipher);
-    loop {
-        match pkt_receiver.recv_pkts::<R>().await {
-            Ok(pkts) => {
-                for pkt in pkts {
-                    info!("[recv from {:?}] {:#?}", client_id, pkt);
-                    match state.handle(client_id, pkt).await {
-                        Ok(response) => {
-                            for resp in response {
-                                clients
-                                    .read()
-                                    .await
-                                    .get(&resp.0)
-                                    .unwrap()
-                                    .send(resp.1)
-                                    .await
-                                    .unwrap();
-                            }
-                        },
-                        Err(err) => {
-                            error!("[client recv {:?}] error {:?} ", client_id, err);
-
-                            let mut f = std::fs::File::options().create(true).append(true).open("errors.txt").unwrap();
-                            f.write_all(format!("[{client_id:?}] {err:?}").as_bytes()).unwrap();
-
-                            // disconnect client on an error
-                            for pkt in state.on_disconnect(client_id).await.unwrap() {
-                                clients
-                                    .read()
-                                    .await
-                                    .get(&pkt.0)
-                                    .unwrap()
-                                    .send(pkt.1)
-                                    .await
-                                    .unwrap();
-                            }
-                            clients
-                                .write()
-                                .await
-                                .remove(&client_id);
-                            break;
-                        }
-                    }
-                }
-            },
-            Err(err) => {
-                match err {
-                    NetworkError::ClientDisconnected => {
-                        info!("[client recv {:?}] disconnected", client_id);
-                        for pkt in state.on_disconnect(client_id).await.unwrap() {
-                            clients
-                                .read()
-                                .await
-                                .get(&pkt.0)
-                                .unwrap()
-                                .send(pkt.1)
-                                .await
-                                .unwrap();
-                        }
-                        clients
-                            .write()
-                            .await
-                            .remove(&client_id);
-                        break;
-                    }
-                    _ => {
-                        error!("[client {:?} recv error] {:?}", client_id, err);
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-async fn send_pkt<S, C>(socket: &mut async_std::net::TcpStream,
-                        cipher: &mut C,
-                        pkt: &S)
-                        -> Result<(), NetworkError>
-where
-    S: SendServerPacket + std::fmt::Debug,
-    C: PSOCipher,
-{
-    let buf = pkt.as_bytes();
-    let cbuf = cipher.encrypt(&buf)?;
-    socket.write_all(&cbuf).await?;
-    Ok(())
-}
-
-async fn send_loop<S, C>(mut socket: async_std::net::TcpStream, client_id: ClientId, mut cipher: C,  packet_queue: channel::Receiver<S>)
-where
-    S: SendServerPacket + std::fmt::Debug,
-    C: PSOCipher,
-{
-    loop {
-        match packet_queue.recv().await {
-            Ok(pkt) => {
-                info!("[send to {:?}] {:#?}", client_id, pkt);
-                if let Err(err) = send_pkt(&mut socket, &mut cipher, &pkt).await {
-                    error!("error sending pkt {:#?} to {:?} {:?}", pkt, client_id, err);
-                }
-            },
-            Err(err) => {
-                info!("send to {:?} failed: {:?}", client_id, err);
-                break;
-            }
-        }
-    }
-}
-
-pub async fn run_server<STATE, S, R, C, E>(mut state: STATE, port: u16)
-where
-    STATE: ServerState<SendPacket=S, RecvPacket=R, Cipher=C, PacketError=E> + Send + 'static,
-    S: SendServerPacket + std::fmt::Debug + Send + 'static,
-    R: RecvServerPacket + std::fmt::Debug + Send,
-    C: PSOCipher + Send + 'static,
-    E: std::fmt::Debug + Send,
-{
-    let listener = async_std::net::TcpListener::bind(&std::net::SocketAddr::from((std::net::Ipv4Addr::new(0,0,0,0), port))).await.unwrap();
-    let mut id = 0;
-
-    let clients = Arc::new(RwLock::new(HashMap::new()));
-
-    loop {
-        let (mut socket, addr) = listener.accept().await.unwrap();
-        id += 1;
-
-        let client_id = crate::serverstate::ClientId(id);
-        info!("new client {:?} {:?} {:?}", client_id, socket, addr);
-
-        let (client_tx, client_rx) = async_std::channel::unbounded();
-
-        clients
-            .write()
-            .await
-            .insert(client_id, client_tx.clone());
-
-        let mut cipher_in: Option<C> = None;
-        let mut cipher_out: Option<C> = None;
-
-        for action in state.on_connect(client_id).await.unwrap() {
-            match action {
-                OnConnect::Cipher(cin, cout) => {
-                    cipher_in = Some(cin);
-                    cipher_out = Some(cout);
-                },
-                OnConnect::Packet(pkt) => {
-                    if let Err(err) = send_pkt(&mut socket, &mut NullCipher {}, &pkt).await {
-                        error!("error sending on_connect packet {:?}", err);
-                    }
-                }
-            }
-        }
-
-        let rstate = state.clone();
-        let rsocket = socket.clone();
-        let rclients = clients.clone();
-        async_std::task::spawn(async move {
-            recv_loop(rstate, rsocket, client_id, cipher_in.unwrap(), rclients).await
-        });
-
-        async_std::task::spawn(async move {
-            send_loop(socket, client_id, cipher_out.unwrap(), client_rx).await
-        });
-    }
-}

src/networking/src/mainloop/interserver.rs

@@ -1,227 +0,0 @@
-use std::time::Duration;
-use std::pin::Pin;
-use futures::future::Future;
-use log::{info, warn};
-use async_std::sync::{Arc, RwLock};
-use async_std::io::prelude::{ReadExt, WriteExt};
-use std::collections::HashMap;
-use serde::Serialize;
-use serde::de::DeserializeOwned;
-
-use crate::interserver::{ServerId, InterserverActor};
-
-use libpso::crypto::{PSOCipher, NullCipher, CipherError};
-use crate::serverstate::{ServerState, SendServerPacket, RecvServerPacket};
-use entity::gateway::entitygateway::EntityGateway;
-
-use async_std::channel;
-use std::fmt::Debug;
-
-
-#[derive(Debug)]
-enum MessageReceiverError {
-    //InvalidSize,
-    InvalidPayload,
-    //NetworkError(std::io::Error),
-    Disconnected,
-}
-
-struct MessageReceiver {
-    socket: async_std::net::TcpStream,
-}
-
-impl MessageReceiver {
-    fn new(socket: async_std::net::TcpStream) -> MessageReceiver {
-        MessageReceiver {
-            socket,
-        }
-    }
-
-    async fn recv<R: serde::de::DeserializeOwned + std::fmt::Debug>(&mut self) -> Result<R, MessageReceiverError> {
-        let mut size_buf = [0u8; 4];
-        self.socket.read_exact(&mut size_buf).await.map_err(|_| MessageReceiverError::Disconnected)?;
-        let size = u32::from_le_bytes(size_buf) as usize;
-
-        let mut payload = vec![0u8; size];
-        self.socket.read_exact(&mut payload).await.map_err(|_| MessageReceiverError::Disconnected)?;
-        let payload = String::from_utf8(payload).map_err(|_| MessageReceiverError::InvalidPayload)?;
-
-        let msg = serde_json::from_str(&payload).map_err(|_| MessageReceiverError::InvalidPayload)?;
-        Ok(msg)
-    }
-}
-
-async fn interserver_recv_loop<STATE, S, R, E>(mut state: STATE, server_id: ServerId, socket: async_std::net::TcpStream, ships: Arc<RwLock<HashMap<ServerId, channel::Sender<S>>>>)
-where
-    STATE: InterserverActor<SendMessage=S, RecvMessage=R, Error=E> + Send,
-    S: serde::Serialize + Debug + Send,
-    R: serde::de::DeserializeOwned + Debug + Send,
-    E: Debug + Send,
-{
-    let mut msg_receiver = MessageReceiver::new(socket);
-
-    loop {
-        match msg_receiver.recv::<R>().await {
-            Ok(msg) => {
-                info!("[interserver recv {:?}] {:?}", server_id,  msg);
-                match state.on_action(server_id, msg).await {
-                    Ok(response) => {
-                        for resp in response {
-                            ships
-                                .read()
-                                .await
-                                .get(&resp.0)
-                                .unwrap()
-                                .send(resp.1)
-                                .await
-                                .unwrap();
-                        }
-                    },
-                    Err(err) => {
-                        warn!("[interserver recv {:?}] error {:?}", server_id, err);
-                    }
-                }
-            },
-            Err(err) => {
-                if let MessageReceiverError::Disconnected = err {
-                    info!("[interserver recv {:?}] disconnected", server_id);
-                    for (_, _sender) in ships.read().await.iter() {
-                        for pkt in state.on_disconnect(server_id).await {
-                            ships
-                                .read()
-                                .await
-                                .get(&pkt.0)
-                                .unwrap()
-                                .send(pkt.1)
-                                .await
-                                .unwrap();
-                        }
-                    }
-                    ships
-                        .write()
-                        .await
-                        .remove(&server_id);
-                    break;
-                }
-                info!("[interserver recv {:?}] error {:?}", server_id, err);
-            }
-        }
-    }
-}
-
-async fn interserver_send_loop<S>(server_id: ServerId, mut socket: async_std::net::TcpStream, to_send: channel::Receiver<S>)
-where
-    S: serde::Serialize + std::fmt::Debug,
-{
-    loop {
-        let msg = to_send.recv().await.unwrap();
-        let payload = serde_json::to_string(&msg);
-
-        if let Ok(payload) = payload {
-            let len_bytes = u32::to_le_bytes(payload.len() as u32);
-            if let Err(err) = socket.write_all(&len_bytes).await {
-                warn!("[interserver send {:?}] failed: {:?}", server_id, err);
-                break;
-            }
-            if let Err(err) = socket.write_all(payload.as_bytes()).await {
-                warn!("[interserver send {:?}] failed: {:?}", server_id, err);
-                break;
-            }
-        }
-    }
-}
-
-pub async fn run_interserver_listen<STATE, S, R, E>(mut state: STATE, port: u16)
-where
-    STATE: InterserverActor<SendMessage=S, RecvMessage=R, Error=E> + Send + 'static,
-    S: serde::Serialize + Debug + Send + 'static,
-    R: serde::de::DeserializeOwned + Debug + Send,
-    E: Debug + Send,
-{
-    let listener = async_std::net::TcpListener::bind(&std::net::SocketAddr::from((std::net::Ipv4Addr::new(0,0,0,0), port))).await.unwrap();
-    let mut id = 0;
-    let ships = Arc::new(RwLock::new(HashMap::new()));
-
-    loop {
-        let (socket, addr) = listener.accept().await.unwrap();
-        info!("[interserver listen] new server: {:?} {:?}", socket, addr);
-
-        id += 1;
-        let server_id = crate::interserver::ServerId(id);
-        let (client_tx, client_rx) = async_std::channel::unbounded();
-        state.set_sender(server_id, client_tx.clone()).await;
-
-        ships
-            .write()
-            .await
-            .insert(server_id, client_tx.clone());
-
-        for msg in state.on_connect(server_id).await {
-            if let Some(ship_sender) = ships.read().await.get(&msg.0) {
-                ship_sender.send(msg.1).await.unwrap();
-            }
-        }
-
-        let rstate = state.clone();
-        let rsocket = socket.clone();
-        let rships = ships.clone();
-        async_std::task::spawn(async move {
-            interserver_recv_loop(rstate, server_id, rsocket, rships).await;
-        });
-        async_std::task::spawn(async move {
-            interserver_send_loop(server_id, socket, client_rx).await;
-        });
-    }
-}
-
-pub async fn run_interserver_connect<STATE, S, R, E>(mut state: STATE, ip: std::net::Ipv4Addr, port: u16)
-where
-    STATE: InterserverActor<SendMessage=S, RecvMessage=R, Error=E> + Send + 'static,
-    S: serde::Serialize + Debug + Send + 'static,
-    R: serde::de::DeserializeOwned + Debug + Send,
-    E: Debug + Send,
-{
-    let mut id = 0;
-
-    loop {
-        info!("[interserver connect] trying to connect to server");
-        let socket = match async_std::net::TcpStream::connect((ip, port)).await {
-            Ok(socket) => socket,
-            Err(err) => {
-                info!("err trying to connect to loginserv {:?}", err);
-                async_std::task::sleep(std::time::Duration::from_secs(10)).await;
-                continue;
-            }
-        };
-        id += 1;
-        let server_id = crate::interserver::ServerId(id);
-        info!("[interserver connect] found loginserv: {:?} {:?}", server_id, socket);
-
-        let (client_tx, client_rx) = async_std::channel::unbounded();
-        state.set_sender(server_id, client_tx.clone()).await;
-
-        for msg in state.on_connect(server_id).await {
-            client_tx.send(msg.1).await.unwrap();
-        }
-
-        let other_server = vec![(server_id, client_tx.clone())].into_iter().collect();
-        let rstate = state.clone();
-        let rsocket = socket.clone();
-        async_std::task::spawn(async move {
-            interserver_recv_loop(rstate, server_id, rsocket, Arc::new(RwLock::new(other_server))).await;
-        });
-        let ssocket = socket.clone();
-        async_std::task::spawn(async move {
-            interserver_send_loop(server_id, ssocket, client_rx).await;
-        });
-
-        let mut buf = [0u8; 1];
-        loop {
-            let peek = socket.peek(&mut buf).await;
-            if let Ok(0) = peek {
-                break
-            }
-        }
-    }
-
-}

src/networking/src/mainloop/mod.rs

@@ -1,6 +0,0 @@
-#![allow(unused_imports)]
-mod client;
-mod interserver;
-
-pub use self::client::*;
-pub use self::interserver::*;

src/patch/mod.rs

@@ -0,0 +1,2 @@
+#[allow(clippy::module_inception)]
+pub mod patch;

src/patch/patch.rs

@@ -11,8 +11,8 @@ use libpso::crypto::pc::PSOPCCipher;
 use ron::de::from_str;
 use serde::Deserialize;
 
-use networking::mainloop::{NetworkError};
-use networking::serverstate::{RecvServerPacket, SendServerPacket, ServerState, OnConnect, ClientId};
+use crate::common::mainloop::{NetworkError};
+use crate::common::serverstate::{RecvServerPacket, SendServerPacket, ServerState, OnConnect, ClientId};
 
 #[derive(Debug)]
 pub enum PatchError {
@@ -136,7 +136,6 @@ impl SendServerPacket for SendPatchPacket {
 }
 
 
-#[derive(Clone)]
 pub struct PatchServerState {
     patch_file_tree: PatchFileTree,
     patch_file_lookup: HashMap<u32, PatchFile>,
@@ -159,39 +158,33 @@ impl PatchServerState {
 impl ServerState for PatchServerState {
     type SendPacket = SendPatchPacket;
     type RecvPacket = RecvPatchPacket;
-    type Cipher = PSOPCCipher;
     type PacketError = PatchError;
 
-    async fn on_connect(&mut self, _id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket, Self::Cipher>>, PatchError> {
+    async fn on_connect(&mut self, _id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket>>, PatchError> {
         let mut rng = rand::thread_rng();
         let key_in: u32 = rng.gen();
         let key_out: u32 = rng.gen();
 
         Ok(vec![OnConnect::Packet(SendPatchPacket::PatchWelcome(PatchWelcome::new(key_out, key_in))),
-                OnConnect::Cipher(PSOPCCipher::new(key_in), PSOPCCipher::new(key_out))
+             OnConnect::Cipher((Box::new(PSOPCCipher::new(key_in)), Box::new(PSOPCCipher::new(key_out))))
         ])
     }
 
-    async fn handle(&mut self, id: ClientId, pkt: RecvPatchPacket) -> Result<Vec<(ClientId, SendPatchPacket)>, PatchError> {
+    async fn handle(&mut self, id: ClientId, pkt: &RecvPatchPacket)
+              -> Result<Box<dyn Iterator<Item = (ClientId, SendPatchPacket)> + Send>, PatchError> {
         Ok(match pkt {
             RecvPatchPacket::PatchWelcomeReply(_pkt) => {
-                vec![SendPatchPacket::RequestLogin(RequestLogin {})]
-                    .into_iter()
-                    .map(move |pkt| (id, pkt))
-                    .collect()
+                Box::new(vec![SendPatchPacket::RequestLogin(RequestLogin {})].into_iter().map(move |pkt| (id, pkt)))
             },
             RecvPatchPacket::LoginReply(_pkt) => {
-                let mut pkts = vec![SendPatchPacket::Message(Message::new(self.patch_motd.clone()))];
-                pkts.append(&mut get_file_list_packets(&self.patch_file_tree));
-                pkts.push(SendPatchPacket::PatchEndList(PatchEndList {}));
-                pkts
-                    .into_iter()
-                    .map(move |pkt| (id, pkt))
-                    .collect()
+                let mut p = vec![SendPatchPacket::Message(Message::new(self.patch_motd.clone()))];
+                p.append(&mut get_file_list_packets(&self.patch_file_tree));
+                p.push(SendPatchPacket::PatchEndList(PatchEndList {}));
+                Box::new(p.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvPatchPacket::FileInfoReply(pkt) => {
-                self.patch_file_info.push(pkt);
-                Vec::new()
+                self.patch_file_info.push(pkt.clone());
+                Box::new(None.into_iter().map(move |pkt| (id, pkt)))
             },
             RecvPatchPacket::FileInfoListEnd(_pkt) => {
                 let need_update = self.patch_file_info.iter()
@@ -201,12 +194,10 @@ impl ServerState for PatchServerState {
                 let total_size = need_update.iter().fold(0, |a, file_info| a + file_info.size);
                 let total_files = need_update.len() as u32;
 
-                vec![SendPatchPacket::FilesToPatchMetadata(FilesToPatchMetadata::new(total_size, total_files)),
-                     SendPatchPacket::PatchStartList(PatchStartList {})]
-                    .into_iter()
-                    .chain(SendFileIterator::new(self))
-                    .map(move |pkt| (id, pkt))
-                    .collect()
+                let p = vec![SendPatchPacket::FilesToPatchMetadata(FilesToPatchMetadata::new(total_size, total_files)),
+                             SendPatchPacket::PatchStartList(PatchStartList {})
+                ];
+                Box::new(p.into_iter().chain(SendFileIterator::new(self)).map(move |pkt| (id, pkt)))
             }
         })
     }
@@ -341,7 +332,7 @@ impl Iterator for SendFileIterator {
                 if len == 0 {
                     self.current_file = None;
                     self.chunk_num = 0;
-                    Some(SendPatchPacket::EndFileSend(EndFileSend::default()))
+                    Some(SendPatchPacket::EndFileSend(EndFileSend::new()))
                 }
                 else {
                     let mut crc = crc32::Digest::new(crc32::IEEE);
@@ -395,18 +386,18 @@ pub struct PatchConfig {
 
 pub fn load_config() -> PatchConfig {
     let ini_file = match fs::File::open(std::path::Path::new("patch.ron")) {
-        Err(err) => panic!("Failed to open patch.ron config file. \n{err}"),
+        Err(err) => panic!("Failed to open patch.ron config file. \n{}", err),
         Ok(ini_file) => ini_file,
     };
 
     let mut s = String::new();
     if let Err(err) = (&ini_file).read_to_string(&mut s) {
-        panic!("Failed to read patch.ron config file. \n{err}");
+        panic!("Failed to read patch.ron config file. \n{}", err);
     }
 
     let config: PatchConfig = match from_str(s.as_str()) {
         Ok(config) => config,
-        Err(err) => panic!("Failed to load values from patch.ron \n{err}"),
+        Err(err) => panic!("Failed to load values from patch.ron \n{}",err),
     };
     config
 }

src/patch_server/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "patch_server"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-networking = { workspace = true }
-
-libpso = { workspace = true }
-
-async-trait = { workspace = true }
-rand = { workspace = true }
-crc = { workspace = true }
-ron = { workspace = true }
-serde = { workspace = true }

src/pktbuilder/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "pktbuilder"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-quests = { workspace = true }
-stats = { workspace = true }
-location = { workspace = true }
-client = { workspace = true }
-items = { workspace = true }
-networking = { workspace = true }
-maps = { workspace = true }
-room = { workspace = true }
-shops = { workspace = true }
-entity = { workspace = true }
-
-libpso = { workspace = true }
-
-anyhow = { workspace = true }
-futures = { workspace = true }
-thiserror = { workspace = true }

src/pktbuilder/src/lobby.rs

@@ -1,94 +0,0 @@
-use libpso::packet::ship::*;
-use networking::serverstate::ClientId;
-use maps::Holiday;
-use client::Clients;
-use location::{ClientLocation, LobbyId, ClientLocationError};
-use crate::player_info;
-use items::state::ItemState;
-
-use futures::future::join_all;
-
-pub async fn join_lobby(id: ClientId,
-                        lobby: LobbyId,
-                        client_location: &ClientLocation,
-                        clients: &Clients,
-                        item_state: &ItemState,
-                        event: Holiday)
-                        -> Result<JoinLobby, anyhow::Error> {
-    let lobby_clients = client_location.get_clients_in_lobby(lobby).await.map_err(|err| -> ClientLocationError { err.into() })?;
-
-    let playerinfo = join_all(
-        lobby_clients.into_iter()
-            .map(|area_client| {
-                let item_state = item_state.clone();
-                async move {
-                    clients.with(area_client.client, |client| Box::pin(async move {
-                        let inventory = item_state.get_character_inventory(&client.character).await?;
-                        Ok(player_info(0x100, client, &area_client, &inventory).await)
-                    })).await?
-                }}))
-        .await
-        .into_iter()
-        .collect::<Result<Vec<_>, anyhow::Error>>()?;
-
-    let client_block = clients.with(id, |client| Box::pin(async move {
-        client.block as u16
-    })).await?;
-    let area_client = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    let leader = client_location.get_lobby_leader(lobby).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    Ok(JoinLobby {
-        client: area_client.local_client.id(),
-        leader: leader.local_client.id(),
-        one: 1,
-        lobby: lobby.id(),
-        block: client_block,
-        event: event.into(),
-        padding: 0,
-        playerinfo,
-    })
-}
-
-pub async fn add_to_lobby(id: ClientId,
-                          lobby: LobbyId,
-                          client_location: &ClientLocation,
-                          clients: &Clients,
-                          item_state: &ItemState,
-                          event: Holiday)
-                          -> Result<AddToLobby, anyhow::Error> {
-    let area_client = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    let leader = client_location.get_lobby_leader(lobby).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    clients.with(id, |client| {
-        let item_state = item_state.clone();
-        Box::pin(async move {
-            let inventory = item_state.get_character_inventory(&client.character).await?;
-            Ok(AddToLobby {
-                flag: 1,
-                client: area_client.local_client.id(),
-                leader: leader.local_client.id(),
-                one: 1,
-                lobby: lobby.id(),
-                block: client.block as u16,
-                event: event.into(),
-                padding: 0,
-                playerinfo: player_info(0x100, client, &area_client, &inventory).await,
-            })
-        })}).await?
-}
-
-pub async fn remove_from_lobby(id: ClientId,
-                               client_location: &ClientLocation)
-                               -> Result<LeaveLobby, anyhow::Error> {
-    let prev_area_index = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?.local_client.id();
-    let prev_area_leader_index = client_location
-        .get_area_leader(client_location
-                         .get_area(id)
-                         .await
-                         .map_err(|err| -> ClientLocationError { err.into() })?)
-        .await
-        .map_err(|err| -> ClientLocationError { err.into() })?.local_client.id();
-    Ok(LeaveLobby {
-        client: prev_area_index,
-        leader: prev_area_leader_index,
-        _padding: 0,
-    })
-}

src/pktbuilder/src/room.rs

@@ -1,82 +0,0 @@
-use std::convert::TryInto;
-use libpso::packet::ship::*;
-use networking::serverstate::ClientId;
-use maps::Holiday;
-use client::{ClientState, Clients};
-use location::{ClientLocation, RoomId, AreaClient, ClientLocationError};
-use room::RoomState;
-use items::state::ItemState;
-use crate::{player_header, player_info};
-
-use futures::stream::StreamExt;
-
-pub async fn join_room(id: ClientId,
-                       clients: &Clients,
-                       client_location: &ClientLocation,
-                       room_id: RoomId,
-                       room: &RoomState,
-                       event: Holiday)
-                       -> Result<JoinRoom, anyhow::Error> {
-    let all_clients = client_location.get_clients_in_room(room_id).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    #[allow(clippy::manual_try_fold)] // I don't think its even possible to make this work here
-    let players = futures::stream::iter(all_clients.iter())
-        .enumerate()
-        .fold::<Result<_, anyhow::Error>, _, _>(Ok([PlayerHeader::default(); 4]), |acc, (i, c)| async move {
-            let header_area_client = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError {err.into() })?;
-            clients.with(c.client, |client| Box::pin(async move {
-                acc.map(|mut a| {
-                    a[i] = player_header(0x10000, client, &header_area_client);
-                    a
-                })
-            })).await?
-        }).await?;
-
-    let area_client = client_location.get_local_client(id).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    let leader = client_location.get_room_leader(room_id).await.map_err(|err| -> ClientLocationError { err.into() })?;
-    Ok(JoinRoom {
-        flag: all_clients.len() as u32,
-        maps: room.maps.map_headers(),
-        players,
-        client: area_client.local_client.id(),
-        leader: leader.local_client.id(),
-        one: 1,
-        difficulty: room.mode.difficulty().into(),
-        battle: room.mode.battle() as u8,
-        event: event.into(),
-        section: room.section_id.into(),
-        challenge: room.mode.challenge() as u8,
-        random_seed: room.random_seed,
-        episode: room.mode.episode().into(),
-        one2: 1,
-        single_player: room.mode.player_mode().value(),
-        unknown: 0,
-    })
-}
-
-
-pub async fn add_to_room(_id: ClientId,
-                         client: &ClientState,
-                         area_client: &AreaClient,
-                         leader: &AreaClient,
-                         item_state: &ItemState,
-                         event: Holiday)
-                         -> Result<AddToRoom, anyhow::Error> {
-    let inventory = item_state.get_character_inventory(&client.character).await?;
-    Ok(AddToRoom {
-        flag: 1,
-        client: area_client.local_client.id(),
-        leader: leader.local_client.id(),
-        one: 0, // TODO: ????????
-        lobby: 0xFF,
-        block: 0,
-        event: event.into(),
-        padding: 0,
-        playerinfo: player_info(0x10000, client, area_client, &inventory).await,
-    })
-}
-
-pub fn build_rare_monster_list(rare_monster_vec: Vec<u16>) -> RareMonsterList {
-    RareMonsterList {
-        ids: rare_monster_vec.try_into().unwrap_or([0xFFFFu16; 16]),
-    }
-}

src/pktbuilder/src/team.rs

@@ -1,107 +0,0 @@
-use futures::stream::{FuturesOrdered, StreamExt};
-use libpso::packet::ship::*;
-use crate::common::serverstate::ClientId;
-use crate::entity::gateway::EntityGateway;
-use crate::ship::client::{Clients, ClientState};
-use crate::ship::teams::Teams;
-use crate::ship::location::ClientLocation;
-use crate::ship::ship::ShipError;
-use crate::entity::team::TeamEntity;
-
-
-pub fn client_team_state_changed(client_id: ClientId, client: &ClientState, team: &TeamEntity) -> ClientTeamStateChanged {
-    ClientTeamStateChanged {
-        unknown: 0,
-        guildcard: client.user.guildcard(),
-        team_id: team.id.0,
-        unknown2: [0;2],
-        privilege: 0x40, // TODO: improve
-        team_name: libpso::utf8_to_utf16_array!(team.name, 14),
-        unknown3: 0x00986C84, // TODO: what if we omit this?
-    }
-}
-
-fn player_team_info(client_id: ClientId, client: &ClientState, team: &TeamEntity) -> PlayerTeamInfo {
-    PlayerTeamInfo {
-        guildcard: client.user.guildcard(),
-        team_id: team.id.0,
-        info: 0,
-        info2: 0,
-        privilege: 0x40, // TODO: improve
-        team_name: libpso::utf8_to_utf16_array!(team.name, 14),
-        unknown: 0x00986C84, // TODO: what if we omit this?
-        guildcard_again: client.user.guildcard(),
-        client_id: client_id.0 as u32,
-        character_name: libpso::utf8_to_utf16_array!(client.character.name, 12),
-        unknown2: 0,
-        unknown3: 0,
-        team_flag: team.team_flag,
-    }
-}
-
-pub fn team_info_individual(client_id: ClientId, client: &ClientState, team: &TeamEntity) -> TeamInfo {
-    TeamInfo {
-        clients: vec![player_team_info(client_id, client, team)]
-    }
-}
-
-
-pub async fn player_team_info_list<EG>(id: ClientId,
-                           client_location: &ClientLocation,
-                           clients: &Clients,
-                           teams: &Teams<EG>,
-) -> Result<Vec<PlayerTeamInfo>, ShipError>
-where
-    EG: EntityGateway + Clone + 'static,
-{
-    Ok(futures::stream::iter(client_location.get_all_clients_by_client(id).await?.into_iter())
-       .filter_map(|area_client| {
-           let clients = clients.clone();
-           async move {
-               clients.with(area_client.client, |client| {
-                   let mut teams = teams.clone();
-                   Box::pin(async move {
-                       let team = teams.get_team(area_client.client).await.ok()??;
-                       Some(player_team_info(area_client.client, client, &team))
-                   })}).await.ok()?
-           }})
-       .collect::<Vec<_>>()
-       .await)
-}
-
-pub async fn team_info<EG>(id: ClientId,
-                           client_location: &ClientLocation,
-                           clients: &Clients,
-                           teams: &Teams<EG>,
-) -> Result<TeamInfo, ShipError>
-where
-    EG: EntityGateway + Clone + 'static,
-{
-    Ok(TeamInfo {
-        clients: player_team_info_list(id, client_location, clients, teams).await?,
-    })
-}
-
-pub async fn lobby_team_list<EG>(id: ClientId,
-                                 client_location: &ClientLocation,
-                                 clients: &Clients,
-                                 teams: &Teams<EG>,
-) -> Result<TeamLobbyList, ShipError>
-where
-    EG: EntityGateway + Clone + 'static,
-{
-    Ok(TeamLobbyList {
-        clients: player_team_info_list(id, client_location, clients, teams).await?,
-    })
-}
-
-pub fn team_invitation_info(client_id: ClientId, client: &ClientState, team: &TeamEntity) -> TeamInvitationInfo {
-    TeamInvitationInfo {
-        guildcard: client.user.guildcard(),
-        team_id: team.id.0,
-        unknown: [0; 2],
-        team_name: libpso::utf8_to_utf16_array!(team.name, 14),
-        unknown2: 0x00986C84, // TODO: what if we omit this?
-        team_flag: team.team_flag,
-    }
-}

src/quests/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "quests"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-maps = { workspace = true }
-
-libpso = { workspace = true }
-
-async-std = { workspace = true }
-ages-prs = { workspace = true }
-log = { workspace = true }
-byteorder = { workspace = true }
-thiserror = { workspace = true }
-anyhow = { workspace = true }
-toml = { workspace = true }
-serde = { workspace = true }

src/room/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "room"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-maps = { workspace = true }
-entity = { workspace = true }
-quests = { workspace = true }
-location = { workspace = true }
-drops = { workspace = true }
-
-rand = { workspace = true }
-async-std = { workspace = true }
-futures = { workspace = true }
-anyhow = { workspace = true }
-thiserror = { workspace = true }

src/room/src/lib.rs

@@ -1,274 +0,0 @@
-use std::collections::HashMap;
-use std::convert::{From, Into};
-use async_std::sync::{Arc, RwLock, RwLockReadGuard};
-use futures::future::BoxFuture;
-use futures::stream::{FuturesOrdered, Stream};
-
-use thiserror::Error;
-use rand::Rng;
-
-use quests::{QuestList, QuestLoadError};
-use maps::maps::Maps;
-use drops::DropTable;
-use entity::character::SectionID;
-use entity::room::{RoomEntityId, RoomEntityMode};
-use maps::monster::{load_monster_stats_table, MonsterType, MonsterStats};
-use maps::area::MapAreaLookup;
-use maps::Holiday;
-use location::{MAX_ROOMS, RoomId};
-
-use maps::room::{Episode, Difficulty, RoomMode};
-
-#[derive(Error, Debug)]
-pub enum RoomError {
-    #[error("invalid room id {0}")]
-    Invalid(u32),
-}
-
-
-#[derive(Clone)]
-pub struct Rooms([Arc<RwLock<Option<RoomState>>>; MAX_ROOMS]);
-
-
-impl Default for Rooms {
-    fn default() -> Rooms {
-        Rooms(core::array::from_fn(|_| Arc::new(RwLock::new(None))))
-    }
-}
-
-impl Rooms {
-    pub async fn add(&self, room_id: RoomId, room: RoomState) -> Result<(), anyhow::Error> {
-        *self.0
-            .get(room_id.0)
-            .ok_or(RoomError::Invalid(room_id.0 as u32))?
-            .write()
-            .await = Some(room);
-        Ok(())
-    }
-
-    pub async fn remove(&self, room_id: RoomId) {
-        if let Some(room) = self.0.get(room_id.0) {
-            *room
-                .write()
-                .await = None;
-        }
-    }
-
-    pub async fn exists(&self, room_id: RoomId) -> bool {
-        match self.0.get(room_id.0) {
-            Some(room) => {
-                room
-                    .read()
-                    .await
-                    .is_some()
-            },
-            None => false,
-        }
-    }
-
-    pub async fn with<'a, T, F>(&'a self, room_id: RoomId, func: F) -> Result<T, anyhow::Error>
-    where
-        T: Send,
-        F: for<'b> FnOnce(&'b RoomState) -> BoxFuture<'b, T> + Send + 'a
-    {
-        let room = self.0
-            .get(room_id.0)
-            .ok_or(RoomError::Invalid(room_id.0 as u32))?
-            .read()
-            .await;
-        if let Some(room) = room.as_ref() {
-            Ok(func(room).await)
-        }
-        else {
-            Err(RoomError::Invalid(room_id.0 as u32).into())
-        }
-    }
-
-    pub async fn with_mut<'a, T, F>(&'a self, room_id: RoomId, func: F) -> Result<T, anyhow::Error>
-    where
-        T: Send,
-        F: for<'b> FnOnce(&'b mut RoomState) -> BoxFuture<'b, T> + Send + 'a
-    {
-        let mut room = self.0
-            .get(room_id.0)
-            .ok_or(RoomError::Invalid(room_id.0 as u32))?
-            .write()
-            .await;
-
-        if let Some(room) = room.as_mut() {
-            Ok(func(room).await)
-        }
-        else {
-            Err(RoomError::Invalid(room_id.0 as u32).into())
-        }
-    }
-
-    pub async fn get(&self, room_id: RoomId) -> RwLockReadGuard<Option<RoomState>> {
-        self.0
-            .get(room_id.0)
-            .unwrap()
-            .read()
-            .await
-    }
-
-    pub fn stream(&self) -> impl Stream<Item = RwLockReadGuard<Option<RoomState>>> {
-        self.0
-            .iter()
-            .map(|room| async move {
-                room
-                    .read()
-                    .await
-            })
-            .collect::<FuturesOrdered<_>>()
-    }
-}
-
-#[derive(Debug, Error)]
-#[error("")]
-pub enum RoomCreationError {
-    InvalidMode,
-    InvalidEpisode(u8),
-    InvalidDifficulty(u8),
-    CouldNotLoadMonsterStats(RoomMode),
-    CouldNotLoadQuests,
-}
-
-
-pub enum QuestCategoryType {
-    Standard,
-    Government,
-}
-
-impl From<usize> for QuestCategoryType {
-    fn from(f: usize) -> QuestCategoryType {
-        match f {
-            0 => QuestCategoryType::Standard,
-            _ => QuestCategoryType::Government,
-        }
-    }
-}
-impl From<u32> for QuestCategoryType {
-    fn from(f: u32) -> QuestCategoryType {
-        match f {
-            0 => QuestCategoryType::Standard,
-            _ => QuestCategoryType::Government,
-        }
-    }
-}
-
-impl QuestCategoryType {
-    pub fn value(&self) -> usize {
-        match self {
-             QuestCategoryType::Standard => 0,
-             QuestCategoryType::Government => 1,
-        }
-    }
-}
-
-pub struct RoomState {
-    pub room_id: RoomEntityId,
-    pub mode: RoomMode,
-    pub name: String,
-    pub password: [u16; 16],
-    pub maps: Maps,
-    pub drop_table: Box<dyn DropTable + Send + Sync>,
-    pub section_id: SectionID,
-    pub random_seed: u32,
-    pub bursting: bool,
-    pub monster_stats: Box<HashMap<MonsterType, MonsterStats>>,
-    pub map_areas: MapAreaLookup,
-    pub quest_group: QuestCategoryType,
-    pub standard_quests: QuestList,
-    pub government_quests: QuestList,
-    // enemy info
-}
-
-impl RoomState {
-    pub fn get_flags_for_room_list(&self) -> u8 {
-        let mut flags = 0u8;
-
-        match self.mode {
-            RoomMode::Single {..} => {flags += 0x04}
-            RoomMode::Battle {..} => {flags += 0x10},
-            RoomMode::Challenge {..} => {flags += 0x20},
-            _ => {flags += 0x40},
-        };
-
-        if self.password[0] > 0 {
-            flags += 0x02;
-        }
-        flags
-    }
-
-    pub fn get_episode_for_room_list(&self) -> u8 {
-        let episode: u8 = self.mode.episode().into();
-
-        match self.mode {
-            RoomMode::Single {..} => episode + 0x10,
-            _ => episode + 0x40,
-        }
-    }
-
-    pub fn get_difficulty_for_room_list(&self) -> u8 {
-        let difficulty: u8 = self.mode.difficulty().into();
-        difficulty + 0x22
-    }
-
-    pub fn quests(&self) -> &QuestList {
-        match self.quest_group {
-            QuestCategoryType::Standard => &self.standard_quests,
-            QuestCategoryType::Government => &self.government_quests,
-        }
-    }
-
-    #[allow(clippy::too_many_arguments, clippy::type_complexity)]
-    pub fn new (room_id: RoomEntityId,
-                mode: RoomEntityMode,
-                episode: Episode,
-                difficulty: Difficulty,
-                section_id: SectionID,
-                name: String,
-                password: [u16; 16],
-                event: Holiday,
-                map_builder: Arc<Box<dyn Fn(RoomMode, Holiday) -> Maps + Send + Sync>>,
-                drop_table_builder: Arc<Box<dyn Fn(Episode, Difficulty, SectionID) -> Box<dyn DropTable + Send + Sync> + Send + Sync>>,
-                standard_quest_builder: Arc<Box<dyn Fn(RoomMode) -> Result<QuestList, QuestLoadError> + Send + Sync>>,
-                government_quest_builder: Arc<Box<dyn Fn(RoomMode) -> Result<QuestList, QuestLoadError> + Send + Sync>>,
-    ) -> Result<RoomState, anyhow::Error> {
-        let mode = match mode {
-            RoomEntityMode::Single => RoomMode::Single {
-                episode,
-                difficulty,
-            },
-            RoomEntityMode::Multi => RoomMode::Multi {
-                episode,
-                difficulty,
-            },
-            RoomEntityMode::Challenge => RoomMode::Challenge {
-                episode,
-            },
-            RoomEntityMode::Battle => RoomMode::Battle {
-                episode,
-                difficulty,
-            },
-        };
-
-        Ok(RoomState {
-            room_id,
-            monster_stats: Box::new(load_monster_stats_table(&mode).map_err(|_| RoomCreationError::CouldNotLoadMonsterStats(mode))?),
-            mode,
-            random_seed: rand::thread_rng().gen(),
-            name,
-            password,
-            maps: map_builder(mode, event),
-            section_id,
-            drop_table: drop_table_builder(episode, difficulty, section_id),
-            bursting: false,
-            map_areas: MapAreaLookup::new(&episode),
-            quest_group: QuestCategoryType::Standard,
-            standard_quests: standard_quest_builder(mode)?,
-            government_quests: government_quest_builder(mode)?,
-        })
-
-    }
-}

src/ship/character.rs

@@ -1,9 +1,8 @@
 use libpso::character::character;
-use stats::leveltable::CharacterStats;
-use entity::character::CharacterEntity;
-use items::bank::BankState;
-use items::inventory::InventoryState;
-use entity::item::Meseta;
+use crate::common::leveltable::CharacterStats;
+use crate::entity::character::CharacterEntity;
+use crate::ship::items::{CharacterInventory, CharacterBank};
+use crate::entity::item::Meseta;
 
 
 #[derive(Default)]
@@ -53,7 +52,7 @@ impl<'a> CharacterBytesBuilder<'a> {
         let level = self.level.unwrap();
         let meseta = self.meseta.unwrap();
         character::Character {
-            name: libpso::util::utf8_to_utf16_array(&character.name),
+            name: libpso::utf8_to_utf16_array!(character.name, 16),
             hp: stats.hp,
             atp: stats.atp + character.materials.power as u16 * 2,
             mst: stats.mst + character.materials.mind as u16 * 2,
@@ -76,7 +75,7 @@ impl<'a> CharacterBytesBuilder<'a> {
             prop_y: character.appearance.prop_y,
             config: character.config.as_bytes(),
             techniques: character.techs.as_bytes(),
-            meseta: meseta.0,
+            meseta: meseta.0 as u32,
             exp: character.exp,
             ..character::Character::default()
         }
@@ -89,8 +88,8 @@ pub struct FullCharacterBytesBuilder<'a> {
     stats: Option<&'a CharacterStats>,
     level: Option<u32>,
     meseta: Option<Meseta>,
-    inventory: Option<&'a InventoryState>,
-    bank: Option<&'a BankState>,
+    inventory: Option<&'a CharacterInventory>,
+    bank: Option<&'a CharacterBank>,
     keyboard_config: Option<&'a [u8; 0x16C]>,
     gamepad_config: Option<&'a [u8; 0x38]>,
     symbol_chat: Option<&'a [u8; 1248]>,
@@ -132,7 +131,7 @@ impl<'a> FullCharacterBytesBuilder<'a> {
     }
 
     #[must_use]
-    pub fn inventory(self, inventory: &'a InventoryState) -> FullCharacterBytesBuilder<'a> {
+    pub fn inventory(self, inventory: &'a CharacterInventory) -> FullCharacterBytesBuilder<'a> {
         FullCharacterBytesBuilder {
             inventory: Some(inventory),
             ..self
@@ -140,7 +139,7 @@ impl<'a> FullCharacterBytesBuilder<'a> {
     }
 
     #[must_use]
-    pub fn bank(self, bank: &'a BankState) -> FullCharacterBytesBuilder<'a> {
+    pub fn bank(self, bank: &'a CharacterBank) -> FullCharacterBytesBuilder<'a> {
         FullCharacterBytesBuilder {
             bank: Some(bank),
             ..self

src/ship/drops/box_drop_table.rs

@@ -2,17 +2,18 @@
 use rand::{Rng};
 use rand::distributions::{WeightedIndex, Distribution};
 use serde::{Serialize, Deserialize};
-use entity::character::SectionID;
-use maps::room::{Difficulty, Episode};
-use maps::area::MapArea;
-use crate::{ItemDropType, load_data_file};
-use maps::object::{MapObject, MapObjectType, FixedBoxDropType};
-use crate::rare_drop_table::{RareDropTable, RareDropItem};
-use crate::generic_weapon::GenericWeaponTable;
-use crate::generic_armor::GenericArmorTable;
-use crate::generic_shield::GenericShieldTable;
-use crate::generic_unit::GenericUnitTable;
-use crate::tool_table::ToolTable;
+use crate::entity::character::SectionID;
+use crate::ship::room::{Difficulty, Episode};
+use crate::ship::map::MapArea;
+use crate::ship::drops::{ItemDropType, load_data_file};
+use crate::ship::map::{MapObject, MapObjectType, FixedBoxDropType};
+use crate::ship::drops::rare_drop_table::{RareDropTable, RareDropItem};
+use crate::ship::drops::generic_weapon::GenericWeaponTable;
+use crate::ship::drops::generic_armor::GenericArmorTable;
+use crate::ship::drops::generic_shield::GenericShieldTable;
+use crate::ship::drops::generic_unit::GenericUnitTable;
+use crate::ship::drops::tool_table::ToolTable;
+use crate::entity::item::ItemDetail;
 
 #[derive(Debug, Serialize, Deserialize)]
 struct BoxDropRate {
@@ -175,8 +176,8 @@ impl BoxDropTable {
     fn random_box_drop<R: Rng>(&self, map_area: &MapArea, rng: &mut R) -> Option<ItemDropType> {
         self.rare_drop(map_area, rng).or_else(|| {
             let rate = self.box_rates.rates_by_area(map_area);
-            let type_weights = WeightedIndex::new([rate.weapon_rate, rate.armor_rate, rate.shield_rate, rate.unit_rate,
-                                                   rate.tool_rate, rate.meseta_rate, rate.nothing_rate]).unwrap();
+            let type_weights = WeightedIndex::new(&[rate.weapon_rate, rate.armor_rate, rate.shield_rate, rate.unit_rate,
+                                                    rate.tool_rate, rate.meseta_rate, rate.nothing_rate]).unwrap();
             let btype = type_weights.sample(rng);
             match btype {
                 0 => self.weapon_table.get_drop(map_area, rng),
@@ -203,7 +204,7 @@ impl BoxDropTable {
             FixedBoxDropType::Specific(value) => {
                 let mut buf: [u8; 16] = [0; 16];
                 buf[0..4].copy_from_slice(&u32::to_be_bytes(value));
-                ItemDropType::parse_item_from_bytes(buf)
+                ItemDetail::parse_item_from_bytes(buf)
             },
         }
     }

src/ship/drops/generic_armor.rs

@@ -1,14 +1,14 @@
 use std::collections::HashMap;
 use serde::{Serialize, Deserialize};
-use rand::Rng;
+use rand::{Rng};
 use rand::distributions::{WeightedIndex, Distribution};
 
-use entity::character::SectionID;
-use entity::item::armor::{ArmorType, Armor};
-use maps::room::{Difficulty, Episode};
-use maps::area::MapArea;
-use crate::{ItemDropType, load_data_file};
-use stats::items::{armor_stats, ArmorStats};
+use crate::entity::item::armor::{ArmorType, Armor};
+use crate::ship::room::{Difficulty, Episode};
+use crate::ship::map::MapArea;
+use crate::entity::character::SectionID;
+use crate::ship::drops::{ItemDropType, load_data_file};
+use crate::ship::item_stats::{armor_stats, ArmorStats};
 
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -46,8 +46,8 @@ impl GenericArmorTable {
     }
 
     fn armor_type<R: Rng>(&self, area_map: &MapArea, rng: &mut R) -> ArmorType {
-        let rank_weights = WeightedIndex::new([self.rank_rates.rank0, self.rank_rates.rank1, self.rank_rates.rank2,
-                                               self.rank_rates.rank3, self.rank_rates.rank4]).unwrap();
+        let rank_weights = WeightedIndex::new(&[self.rank_rates.rank0, self.rank_rates.rank1, self.rank_rates.rank2,
+                                                self.rank_rates.rank3, self.rank_rates.rank4]).unwrap();
         let rank = rank_weights.sample(rng) as i32;
         let armor_level = std::cmp::max(0i32, self.armor_set as i32 - 3i32 + rank + area_map.drop_area_value().unwrap_or(0) as i32);
         match armor_level {
@@ -80,8 +80,8 @@ impl GenericArmorTable {
     }
 
     pub fn slots<R: Rng>(&self, _area_map: &MapArea, rng: &mut R) -> usize {
-        let slot_weights = WeightedIndex::new([self.slot_rates.slot0, self.slot_rates.slot1, self.slot_rates.slot2,
-                                               self.slot_rates.slot3, self.slot_rates.slot4]).unwrap();
+        let slot_weights = WeightedIndex::new(&[self.slot_rates.slot0, self.slot_rates.slot1, self.slot_rates.slot2,
+                                                self.slot_rates.slot3, self.slot_rates.slot4]).unwrap();
         slot_weights.sample(rng)
     }