chore: changed to sqlite

Author: KingTimer12

Cargo.toml

@@ -36,7 +36,6 @@ members = [
     "src/lib/inventories",
     "src/lib/registry",
     "src/lib/scheduler",
-    "src/lib/player_state",
 ]
 
 #================== Lints ==================#
@@ -106,15 +105,22 @@ ferrumc-scheduler = { path = "src/lib/scheduler" }
 ferrumc-state = { path = "src/lib/core/state" }
 ferrumc-storage = { path = "src/lib/storage" }
 ferrumc-text = { path = "src/lib/text" }
-ferrumc-playerstate = { path = "src/lib/player_state" }
 ferrumc-threadpool = { path = "src/lib/utils/threadpool" }
 ferrumc-utils = { path = "src/lib/utils" }
 ferrumc-world = { path = "src/lib/world" }
 ferrumc-world-gen = { path = "src/lib/world_gen" }
 ferrumc-inventories = { path = "src/lib/inventories" }
 
 # Asynchronous
-tokio = { version = "1.47.1", features = ["macros", "net", "rt", "sync", "time", "io-util", "test-util"], default-features = false }
+tokio = { version = "1.47.1", features = [
+    "macros",
+    "net",
+    "rt",
+    "sync",
+    "time",
+    "io-util",
+    "test-util",
+], default-features = false }
 
 # Logging
 tracing = "0.1.41"

src/bin/Cargo.toml

@@ -33,7 +33,6 @@ ferrumc-threadpool = { workspace = true }
 ferrumc-inventories = { workspace = true }
 once_cell = { workspace = true }
 serde_json = { workspace = true }
-ferrumc-playerstate = { workspace = true }
 
 tracing = { workspace = true }
 clap = { workspace = true, features = ["derive", "env"] }

src/bin/src/main.rs

@@ -6,6 +6,7 @@ use ferrumc_config::server_config::get_global_config;
 use ferrumc_config::whitelist::create_whitelist;
 use ferrumc_general_purpose::paths::get_root_path;
 use ferrumc_state::player_list::PlayerList;
+use ferrumc_state::player_state::PlayerState;
 use ferrumc_state::{GlobalState, ServerState};
 use ferrumc_threadpool::ThreadPool;
 use ferrumc_world::World;
@@ -159,6 +160,7 @@ fn create_state(start_time: Instant) -> Result<ServerState, BinaryError> {
         world: World::new(&get_global_config().database.db_path),
         terrain_generator: WorldGenerator::new(0),
         shut_down: false.into(),
+        player_state: PlayerState::default(),
         players: PlayerList::default(),
         thread_pool: ThreadPool::new(),
         start_time,

src/bin/src/packet_handlers/play_packets/player_loaded.rs

@@ -29,7 +29,6 @@ pub fn handle(
 
         // Default player data
         *player_data = PlayerData::new(
-            player_identity.uuid.as_u128(),
             Position::default(),
             "overworld",
         );
@@ -38,35 +37,36 @@ pub fn handle(
         if let Ok(loaded) = state
             .0
             .world
-            .players_state
             .load_player_state(player_identity.uuid.as_u128())
         {
             match loaded {
                 Some(loaded_data) => {
                     *player_data = loaded_data;
                     tracing::info!(
                         "Loaded player state for {}: position=({}, {}, {}), dimension={}",
-                        player_data.uuid,
+                        player_identity.uuid.as_u128(),
                         player_data.pos.x,
                         player_data.pos.y,
                         player_data.pos.z,
                         player_data.dimension
                     );
                 }
                 None => {
-                    if let Err(e) = state.0.world.players_state.save_player_state(&player_data) {
+                    if let Err(e) = state.0.world.save_player_state(player_identity.uuid.as_u128(), &player_data) {
                         tracing::error!(
-                            "Failed to save player state for {}: {:?}",
+                            "Failed to save player state for {} ({}): {:?}",
                             player_identity.username,
+                            player_identity.uuid.as_u128(),
                             e
                         );
                     }
                 }
             }
-        } else if let Err(e) = state.0.world.players_state.save_player_state(&player_data) {
+        } else if let Err(e) = state.0.world.save_player_state(player_identity.uuid.as_u128(), &player_data) {
             tracing::error!(
-                "Failed to save player state for {}: {:?}",
+                "Failed to save player state for {} ({}): {:?}",
                 player_identity.username,
+                player_identity.uuid.as_u128(),
                 e
             );
         }

src/lib/core/src/data/player.rs

@@ -5,23 +5,23 @@ use serde::{Deserialize, Serialize};
 use crate::transform::position::Position;
 
 // https://minecraft.fandom.com/wiki/Player.dat_format
-#[derive(Serialize, Deserialize, Debug, Encode, Decode, Component, typename::TypeName)]
+#[derive(
+    Serialize, Deserialize, Clone, Debug, Encode, Decode, Component, typename::TypeName, PartialEq,
+)]
 pub struct PlayerData {
-    pub uuid: u128,
     pub pos: Position,
     pub dimension: String,
 }
 
 impl Default for PlayerData {
     fn default() -> Self {
-        Self::new(0, Position::default(), "overworld")
+        Self::new(Position::default(), "overworld")
     }
 }
 
 impl PlayerData {
-    pub fn new(uuid: u128, pos: Position, dimension: &str) -> Self {
+    pub fn new(pos: Position, dimension: &str) -> Self {
         Self {
-            uuid,
             pos,
             dimension: dimension.to_string(),
         }

src/lib/core/src/transform/position.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{Debug, Display, Formatter};
 use typename::TypeName;
 
-#[derive(TypeName, Component, Serialize, Deserialize, Encode, Decode)]
+#[derive(TypeName, Component, Serialize, Deserialize, Encode, Decode, Clone, PartialEq)]
 pub struct Position {
     pub x: f64,
     pub y: f64,

src/lib/core/state/Cargo.toml

@@ -10,3 +10,4 @@ ferrumc-world-gen = { workspace = true }
 dashmap = { workspace = true }
 ferrumc-threadpool = { workspace = true }
 crossbeam-queue = { workspace = true }
+ferrumc-core = { workspace = true }

src/lib/core/state/src/lib.rs

@@ -1,6 +1,8 @@
 pub mod player_list;
+pub mod player_state;
 
 use crate::player_list::PlayerList;
+use crate::player_state::PlayerState;
 use bevy_ecs::prelude::Resource;
 use ferrumc_threadpool::ThreadPool;
 use ferrumc_world::World;
@@ -12,6 +14,7 @@ use std::time::Instant;
 pub struct ServerState {
     pub world: World,
     pub terrain_generator: WorldGenerator,
+    pub player_state: PlayerState,
     pub shut_down: AtomicBool,
     pub players: PlayerList, // (UUID, Username)
     pub thread_pool: ThreadPool,

src/lib/core/state/src/player_state.rs

@@ -0,0 +1,22 @@
+use bevy_ecs::entity::Entity;
+use dashmap::DashMap;
+use ferrumc_core::data::player::PlayerData;
+
+#[derive(Debug, Default)]
+pub struct PlayerState {
+    player_data: DashMap<Entity, PlayerData>,
+}
+
+impl PlayerState {
+    pub fn is_connected(&self, entity: Entity) -> bool {
+        self.player_data.contains_key(&entity)
+    }
+
+    pub fn disconnect(&self, entity: Entity) {
+        self.player_data.remove(&entity);
+    }
+
+    pub fn connect(&self, entity: Entity, data: PlayerData) {
+        self.player_data.insert(entity, data);
+    }
+}