Cargo.toml

@@ -6,41 +6,35 @@ 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",
+    "client",
+    "drops",
+    "entity",
+    "items",
+    "location",
+    "maps",
+    "networking",
+    "pktbuilder",
+    "quests",
+    "room",
+    "shops",
+    "stats",
+    "trade",
 ]
 
 [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" }
+entity = { path = "./entity" }
+maps = { path = "./maps" }
+networking = { path = "./networking" }
+shops = { path = "./shops" }
+stats = { path = "./stats" }
+items = { path = "./items" }
+pktbuilder = { path = "./pktbuilder" }
+quests = { path = "./quests" }
+location = { path = "./location" }
+client = { path = "./client" }
+drops = { path = "./drops" }
+trade = { path = "./trade" }
+room = { path = "./room" }
 
 libpso = { git = "http://git.sharnoth.com/jake/libpso" }
 
@@ -65,6 +59,7 @@ 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"] }
 strum = "0.19.5"
@@ -75,23 +70,37 @@ anyhow = { version = "1.0.68", features = ["backtrace"] }
 entity = { workspace = true }
 maps = { workspace = true }
 networking = { workspace = true }
-patch_server = { workspace = true }
-login_server = { workspace = true }
-ship_server = { workspace = true }
+shops = { workspace = true }
+stats = { workspace = true }
+items = { workspace = true }
+pktbuilder = { workspace = true }
+quests = { workspace = true }
+location = { workspace = true }
+client = { workspace = true }
+drops = { workspace = true }
+trade = { workspace = true }
+room = { workspace = true }
 
 libpso = { workspace = true }
 
+ages-prs = { workspace = true }
+anyhow = { workspace = true }
+async-recursion = { workspace = true }
 async-std = { workspace = true }
+async-trait = { workspace = true }
 bcrypt = { workspace = true }
+byteorder = { workspace = true }
 chrono = { workspace = true }
+crc = { workspace = true }
+derive_more = { workspace = true }
+enum-utils = { 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 }
+rand = { workspace = true }
+rand_chacha = { workspace = true }
+ron = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+toml = { workspace = true }
+thiserror = { workspace = true }

src/bin/login.rs

@@ -1,7 +1,7 @@
 use log::{info};
 use entity::gateway::postgres::PostgresGateway;
-use login_server::login::LoginServerState;
-use login_server::character::CharacterServerState;
+use elseware::login::login::LoginServerState;
+use elseware::login::character::CharacterServerState;
 use networking::interserver::AuthToken;
 
 fn main() {
@@ -38,17 +38,17 @@ fn main() {
     
     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;
+        networking::mainloop::run_server(login_state, elseware::login::login::LOGIN_PORT).await;
     });
 
     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;
+        networking::mainloop::run_server(sub_char_state, elseware::login::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;
+        networking::mainloop::run_interserver_listen(char_state, elseware::login::login::COMMUNICATION_PORT).await;
     });
     
     info!("[auth/character] starting server");

src/bin/main.rs

@@ -2,10 +2,10 @@ 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::login::login::LoginServerState;
+use elseware::login::character::CharacterServerState;
+use elseware::patch::{PatchServerState, generate_patch_tree, load_config, load_motd};
+use elseware::ship::ship::ShipServerStateBuilder;
 
 use maps::Holiday;
 use entity::gateway::{EntityGateway, InMemoryGateway};
@@ -344,67 +344,67 @@ fn main() {
         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;
+            networking::mainloop::run_server(login_state, elseware::login::login::LOGIN_PORT).await;
         });
 
         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;
+            networking::mainloop::run_server(sub_char_state, elseware::login::character::CHARACTER_PORT).await;
         });
 
         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;
+            networking::mainloop::run_interserver_listen(sub_char_state, elseware::login::login::COMMUNICATION_PORT).await;
         });
 
         info!("[ship] starting servers");
         let ship_state = ShipServerStateBuilder::default()
             .name("US/Sona-Nyl".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT)
+            .port(elseware::ship::ship::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;
+            networking::mainloop::run_server(sub_ship_state, elseware::ship::ship::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;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT).await;
         });
 
         let ship_state = ShipServerStateBuilder::default()
             .name("EU/Dylath-Leen".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT+2000)
+            .port(elseware::ship::ship::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;
+            networking::mainloop::run_server(sub_ship_state, elseware::ship::ship::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;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT).await;
         });
 
         let ship_state = ShipServerStateBuilder::default()
             .name("JP/Thalarion".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(ship_server::SHIP_PORT+3000)
+            .port(elseware::ship::ship::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;
+            networking::mainloop::run_server(sub_ship_state, elseware::ship::ship::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;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT).await;
         });
 
         futures::future::join_all(vec![patch_loop, login_loop, character_loop, inter_character_loop,