cleaned up iterating over players in world/chunk

Author: Stivais

server/src/player/mod.rs

@@ -1,4 +1,5 @@
 pub mod player;
 pub mod packet_handling;
 pub mod attribute;
-pub mod sidebar;
+pub mod sidebar;
+pub mod player_iterator;

server/src/player/player_iterator.rs

@@ -0,0 +1,35 @@
+use crate::{Player, PlayerExtension};
+use std::cell::UnsafeCell;
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+pub struct PlayerIterator<'a, I, P : PlayerExtension>
+where
+    I: Iterator<Item = Rc<UnsafeCell<Player<P>>>>,
+{
+    iter: I,
+    _marker: PhantomData<&'a mut P>,
+}
+
+impl<'a, I, P : PlayerExtension> PlayerIterator<'a, I, P>
+where
+    I: Iterator<Item = Rc<UnsafeCell<Player<P>>>>,
+{
+    pub fn new(iter: I) -> Self {
+        Self {
+            iter,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, I, P : PlayerExtension> Iterator for PlayerIterator<'a, I, P>
+where
+    I: Iterator<Item = Rc<UnsafeCell<Player<P>>>>,
+{
+    type Item = &'a mut Player<P>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next().map(|rc| unsafe { &mut *rc.get() })
+    }
+}

server/src/world/chunk/chunk.rs

@@ -161,6 +161,10 @@ impl<W : WorldExtension> Chunk<W> {
         !self.entities.is_empty()
     }
 
+    pub fn players(&mut self) -> impl Iterator<Item = &mut Player<W::Player>> {
+        self.players.values().map(|it| unsafe { &mut *it.get() })
+    }
+
     pub fn write_spawn_entities<P : PlayerExtension>(
         &self,
         player: &mut Player<P>

server/src/world/world.rs

@@ -247,8 +247,7 @@ impl<W: WorldExtension> World<W> {
             entity.tick()
         }
 
-        for player in self.players.iter_mut() {
-            let player = unsafe { player.get().as_mut().unwrap() };
+        for player in self.players_mut() {
             player.write_packet(&packet_destroy_entities);
             player.tick();
         }
@@ -291,6 +290,14 @@ impl<W: WorldExtension> World<W> {
             }
         }
     }
+
+    pub fn players(&self) -> impl Iterator<Item = &Player<W::Player>> {
+        self.players.iter().map(|it| unsafe { &*it.get() })
+    }
+    
+    pub fn players_mut(&mut self) -> impl Iterator<Item = &mut Player<W::Player>> {
+        self.players.iter().map(|it| unsafe { &mut *it.get() })
+    }
 }
 
 impl<W: WorldExtension> Deref for World<W> {

src/dungeon/dungeon.rs

@@ -66,8 +66,8 @@ impl WorldExtension for Dungeon {
                     let s = if seconds_remaining == 1 { "" } else { "s" };
                     let str = format!("§aStarting in {} second{}.", seconds_remaining, s);
 
-                    for player_rc in world.players.iter_mut() {
-                        let player = unsafe { &mut *player_rc.get() };
+                    // todo: global packet buffer for these global stuff
+                    for player in world.players_mut() {
                         player.write_packet(&Chat {
                             component: ChatComponent::new(str.clone()),
                             chat_type: 0,
@@ -127,8 +127,7 @@ impl WorldExtension for Dungeon {
                 }
 
                 if let Some(packet) = world.extension.map.get_packet() {
-                    for player_rc in world.players.iter_mut() {
-                        let player = unsafe { &mut *player_rc.get() };
+                    for player in world.players_mut() {
                         player.write_packet(&packet)
                     }
                 }
@@ -195,7 +194,7 @@ impl WorldExtension for Dungeon {
         player.flush_packets()
     }
 
-    fn on_player_leave(world: &mut World<Self>, player: &mut Player<Self::Player>) {
+    fn on_player_leave(_: &mut World<Self>, player: &mut Player<Self::Player>) {
         if let Some((room_rc, _)) = &player.current_room {
             let mut room = room_rc.borrow_mut();
             room.remove_player_ref(player.client_id)
@@ -210,8 +209,7 @@ impl Dungeon {
     }
 
     pub fn start_dungeon(world: &mut World<Self>) {
-        for player_rc in world.players.iter_mut() {
-            let player = unsafe { &mut *player_rc.get() };
+        for player in world.players_mut() {
             if let OpenContainer::Menu(_) = player.get_container() {
                 player.open_container(OpenContainer::None)
             }
@@ -243,16 +241,14 @@ impl Dungeon {
             chat_type: 0,
         };
 
-        for player_rc in world.players.iter_mut() {
-            let player = unsafe { &mut *player_rc.get() };
+        for player in world.players_mut() {
             player.write_packet(&packet)
         }
 
         if is_ready {
             let mut should_start = true;
 
-            for player_rc in world.players.iter() {
-                let player = unsafe { &*player_rc.get() };
+            for player in world.players_mut() {
                 if !player.extension.is_ready {
                     should_start = false
                 }

src/dungeon/dungeon_player.rs

@@ -229,8 +229,7 @@ impl DungeonPlayer {
                 // can't use one outside because of borrow checker
                 let sidebar = &mut player.extension.sidebar;
 
-                for player_rc in world.players.iter() {
-                    let player = unsafe { &*player_rc.get() };
+                for player in world.players() {
                     let color = if player.extension.is_ready { 'a' } else { 'c' };
                     sidebar.push(&format!("§{color}[M] §7{}", player.profile.username));
                 }

src/dungeon/entities/npc.rs

@@ -18,9 +18,9 @@ impl EntityExtension<Dungeon> for InteractableNPC {
             return;
         }
 
-        let player: Option<&Player<DungeonPlayer>> = entity.world().players.iter()
-            // todo custom iter for player to unwrap 
-            .map(|p| unsafe { &*p.get() })
+        let player: Option<&Player<DungeonPlayer>> = entity
+            .world()
+            .players()
             .filter(|p| entity.position.distance(p.position) <= 5.0)
             .min_by(|a, b| {
                 let dist_a = entity.position.distance(a.position);

src/dungeon/room/room.rs

@@ -114,6 +114,10 @@ impl Room {
         self.segments.iter().flat_map(|seg| seg.neighbours.iter().flatten())
     }
 
+    pub fn players(&mut self) -> impl Iterator<Item = &mut Player<DungeonPlayer>> {
+        self.players.values().map(|it| unsafe { &mut *it.get() })
+    }
+
     pub fn get_corner_pos(&self) -> IVec3 {
         Room::get_corner_pos_from(&self.segments, &self.rotation, &self.data)
     }
@@ -168,7 +172,7 @@ impl Room {
 
     pub fn remove_player_ref(&mut self, client_id: ClientId) {
         debug_assert!(self.players.contains_key(&client_id), "player wasn't in the room");
-        let segment = self.players.remove(&client_id).unwrap();
+        self.players.remove(&client_id);
 
         // if let Some(segment) = segment {
         //     self.segments[segment].player_ref_count -= 1;