Cargo.toml

@@ -6,35 +6,41 @@ edition = "2021"
 
 [workspace]
 members = [
-    "client",
-    "drops",
-    "entity",
-    "items",
-    "location",
-    "maps",
-    "networking",
-    "pktbuilder",
-    "quests",
-    "room",
-    "shops",
-    "stats",
-    "trade",
+    "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 = "./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" }
+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" }
 
@@ -59,7 +65,6 @@ 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"
@@ -70,37 +75,23 @@ anyhow = { version = "1.0.68", features = ["backtrace"] }
 entity = { workspace = true }
 maps = { workspace = true }
 networking = { 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 }
+patch_server = { workspace = true }
+login_server = { workspace = true }
+ship_server = { 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 }
-rand = { workspace = true }
-rand_chacha = { workspace = true }
-ron = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-toml = { workspace = true }
-thiserror = { workspace = true }
+
+[dev-dependencies]
+drops = { workspace = true }
+shops = { workspace = true }
+items = { workspace = true }
+quests = { workspace = true }
+stats = { workspace = true }
+async-trait = { workspace = true }

src/bin/login.rs

@@ -1,7 +1,7 @@
 use log::{info};
 use entity::gateway::postgres::PostgresGateway;
-use elseware::login::login::LoginServerState;
-use elseware::login::character::CharacterServerState;
+use login_server::login::LoginServerState;
+use login_server::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, elseware::login::login::LOGIN_PORT).await;
+        networking::mainloop::run_server(login_state, login_server::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, elseware::login::character::CHARACTER_PORT).await;
+        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, elseware::login::login::COMMUNICATION_PORT).await;
+        networking::mainloop::run_interserver_listen(char_state, login_server::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 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 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 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, elseware::login::login::LOGIN_PORT).await;
+            networking::mainloop::run_server(login_state, login_server::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, elseware::login::character::CHARACTER_PORT).await;
+            networking::mainloop::run_server(sub_char_state, login_server::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, elseware::login::login::COMMUNICATION_PORT).await;
+            networking::mainloop::run_interserver_listen(sub_char_state, login_server::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(elseware::ship::ship::SHIP_PORT)
+            .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, elseware::ship::ship::SHIP_PORT).await;
+            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), elseware::login::login::COMMUNICATION_PORT).await;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
         });
 
         let ship_state = ShipServerStateBuilder::default()
             .name("EU/Dylath-Leen".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(elseware::ship::ship::SHIP_PORT+2000)
+            .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, elseware::ship::ship::SHIP_PORT+2000).await;
+            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), elseware::login::login::COMMUNICATION_PORT).await;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
         });
 
         let ship_state = ShipServerStateBuilder::default()
             .name("JP/Thalarion".into())
             .ip(Ipv4Addr::new(127,0,0,1))
-            .port(elseware::ship::ship::SHIP_PORT+3000)
+            .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, elseware::ship::ship::SHIP_PORT+3000).await;
+            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), elseware::login::login::COMMUNICATION_PORT).await;
+            networking::mainloop::run_interserver_connect(sub_ship_state, std::net::Ipv4Addr::new(127, 0, 0, 1), login_server::login::COMMUNICATION_PORT).await;
         });
 
         futures::future::join_all(vec![patch_loop, login_loop, character_loop, inter_character_loop,

src/bin/patch.rs

@@ -1,4 +1,4 @@
-use elseware::patch::{PatchServerState, generate_patch_tree, load_config_env, load_motd};
+use patch_server::{PatchServerState, generate_patch_tree, load_config_env, load_motd};
 use log::info;
 
 fn main() {

src/bin/ship.rs

@@ -1,6 +1,6 @@
 use log::info;
 use entity::gateway::postgres::PostgresGateway;
-use elseware::ship::ship::ShipServerStateBuilder;
+use ship_server::ShipServerStateBuilder;
 use networking::interserver::AuthToken;
 
 fn main() {
@@ -40,7 +40,7 @@ fn main() {
     let ship_state = ShipServerStateBuilder::default()
         .name(ship_name)
         .ip(ip)
-        .port(elseware::ship::ship::SHIP_PORT)
+        .port(ship_server::SHIP_PORT)
         .gateway(entity_gateway)
         .auth_token(AuthToken(shipgate_token))
         .build();
@@ -49,10 +49,10 @@ fn main() {
 
     let sub_ship_state = ship_state.clone();
     let ship_loop = async_std::task::spawn(async move {
-        networking::mainloop::run_server(sub_ship_state, elseware::ship::ship::SHIP_PORT).await;
+        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, elseware::login::login::COMMUNICATION_PORT).await;
+        networking::mainloop::run_interserver_connect(ship_state, shipgate_ip, login_server::login::COMMUNICATION_PORT).await;
     });
 
     info!("[auth/character] starting server");

src/lib.rs

@@ -1,15 +0,0 @@
-#![allow(clippy::type_complexity)]
-#![allow(incomplete_features)]
-#![feature(inline_const)]
-#![feature(extract_if)]
-#![feature(try_blocks)]
-#![feature(test)]
-#![feature(error_generic_member_access)]
-
-extern crate test;
-
-//pub mod common;
-//pub mod entity;
-pub mod patch;
-pub mod login;
-pub mod ship;

src/login/mod.rs

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

src/login/models.rs

@@ -1,92 +0,0 @@
-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

@@ -0,0 +1,21 @@
+[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/character.rs → src/login_server/src/character.rs

@@ -31,7 +31,7 @@ use entity::item::tool::Tool;
 use entity::item::mag::Mag;
 use entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
 
-use crate::login::login::{get_login_status};
+use crate::login::get_login_status;
 use networking::interserver::AuthToken;
 
 use pktbuilder::ship::SHIP_MENU_ID;

src/login_server/src/lib.rs

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

src/login/login.rs → src/login_server/src/login.rs

@@ -83,21 +83,13 @@ 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> {
     character_server_ip: net::Ipv4Addr,
     entity_gateway: EG,
-    clients: HashMap<ClientId, String>,
+    clients: HashMap<ClientId, String>, // TODO: this should be arc/mutex'd?
 }
 
 impl<EG: EntityGateway + Clone> LoginServerState<EG> {
@@ -119,7 +111,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::login::character::CHARACTER_PORT))])
+                        SendLoginPacket::RedirectClient(RedirectClient::new(ip, crate::character::CHARACTER_PORT))])
             },
             Err(err) => {
                 Ok(vec![SendLoginPacket::LoginResponse(LoginResponse::by_status(err, pkt.session))])

src/patch_server/Cargo.toml

@@ -0,0 +1,15 @@
+[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 }