feat: Player Data Storage

.gitignore

@@ -18,7 +18,7 @@ result-*
 profile.json.gz
 .DS_Store
 
-world/
+/world/
 whitelist.txt
 
 logs/

Cargo.toml

@@ -14,15 +14,12 @@ resolver = "2"
 members = [
     "src/bin",
     "src/lib/adapters/anvil",
-    "src/lib/adapters/anvil",
-    "src/lib/adapters/nbt",
     "src/lib/adapters/nbt",
     "src/lib/commands",
     "src/lib/default_commands",
     "src/lib/core",
     "src/lib/core/state",
     "src/lib/derive_macros",
-    "src/lib/derive_macros",
     "src/lib/net",
     "src/lib/net/crates/codec",
     "src/lib/net/crates/encryption",
@@ -186,6 +183,7 @@ yazi = "0.2.1"
 # Database
 heed = "0.22.0"
 moka = "0.12.11"
+rusqlite = { version = "0.37.0", features = ["bundled", "serde_json"] }
 
 # CLI
 clap = "4.5.49"

src/bin/src/packet_handlers/mod.rs

@@ -1,7 +1,8 @@
 pub(crate) mod play_packets;
-mod player;
+pub mod player;
 
 pub fn register_player_systems(schedule: &mut bevy_ecs::schedule::Schedule) {
     schedule.add_systems(player::head_rot::handle_player_move);
     schedule.add_systems(player::send_inventory_updates::handle_inventory_updates);
+    schedule.add_systems(player::player_disconnect::handle);
 }

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

@@ -1,4 +1,6 @@
 use bevy_ecs::prelude::{Entity, Query, Res};
+use ferrumc_core::data::player::PlayerData;
+use ferrumc_core::identity::player_identity::PlayerIdentity;
 use ferrumc_core::transform::position::Position;
 use ferrumc_net::connection::StreamWriter;
 use ferrumc_net::packets::outgoing::synchronize_player_position::SynchronizePlayerPositionPacket;
@@ -10,10 +12,10 @@ use tracing::warn;
 pub fn handle(
     ev: Res<PlayerLoadedReceiver>,
     state: Res<GlobalStateResource>,
-    query: Query<(Entity, &Position, &StreamWriter)>,
+    mut query: Query<(Entity, &PlayerIdentity, &StreamWriter, &mut Position)>,
 ) {
     for (_, player) in ev.0.try_iter() {
-        let Ok((entity, player_pos, conn)) = query.get(player) else {
+        let Ok((entity, player_identity, conn, mut position)) = query.get_mut(player) else {
             warn!("Player position not found in query.");
             continue;
         };
@@ -24,28 +26,72 @@ pub fn handle(
             );
             continue;
         }
+
+        // Save the player's position in the world
+        match state
+            .0
+            .world
+            .load_player_state(player_identity.uuid.as_u128())
+        {
+            Ok(loaded) => match loaded {
+                Some(loaded_data) => {
+                    *position =
+                        Position::new(loaded_data.pos.x, loaded_data.pos.y, loaded_data.pos.z);
+                    tracing::info!(
+                        "Loaded player state for {}: {}",
+                        player_identity.uuid.as_u128(),
+                        loaded_data,
+                    );
+                }
+                None => {
+                    if let Err(e) = state
+                        .0
+                        .world
+                        .save_player_state(player_identity.uuid.as_u128(), &PlayerData::default())
+                    // First time saving player data
+                    {
+                        tracing::error!(
+                            "Failed to save player state for {:?}: {:?}",
+                            player_identity,
+                            e
+                        );
+                    }
+                }
+            },
+            Err(e) => {
+                tracing::error!(
+                    "Failed to load player state for {:?}: {:?}",
+                    player_identity,
+                    e
+                );
+                if let Err(e) = state
+                    .0
+                    .world
+                    .save_player_state(player_identity.uuid.as_u128(), &PlayerData::default())
+                // First time saving player data
+                {
+                    tracing::error!(
+                        "Failed to save player state for {:?}: {:?}",
+                        player_identity,
+                        e
+                    );
+                }
+            }
+        }
         let head_block = state.0.world.get_block_and_fetch(
-            player_pos.x as i32,
-            player_pos.y as i32,
-            player_pos.z as i32,
+            position.x as i32,
+            position.y as i32,
+            position.z as i32,
             "overworld",
         );
         if let Ok(head_block) = head_block {
             if head_block == BlockId(0) {
-                tracing::info!(
-                    "Player {} loaded at position: ({}, {}, {})",
-                    player,
-                    player_pos.x,
-                    player_pos.y,
-                    player_pos.z
-                );
+                tracing::info!("Player {} loaded at position: {:?}", player, position);
             } else {
                 tracing::info!(
-                    "Player {} loaded at position: ({}, {}, {}) with head block: {:?}",
+                    "Player {} loaded at position: {:?} with head block: {:?}",
                     player,
-                    player_pos.x,
-                    player_pos.y,
-                    player_pos.z,
+                    position,
                     head_block
                 );
                 // Teleport the player to the world center if their head block is not air
@@ -65,8 +111,8 @@ pub fn handle(
             }
         } else {
             warn!(
-                "Failed to fetch head block for player {} at position: ({}, {}, {})",
-                player, player_pos.x, player_pos.y, player_pos.z
+                "Failed to fetch head block for player {} at position: {:?}",
+                player, position
             );
         }
     }

src/bin/src/packet_handlers/player/mod.rs

@@ -1,2 +1,3 @@
 pub mod head_rot;
+pub mod player_disconnect;
 pub(crate) mod send_inventory_updates;

src/bin/src/packet_handlers/player/player_disconnect.rs

@@ -0,0 +1,20 @@
+use bevy_ecs::{event::EventReader, prelude::Res, system::Commands};
+use ferrumc_core::conn::player_disconnect_event::PlayerDisconnectEvent;
+use ferrumc_state::GlobalStateResource;
+
+pub fn handle(
+    mut cmd: Commands,
+    mut events: EventReader<PlayerDisconnectEvent>,
+    state: Res<GlobalStateResource>,
+) {
+    for event in events.read() {
+        let uuid = event.identity.uuid.as_u128();
+        let username = &event.identity.username;
+        if let Err(e) = state.0.world.save_player_state(uuid, &event.data) {
+            tracing::error!("Failed to save player state for {}: {}", username, e);
+        } else {
+            tracing::info!("Player state saved for {}", username);
+        }
+        cmd.entity(event.entity).despawn();
+    }
+}

src/bin/src/register_events.rs

@@ -3,10 +3,12 @@ use bevy_ecs::prelude::World;
 use ferrumc_commands::events::{CommandDispatchEvent, ResolvedCommandDispatchEvent};
 use ferrumc_core::chunks::cross_chunk_boundary_event::CrossChunkBoundaryEvent;
 use ferrumc_core::conn::force_player_recount_event::ForcePlayerRecountEvent;
+use ferrumc_core::conn::player_disconnect_event::PlayerDisconnectEvent;
 use ferrumc_net::packets::packet_events::TransformEvent;
 
 pub fn register_events(world: &mut World) {
     EventRegistry::register_event::<TransformEvent>(world);
+    EventRegistry::register_event::<PlayerDisconnectEvent>(world);
     EventRegistry::register_event::<CrossChunkBoundaryEvent>(world);
     EventRegistry::register_event::<ForcePlayerRecountEvent>(world);
     EventRegistry::register_event::<CommandDispatchEvent>(world);

src/bin/src/systems/connection_killer.rs

@@ -1,21 +1,36 @@
 use crate::systems::system_messages;
-use bevy_ecs::prelude::{Commands, Entity, Query, Res};
-use ferrumc_core::identity::player_identity::PlayerIdentity;
+use bevy_ecs::{
+    event::EventWriter,
+    prelude::{Entity, Query, Res},
+};
+use ferrumc_core::{
+    conn::player_disconnect_event::PlayerDisconnectEvent,
+    data::player::PlayerData,
+    identity::player_identity::PlayerIdentity,
+    transform::{grounded::OnGround, position::Position, rotation::Rotation},
+};
 use ferrumc_net::connection::StreamWriter;
 use ferrumc_state::GlobalStateResource;
 use ferrumc_text::TextComponent;
 use tracing::{info, trace, warn};
 
 pub fn connection_killer(
-    query: Query<(Entity, &StreamWriter, &PlayerIdentity)>,
-    mut cmd: Commands,
+    query: Query<(
+        Entity,
+        &StreamWriter,
+        &PlayerIdentity,
+        &Position,
+        &OnGround,
+        &Rotation,
+    )>,
+    mut dispatch_events: EventWriter<PlayerDisconnectEvent>,
     state: Res<GlobalStateResource>,
 ) {
     while let Some((disconnecting_entity, reason)) = state.0.players.disconnection_queue.pop() {
         let entity_result = query.get(disconnecting_entity);
         match entity_result {
             Ok(disconnecting_player) => {
-                for (entity, conn, player_identity) in query.iter() {
+                for (entity, conn, player_identity, position, on_ground, rotation) in query.iter() {
                     if disconnecting_entity == entity {
                         info!(
                             "Player {} ({}) disconnected: {}",
@@ -49,7 +64,12 @@ pub fn connection_killer(
                     } else {
                         system_messages::player_leave::handle(disconnecting_player.2, entity);
                     }
-                    cmd.entity(entity).despawn();
+                    let player_disconnect = PlayerDisconnectEvent {
+                        data: PlayerData::new(position, on_ground.0, "overworld", rotation),
+                        identity: player_identity.to_owned(),
+                        entity,
+                    };
+                    dispatch_events.write(player_disconnect);
                 }
             }
             Err(e) => {

src/bin/src/systems/new_connections.rs

@@ -1,11 +1,11 @@
 use crate::systems::system_messages;
 use bevy_ecs::prelude::{Commands, Res, Resource};
 use crossbeam_channel::Receiver;
-use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_core::conn::keepalive::KeepAliveTracker;
 use ferrumc_core::transform::grounded::OnGround;
 use ferrumc_core::transform::position::Position;
 use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_core::{chunks::chunk_receiver::ChunkReceiver, data::player::PlayerData};
 use ferrumc_inventories::hotbar::Hotbar;
 use ferrumc_inventories::inventory::Inventory;
 use ferrumc_net::connection::NewConnection;
@@ -29,6 +29,7 @@ pub fn accept_new_connections(
         let entity = cmd.spawn((
             new_connection.stream,
             Position::default(),
+            PlayerData::default(),
             ChunkReceiver::default(),
             Rotation::default(),
             OnGround::default(),

src/bin/src/systems/shutdown_systems/mod.rs

@@ -1,5 +1,15 @@
+use bevy_ecs::schedule::IntoScheduleConfigs;
+
+use crate::packet_handlers::player;
+
 mod send_shutdown_packet;
 
 pub fn register_shutdown_systems(schedule: &mut bevy_ecs::schedule::Schedule) {
-    schedule.add_systems(send_shutdown_packet::handle);
+    schedule.add_systems(
+        (
+            send_shutdown_packet::handle,
+            player::player_disconnect::handle,
+        )
+            .chain(),
+    );
 }

src/bin/src/systems/shutdown_systems/send_shutdown_packet.rs

@@ -1,19 +1,40 @@
-use bevy_ecs::prelude::{Entity, Query, Res};
-use ferrumc_core::identity::player_identity::PlayerIdentity;
+use bevy_ecs::{
+    event::EventWriter,
+    prelude::{Entity, Query, Res},
+};
+use ferrumc_core::{
+    conn::player_disconnect_event::PlayerDisconnectEvent,
+    data::player::PlayerData,
+    identity::player_identity::PlayerIdentity,
+    transform::{grounded::OnGround, position::Position, rotation::Rotation},
+};
 use ferrumc_net::connection::StreamWriter;
 use ferrumc_state::GlobalStateResource;
 use ferrumc_text::TextComponent;
 
 pub fn handle(
-    query: Query<(Entity, &StreamWriter, &PlayerIdentity)>,
+    query: Query<(
+        Entity,
+        &StreamWriter,
+        &PlayerIdentity,
+        &Position,
+        &OnGround,
+        &Rotation,
+    )>,
+    mut dispatch_events: EventWriter<PlayerDisconnectEvent>,
     state: Res<GlobalStateResource>,
 ) {
     let packet = ferrumc_net::packets::outgoing::disconnect::DisconnectPacket {
         reason: TextComponent::from("Server is shutting down"),
     };
-
-    for (entity, conn, identity) in query.iter() {
+    for (entity, conn, identity, position, on_ground, rotation) in query.iter() {
         if state.0.players.is_connected(entity) {
+            let player_disconnect = PlayerDisconnectEvent {
+                data: PlayerData::new(position, on_ground.0, "overworld", rotation),
+                identity: identity.to_owned(),
+                entity,
+            };
+            dispatch_events.write(player_disconnect);
             if let Err(e) = conn.send_packet_ref(&packet) {
                 tracing::error!(
                     "Failed to send shutdown packet to player {}: {}",

src/lib/core/Cargo.toml

@@ -13,6 +13,8 @@ ferrumc-text = { workspace = true }
 ferrumc-net-codec = { workspace = true }
 uuid = { workspace = true }
 crossbeam-queue = { workspace = true }
+serde = { workspace = true }
+bitcode = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }

src/lib/core/src/conn/mod.rs

@@ -1,3 +1,4 @@
 pub mod force_player_recount_event;
 pub mod keepalive;
 pub mod player_count_update_cooldown;
+pub mod player_disconnect_event;

src/lib/core/src/conn/player_disconnect_event.rs

@@ -0,0 +1,10 @@
+use bevy_ecs::{entity::Entity, event::Event};
+
+use crate::{data::player::PlayerData, identity::player_identity::PlayerIdentity};
+
+#[derive(Event)]
+pub struct PlayerDisconnectEvent {
+    pub entity: Entity,
+    pub identity: PlayerIdentity,
+    pub data: PlayerData,
+}

src/lib/core/src/data/mod.rs

@@ -0,0 +1 @@
+pub mod player;