made chunks have direct reference to players

start on room implementations (puzzles and such)

Author: Stivais

server/src/player/player.rs

@@ -16,7 +16,8 @@ use crate::network::protocol::play::serverbound::PlayerDiggingAction;
 use crate::player::packet_handling::BlockInteractResult;
 use crate::types::aabb::AABB;
 use crate::world::chunk::chunk::get_chunk_position;
-use crate::world::chunk::chunk_grid::{ChunkDiff, ChunkGrid};
+use crate::world::chunk::chunk_grid;
+use crate::world::chunk::chunk_grid::ChunkDiff;
 use crate::world::world::VIEW_DISTANCE;
 use crate::world::world::{World, WorldExtension};
 use fstr::FString;
@@ -215,9 +216,7 @@ impl<E : PlayerExtension> Player<E> {
             if let Some(old_chunk) = chunk_grid.get_chunk_mut(last_chunk_x, last_chunk_z) {
                 old_chunk.remove_player(self.client_id)
             }
-            if let Some(new_chunk) = chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
-                new_chunk.insert_player(self.client_id)
-            }
+            self.world_mut().add_player_to_chunk(self.client_id, chunk_x, chunk_z);
 
             self.world().chunk_grid.for_each_diff(
                 (chunk_x, chunk_z),
@@ -232,7 +231,7 @@ impl<E : PlayerExtension> Player<E> {
                         chunk.write_spawn_entities(self);
                     } else {
                         chunk.write_despawn_entities(self);
-                        self.write_packet(&ChunkGrid::get_unload_chunk_packet(x, z));
+                        self.write_packet(&chunk_grid::get_unload_chunk_packet(x, z));
                     }
                 }
             )

server/src/world/chunk/chunk.rs

@@ -3,19 +3,21 @@ use crate::entity::entity::EntityId;
 use crate::network::packets::packet_buffer::PacketBuffer;
 use crate::network::protocol::play::clientbound::ChunkData;
 use crate::player::player::ClientId;
-use crate::{Player, PlayerExtension};
+use crate::{Player, PlayerExtension, WorldExtension};
 use glam::DVec3;
-use std::collections::HashSet;
+use std::cell::UnsafeCell;
+use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
 
 pub struct ChunkSection {
     solid_block_amount: u16,
     data: Box<[u16; 4096]>,
 }
-pub struct Chunk {
+pub struct Chunk<W : WorldExtension> {
     pub chunk_sections: [Option<ChunkSection>; 16],
     pub packet_buffer: PacketBuffer,
 
-    pub players: HashSet<ClientId>,
+    pub players: HashMap<ClientId, Rc<UnsafeCell<Player<W::Player>>>>,
     pub entities: HashSet<EntityId>,
 
     // contains the chunk data packet,
@@ -26,13 +28,13 @@ pub struct Chunk {
     dirty: bool,
 }
 
-impl Chunk {
+impl<W : WorldExtension> Chunk<W> {
 
     pub fn new() -> Self {
         Self {
             chunk_sections: [const { None }; 16],
             packet_buffer: PacketBuffer::new(),
-            players: HashSet::new(),
+            players: HashMap::new(),
             entities: HashSet::new(),
 
             cached_chunk_data: PacketBuffer::new(),
@@ -131,9 +133,9 @@ impl Chunk {
         into.copy_from(&self.cached_chunk_data);
     }
 
-    pub fn insert_player(&mut self, client_id: ClientId) {
-        debug_assert!(!self.players.contains(&client_id), "player already in chunk");
-        self.players.insert(client_id);
+    pub fn insert_player(&mut self, client_id: ClientId, player: Rc<UnsafeCell<Player<W::Player>>>) {
+        debug_assert!(!self.players.contains_key(&client_id), "player already in chunk");
+        self.players.insert(client_id, player);
     }
 
     pub fn insert_entity(&mut self, entity_id: EntityId) {
@@ -142,7 +144,7 @@ impl Chunk {
     }
 
     pub fn remove_player(&mut self, client_id: ClientId) {
-        debug_assert!(self.players.contains(&client_id), "player was never in this chunk");
+        debug_assert!(self.players.contains_key(&client_id), "player was never in this chunk");
         self.players.remove(&client_id);
     }
 

server/src/world/chunk/chunk_grid.rs

@@ -1,14 +1,15 @@
 use crate::block::blocks::Block;
 use crate::network::protocol::play::clientbound::{BlockChange, ChunkData};
 use crate::world::chunk::chunk::Chunk;
+use crate::WorldExtension;
 use glam::{ivec3, IVec3};
 use std::cmp::{max, min};
 
 /// Chunk grid
 ///
 /// Stores a square grid of chunks, based on the provided size.
-pub struct ChunkGrid {
-    pub chunks: Vec<Chunk>,
+pub struct ChunkGrid<W : WorldExtension> {
+    pub chunks: Vec<Chunk<W>>,
     pub size: usize,
 
     index_offset_x: usize,
@@ -21,9 +22,9 @@ pub enum ChunkDiff {
     Old,
 }
 
-impl ChunkGrid {
+impl<W : WorldExtension> ChunkGrid<W> {
 
-    pub fn new(size: usize, offset_x: usize, offset_z: usize) -> ChunkGrid {
+    pub fn new(size: usize, offset_x: usize, offset_z: usize) -> Self {
         let mut chunks = Vec::with_capacity(size * size);
         for _ in 0..size * size {
             chunks.push(Chunk::new());
@@ -78,7 +79,7 @@ impl ChunkGrid {
     }
 
     /// returns the chunk at the x and z coordinates provided, none if no chunk is present
-    pub fn get_chunk(&self, chunk_x: i32, chunk_z: i32) -> Option<&Chunk> {
+    pub fn get_chunk(&self, chunk_x: i32, chunk_z: i32) -> Option<&Chunk<W>> {
         let size = self.size as i32;
         let x = chunk_x + self.index_offset_x as i32;
         let z = chunk_z + self.index_offset_z as i32;
@@ -88,7 +89,7 @@ impl ChunkGrid {
         self.chunks.get(z as usize * self.size + x as usize)
     }
 
-    pub fn get_chunk_mut(&mut self, chunk_x: i32, chunk_z: i32) -> Option<&mut Chunk> {
+    pub fn get_chunk_mut(&mut self, chunk_x: i32, chunk_z: i32) -> Option<&mut Chunk<W>> {
         let size = self.size as i32;
         let x = chunk_x + self.index_offset_x as i32;
         let z = chunk_z + self.index_offset_z as i32;
@@ -105,7 +106,7 @@ impl ChunkGrid {
         view_distance: i32,
         mut callback: F,
     ) where
-        F: FnMut(&mut Chunk, i32, i32)
+        F: FnMut(&mut Chunk<W>, i32, i32)
     {
         let min_x = max(chunk_x - view_distance + self.index_offset_x as i32, 0);
         let min_z = max(chunk_z - view_distance + self.index_offset_z as i32, 0);
@@ -147,19 +148,18 @@ impl ChunkGrid {
             for z in min_z..=max_z {
                 let in_old_range =
                     x >= old_min_x && x <= old_max_x &&
-                        z >= old_min_z && z <= old_max_z;
+                    z >= old_min_z && z <= old_max_z;
 
                 if !in_old_range {
                     callback(x - self.index_offset_x as i32, z - self.index_offset_z as i32, ChunkDiff::New);
                 }
             }
         }
-
         for x in old_min_x..=old_max_x {
             for z in old_min_z..=old_max_z {
                 let in_new_range =
                     x >= min_x && x <= max_x &&
-                        z >= min_z && z <= max_z;
+                    z >= min_z && z <= max_z;
 
                 if !in_new_range {
                     callback(x - self.index_offset_x as i32, z - self.index_offset_z as i32, ChunkDiff::Old);
@@ -173,15 +173,15 @@ impl ChunkGrid {
             self.set_block_at(block, x, y, z)
         })
     }
+}
 
-    pub fn get_unload_chunk_packet(chunk_x: i32, chunk_z: i32) -> ChunkData {
-        ChunkData {
-            chunk_x,
-            chunk_z,
-            is_new_chunk: true,
-            bitmask: 0,
-            data: vec![],
-        }
+pub fn get_unload_chunk_packet(chunk_x: i32, chunk_z: i32) -> ChunkData {
+    ChunkData {
+        chunk_x,
+        chunk_z,
+        is_new_chunk: true,
+        bitmask: 0,
+        data: vec![],
     }
 }
 

server/src/world/world.rs

@@ -12,8 +12,10 @@ use crate::world::chunk::get_chunk_position;
 use enumset::EnumSet;
 use glam::{DVec3, Vec3};
 use slotmap::SecondaryMap;
+use std::cell::UnsafeCell;
 use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
 use tokio::sync::mpsc::UnboundedSender;
 
 pub const VIEW_DISTANCE: i32 = 6;
@@ -29,15 +31,16 @@ pub trait WorldExtension: Sized {
 pub struct World<W: WorldExtension> {
     pub network_tx: UnboundedSender<NetworkThreadMessage>,
 
-    pub players: Vec<Player<W::Player>>,
+    // maybe go back to only map for players?
+    pub players: Vec<Rc<UnsafeCell<Player<W::Player>>>>,
     pub player_map: SecondaryMap<ClientId, usize>,
 
     entity_id: i32,
     pub entities: Vec<Entity<W>>,
     pub entity_map: HashMap<EntityId, usize>,
     entities_for_removal: Vec<EntityId>,
 
-    pub chunk_grid: ChunkGrid,
+    pub chunk_grid: ChunkGrid<W>,
 
     pub extension: W,
 }
@@ -73,9 +76,9 @@ impl<W: WorldExtension> World<W> {
         gamemode: Gamemode,
         extension: W::Player,
     ) -> &mut Player<W::Player> {
-        let entity_id = self.new_entity_id();
 
-        let mut player = Player::new(
+        let entity_id = self.new_entity_id();
+        let player_rc = Rc::new(UnsafeCell::new(Player::new(
             self,
             profile,
             client_id,
@@ -85,7 +88,8 @@ impl<W: WorldExtension> World<W> {
             pitch,
             gamemode,
             extension
-        );
+        )));
+        let mut player = unsafe { &mut *player_rc.get() };
 
         player.write_packet(&JoinGame {
             entity_id: player.entity_id,
@@ -99,7 +103,7 @@ impl<W: WorldExtension> World<W> {
 
         let (chunk_x, chunk_z) = get_chunk_position(player.position);
         if let Some(chunk) = self.chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
-            chunk.insert_player(client_id)
+            chunk.insert_player(client_id, player_rc.clone())
         }
 
         self.chunk_grid
@@ -134,9 +138,10 @@ impl<W: WorldExtension> World<W> {
         player.flush_packets();
 
         let index = self.players.len();
-        self.players.push(player);
+        self.players.push(player_rc);
         self.player_map.insert(client_id, index);
-        &mut self.players[index]
+        // should always be present
+        unsafe { self.players[index].get().as_mut().unwrap() }
     }
 
     pub fn spawn_entity<A: EntityAppearance<W> + 'static, E: EntityExtension<W> + 'static>(
@@ -158,7 +163,8 @@ impl<W: WorldExtension> World<W> {
             self.chunk_grid
                 .for_each_in_view(chunk_x, chunk_z, VIEW_DISTANCE, |chunk, _, _| {
                     if chunk.has_players() {
-                        for player in self.players.iter_mut().filter(|p| chunk.players.contains(&p.client_id)) {
+                        for (_, player_rc) in chunk.players.iter() {
+                            let player = unsafe { &mut *player_rc.get() };
                             entity.enter_view(player)
                         }
                     }
@@ -194,11 +200,12 @@ impl<W: WorldExtension> World<W> {
         if let Some(index) = self.player_map.remove(client_id) {
             let last_index = self.players.len() - 1;
 
-            let mut player = self.players.swap_remove(index);
-            W::on_player_leave(self, &mut player);
+            let player_rc = self.players.swap_remove(index);
+            let player = unsafe { player_rc.get().as_mut().unwrap() };
+            W::on_player_leave(self, player);
 
             if last_index != index {
-                let moved_id = self.players[index].client_id;
+                let moved_id = unsafe { self.players[index].get().as_ref().unwrap() }.client_id;
                 self.player_map.insert(moved_id, index);
             }
 
@@ -207,6 +214,8 @@ impl<W: WorldExtension> World<W> {
             if let Some(chunk) = self.chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
                 chunk.remove_player(client_id)
             }
+
+            assert_eq!(Rc::strong_count(&player_rc), 1, "player leaked")
         }
     }
 
@@ -239,6 +248,7 @@ impl<W: WorldExtension> World<W> {
         }
 
         for player in self.players.iter_mut() {
+            let player = unsafe { player.get().as_mut().unwrap() };
             player.write_packet(&packet_destroy_entities);
             player.tick();
         }
@@ -248,6 +258,16 @@ impl<W: WorldExtension> World<W> {
         }
     }
 
+    pub fn add_player_to_chunk(&mut self, client_id: ClientId, chunk_x: i32, chunk_z: i32) {
+        if let Some(index) = self.player_map.get(client_id) {
+            let player = self.players[*index].clone();
+
+            if let Some(chunk) = self.chunk_grid.get_chunk_mut(chunk_x, chunk_z) {
+                chunk.insert_player(client_id, player)
+            }
+        }
+    }
+
     pub fn process_event(&mut self, event: MainThreadMessage) {
         match event {
             MainThreadMessage::NewPlayer { client_id, profile } => {
@@ -258,7 +278,8 @@ impl<W: WorldExtension> World<W> {
             }
             MainThreadMessage::PacketReceived { client_id, packet } => {
                 if let Some(index) = self.player_map.get(client_id) {
-                    let player = &mut self.players[*index];
+                    let player_rc = &mut self.players[*index];
+                    let player = unsafe { &mut *player_rc.get() };
                     packet.process(player)
                 }
             }

src/dungeon/door/door.rs

@@ -59,7 +59,7 @@ impl Door {
 
     pub fn load_into_world(
         &self,
-        chunk_grid: &mut ChunkGrid,
+        chunk_grid: &mut ChunkGrid<Dungeon>,
         door_blocks: &DeterministicHashMap<DoorType, Vec<Vec<Block>>>
     ) {
         // Area to fill with air