Merge #114: Change world-specific Resources to world Components

Change world-specific Resources to world Components
Implements #78

Author: dylanopen

Cargo.lock

@@ -3,20 +3,25 @@
 
 use bevy::ecs::entity::Entity;
 use bevy::ecs::message::{MessageReader, MessageWriter};
+use bevy::ecs::query::With;
 use bevy::ecs::system::Query;
 use bevy::math::DVec3;
 use meloncraft_command::raw::RawCommand;
 use meloncraft_entity::position::EntityPosition;
 use meloncraft_entity::position::flags::EntityPositionFlags;
 use meloncraft_entity::position::teleport::TeleportEntity;
-use meloncraft_player::GameProfile;
+use meloncraft_player::{GameProfile, PlayerMarker};
 
 pub fn cmd_teleport(
     mut raw_command_mr: MessageReader<RawCommand>,
     player_profile_q: Query<(Entity, &GameProfile)>,
+    player_position_q: Query<&EntityPosition, With<PlayerMarker>>,
     mut teleport_entity_mw: MessageWriter<TeleportEntity>,
 ) {
     for raw_command in raw_command_mr.read() {
+        // world is relative to *executor*, for now:
+        let world = player_position_q.get(raw_command.executor).unwrap().world;
+
         if raw_command.name != "teleport" && raw_command.name != "tp" {
             return; // we don't care about other commands
         }
@@ -32,6 +37,7 @@ pub fn cmd_teleport(
         let entity = get_player_entity_by_name(player_name, player_profile_q).unwrap();
         let new_position = EntityPosition {
             location: DVec3::new(new_x, new_y, new_z),
+            world,
             flags: EntityPositionFlags {
                 on_ground: false,
                 pushing_against_wall: false,

src/meloncraft_default_commands/src/teleport.rs

@@ -22,6 +22,16 @@ pub struct EntityPositionFlags {
     pub pushing_against_wall: bool,
 }
 
+impl Default for EntityPositionFlags {
+    fn default() -> Self {
+        // these defaults may change in the future
+        return EntityPositionFlags {
+            on_ground: true,
+            pushing_against_wall: false,
+        };
+    }
+}
+
 impl From<u8> for EntityPositionFlags {
     fn from(value: u8) -> Self {
         return Self {

src/meloncraft_entity/src/position/flags.rs

@@ -1,6 +1,7 @@
 //! Module for struct [`EntityPosition`] and submodules related to it.
 
 use bevy::ecs::component::Component;
+use bevy::ecs::entity::Entity;
 use bevy::math::DVec3;
 
 pub mod current_chunk;
@@ -26,6 +27,9 @@ pub struct EntityPosition {
     /// Stored as a bevy [`DVec3`].
     pub location: DVec3,
 
+    /// The entity which represents the world the entity is currently in.
+    pub world: Entity,
+
     /// Extra metadata about the entity's position, such as whether the entity is on the ground or
     /// pushing against a wall. See [`EntityPositionFlags`] for more information about the flags
     /// stored in this field.

src/meloncraft_entity/src/position/mod.rs

@@ -1,14 +1,16 @@
 use crate::ServerboundPacket;
 use crate::network_messages::ServerboundNetworkPacket;
+use bevy::math::DVec3;
 use bevy::prelude::{Entity, Message};
 use meloncraft_client::connection_state::ConnectionState;
-use meloncraft_entity::position::{EntityPosition, flags::EntityPositionFlags};
+use meloncraft_entity::position::flags::EntityPositionFlags;
 use meloncraft_protocol_types::{ProtocolBuffer as _, ProtocolType as _};
 
 #[derive(Message, Debug, Clone)]
 pub struct ServerboundSetPlayerPosition {
     pub client: Entity,
-    pub position: EntityPosition,
+    pub location: DVec3,
+    pub flags: EntityPositionFlags,
 }
 
 impl ServerboundPacket for ServerboundSetPlayerPosition {
@@ -28,7 +30,8 @@ impl ServerboundPacket for ServerboundSetPlayerPosition {
 
         return Some(Self {
             client,
-            position: EntityPosition { location, flags },
+            location,
+            flags,
         });
     }
 }

src/meloncraft_packets/src/serverbound/play/set_player_position.rs

@@ -6,3 +6,8 @@ use bevy::ecs::component::Component;
 /// have *finished* spawning into the world, in the **play** connection state.
 #[derive(Component)]
 pub struct PlayerMarker;
+
+/// Marker to allow querying specifically for player entities. This is added to a client once the
+/// *library user* has added any components they need to add before they are acted upon (e.g. positions).
+#[derive(Component)]
+pub struct LoadedPlayer;

src/meloncraft_player/src/marker.rs

@@ -3,6 +3,7 @@ use bevy::prelude::{MessageReader, MessageWriter, Query, With};
 use meloncraft_entity::position::EntityPosition;
 use meloncraft_entity::position::moved::EntityMoved;
 use meloncraft_entity::position::teleport::TeleportEntity;
+use meloncraft_logger::warnlog;
 use meloncraft_packets::{ClientboundSynchronizePlayerPosition, ServerboundSetPlayerPosition};
 use meloncraft_player::GameProfile;
 
@@ -21,14 +22,26 @@ pub fn fwd_player_moved(
     existing_positions: Query<&EntityPosition, With<GameProfile>>,
 ) {
     for packet in set_position_pr.read() {
-        let old_position = existing_positions.get(packet.client).map_or_else(
-            |_| return packet.position.clone(),
-            |old_position| return old_position.clone(),
-        );
+        let Ok(old_position) = existing_positions.get(packet.client) else {
+            warnlog!(
+                "Couldn't forward {}'s movement, as their old position was not defined. Please define the players movement when their PlayerMarker is added.",
+                packet.client
+            );
+            continue;
+        };
+
+        // For now, we'll set the player's world to the world they were in last tick (as we
+        // don't have dimensions yet anyway):
+        let new_position = EntityPosition {
+            location: packet.location,
+            world: old_position.world,
+            flags: packet.flags,
+        };
+
         player_moved_mw.write(EntityMoved {
             entity: packet.client,
-            old_position,
-            new_position: packet.position.clone(),
+            old_position: old_position.clone(),
+            new_position,
         });
     }
 }

src/meloncraft_player_state/src/movement.rs

@@ -6,6 +6,7 @@ license.workspace = true
 
 [dependencies]
 bevy.workspace = true
+meloncraft_entity.workspace = true
 meloncraft_player.workspace = true
 meloncraft_core.workspace = true
 meloncraft_packets.workspace = true

src/meloncraft_resource_forwarding/Cargo.toml

@@ -1,20 +1,21 @@
 //! Packet forwarders for [`Difficulty`] resource.
 
-use bevy::ecs::change_detection::DetectChanges as _;
 use bevy::ecs::entity::Entity;
 use bevy::ecs::message::MessageWriter;
-use bevy::ecs::query::{Added, With};
-use bevy::ecs::system::{Query, Res};
+use bevy::ecs::query::{Added, Changed, With};
+use bevy::ecs::system::Query;
+use meloncraft_entity::position::EntityPosition;
 use meloncraft_packets::ClientboundChangeDifficulty;
 use meloncraft_player::PlayerMarker;
 use meloncraft_server_info::difficulty::Difficulty;
 
 pub fn send_difficulty_on_join(
-    new_player_q: Query<Entity, Added<PlayerMarker>>,
-    difficulty: Res<Difficulty>,
+    new_player_q: Query<(Entity, &EntityPosition), Added<PlayerMarker>>,
+    difficulty: Query<&Difficulty>,
     mut change_difficulty_pw: MessageWriter<ClientboundChangeDifficulty>,
 ) {
-    for client in new_player_q {
+    for (client, player_position) in new_player_q {
+        let difficulty = difficulty.get(player_position.world).unwrap();
         change_difficulty_pw.write(ClientboundChangeDifficulty {
             client,
             difficulty: *difficulty,
@@ -24,19 +25,20 @@ pub fn send_difficulty_on_join(
 }
 
 pub fn send_difficulty_on_change(
-    player_q: Query<Entity, With<PlayerMarker>>,
-    difficulty: Res<Difficulty>,
+    player_q: Query<(Entity, &EntityPosition), With<PlayerMarker>>,
+    difficulty_q: Query<(Entity, &Difficulty), Changed<Difficulty>>,
     mut change_difficulty_pw: MessageWriter<ClientboundChangeDifficulty>,
 ) {
-    if !difficulty.is_changed() {
-        return;
-    }
-
-    for client in player_q {
-        change_difficulty_pw.write(ClientboundChangeDifficulty {
-            client,
-            difficulty: *difficulty,
-            difficulty_locked: false,
-        });
+    for (world, difficulty) in difficulty_q {
+        for (client, player_position) in player_q {
+            if player_position.world != world {
+                continue;
+            }
+            change_difficulty_pw.write(ClientboundChangeDifficulty {
+                client,
+                difficulty: *difficulty,
+                difficulty_locked: false,
+            });
+        }
     }
 }