Refactored dungeon room storage to not use rc<refcell<T>>

SubAt0m1c · SubAt0m1c · commit c86fd2c78ce7 · 2025-08-29T18:34:00.000-04:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,4 +24,4 @@ opt-level = 3
 
 [profile.release]
 codegen-units = 1
-lto = "thin"
+lto = "thin"
diff --git a/src/dungeon/crushers.rs b/src/dungeon/crushers.rs
@@ -5,6 +5,7 @@ use crate::server::utils::direction::Direction;
 use crate::server::world::World;
 use serde_json::Value;
 
+#[derive(Debug)]
 pub struct Crusher {
     pub block_pos: BlockPos,
     pub direction: Direction,
diff --git a/src/dungeon/dungeon.rs b/src/dungeon/dungeon.rs
diff --git a/src/dungeon/map.rs b/src/dungeon/map.rs
@@ -1,4 +1,5 @@
 use crate::dungeon::door::DoorType;
+use crate::dungeon::dungeon::Dungeon;
 use crate::dungeon::room::room::Room;
 use crate::dungeon::room::room_data::{RoomData, RoomShape, RoomType::*};
 use crate::server::block::block_parameter::Axis;
@@ -121,60 +122,63 @@ impl DungeonMap {
             }
         }
     }
-
-    pub fn draw_room(&mut self, room: &Room) {
-
+    
+    pub fn draw_room(dungeon: &mut Dungeon, room: usize) {
+        let room = &dungeon.rooms[room];
+        let map = &mut dungeon.map;
         let color = get_room_color(&room.room_data);
-
+        
         for segment in room.segments.iter() {
             let x = segment.x * 20;
             let y = segment.z * 20;
-
-            self.fill_px(x, y, 16, 16, color);
-
+            
+            map.fill_px(x, y, 16, 16, color);
             if room.segments.iter().find(|seg| seg.x == segment.x + 1 && seg.z == segment.z).is_some() {
-                self.fill_px(x + 16, y, 4, 16, color);
+                map.fill_px(x + 16, y, 4, 16, color);
             }
             if room.segments.iter().find(|seg| seg.x == segment.x && seg.z == segment.z + 1).is_some() {
-                self.fill_px(x, y + 16, 16, 4, color);
+                map.fill_px(x, y + 16, 16, 4, color);
             }
-
+            
             for (index, neighbour) in segment.neighbours.iter().enumerate() {
                 if neighbour.is_none() {
                     continue;
                 }
-                let (neighbour, door) = {
+                
+                let (neighbour_room, door) = {
                     let neighbour = neighbour.as_ref().unwrap();
-                    (neighbour.room.borrow(), neighbour.door.borrow())
+                    let room = dungeon.rooms.get(neighbour.room_index).unwrap();
+                    let door = dungeon.doors.get(neighbour.door_index).unwrap();
+                    (room, door)
                 };
-
+                
                 let mut x = segment.x * 20 + 6;
                 let mut y = segment.z * 20 + 6;
-
+                
                 match index {
                     0 => y -= 10,
                     1 => x += 10,
                     2 => y += 10,
                     3 => x -= 10,
                     _ => unreachable!()
                 }
-
+                
                 let (width, height) = match door.direction {
                     Axis::X => (4, 5),
                     Axis::Z => (5, 4),
                     _ => unreachable!()
                 };
-
-                if neighbour.entered {
-                    let color = get_door_color(room, &*neighbour);
-                    self.fill_px(x, y, width, height, color);
+                
+                if neighbour_room.entered {
+                    let color = get_door_color(room, &*neighbour_room);
+                    map.fill_px(x, y, width, height, color);
                 } else {
                     let color = match door.door_type {
                         DoorType::WITHER => BLACK,
                         DoorType::BLOOD => RED,
                         _ => GRAY,
                     };
-                    self.fill_px(x, y, width, height, color);
+                    map.fill_px(x, y, width, height, color);
 
                     let mut x = segment.x * 20;
                     let mut y = segment.z * 20;
@@ -187,28 +191,28 @@ impl DungeonMap {
                         _ => unreachable!()
                     }
 
-                    self.fill_px(x ,y, 16, 16, GRAY);
+                    map.fill_px(x ,y, 16, 16, GRAY);
 
                     for (qx, qy) in QUESTION_MARK_POSITIONS {
-                        self.set_px(x + qx + 5, y + qy + 5, BLACK);
+                        map.set_px(x + qx + 5, y + qy + 5, BLACK);
                     }
                 }
-            }
+            }    
         }
-
+        
         // fill in hole
         if room.room_data.shape == RoomShape::TwoByTwo {
             let x = room.segments[0].x * 20 + 16;
             let y = room.segments[0].z * 20 + 16;
-            self.fill_px(x, y, 4, 4, color)
+            map.fill_px(x, y, 4, 4, color)
         }
         
         {
             let x = room.segments[0].x * 20 + 4;
             let y = room.segments[0].z * 20 + 4;
 
             for (cx, cy) in CHECKMARK_POSITIONS {
-                self.set_px(x + cx, y + cy, GREEN)
+                map.set_px(x + cx, y + cy, GREEN)
             }
         }
     }
diff --git a/src/dungeon/room/room.rs b/src/dungeon/room/room.rs
@@ -7,21 +7,25 @@ use crate::server::block::blocks::Blocks;
 use crate::server::block::rotatable::Rotatable;
 use crate::server::utils::direction::Direction;
 use crate::server::world::World;
-use std::cell::RefCell;
 use std::collections::HashSet;
-use std::rc::Rc;
 
+#[derive(Debug)]
 pub struct RoomSegment {
     pub x: usize,
     pub z: usize,
     pub neighbours: [Option<RoomNeighbour>; 4]
 }
 
+#[derive(Debug)]
 pub struct RoomNeighbour {
-    pub door: Rc<RefCell<Door>>,
-    pub room: Rc<RefCell<Room>>,
+    // pub door: Rc<RefCell<Door>>,
+    // pub room: Rc<RefCell<Room>>,
+    
+    pub door_index: usize,
+    pub room_index: usize,
 }
 
+#[derive(Debug)]
 pub struct Room {
     pub segments: Vec<RoomSegment>,
     pub room_data: RoomData,
@@ -37,7 +41,7 @@ impl Room {
 
     pub fn new(
         mut segments: Vec<RoomSegment>,
-        dungeon_doors: &Vec<Door>,
+        dungeon_doors: &[Door],
         room_data: RoomData
     ) -> Room {
         // Sort room segments by z and then x
@@ -87,7 +91,7 @@ impl Room {
         Room::get_corner_pos_from(&self.segments, &self.rotation, &self.room_data)
     }
 
-    pub fn get_corner_pos_from(segments: &Vec<RoomSegment>, rotation: &Direction, room_data: &RoomData) -> BlockPos {
+    pub fn get_corner_pos_from(segments: &[RoomSegment], rotation: &Direction, room_data: &RoomData) -> BlockPos {
         let min_x = segments.iter().min_by(|a, b| a.x.cmp(&b.x)).unwrap().x;
         let min_z = segments.iter().min_by(|a, b| a.z.cmp(&b.z)).unwrap().z;
 
@@ -108,7 +112,7 @@ impl Room {
         self.tick_amount += 1;
     }
 
-    pub fn get_1x1_shape_and_type(segments: &Vec<RoomSegment>, dungeon_doors: &Vec<Door>) -> (RoomShape, Direction) {
+    pub fn get_1x1_shape_and_type(segments: &[RoomSegment], dungeon_doors: &[Door]) -> (RoomShape, Direction) {
         let center_x = segments[0].x as i32 * 32 + 15 + DUNGEON_ORIGIN.0;
         let center_z = segments[0].z as i32 * 32 + 15 + DUNGEON_ORIGIN.1;
 
@@ -158,7 +162,7 @@ impl Room {
         }
     }
 
-    pub fn get_rotation_from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &Vec<Door>) -> Direction {
+    pub fn get_rotation_from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &[Door]) -> Direction {
         let unique_x = segments.iter()
             .map(|segment| segment.x)
             .collect::<HashSet<usize>>();
diff --git a/src/dungeon/room/room_data.rs b/src/dungeon/room/room_data.rs
@@ -42,7 +42,7 @@ impl RoomShape {
         }
     }
 
-    pub fn from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &Vec<Door>) -> RoomShape {
+    pub fn from_segments(segments: &[RoomSegment], dungeon_doors: &[Door]) -> RoomShape {
 
         let unique_x = segments.iter()
             .map(|segment| segment.x)
diff --git a/src/main.rs b/src/main.rs
@@ -130,7 +130,7 @@ async fn main() -> Result<()> {
     println!("Rng Seed: {}", rng_seed);
     SeededRng::set_seed(rng_seed);
 
-    let dungeon = Dungeon::from_string(dungeon_str, &room_data_storage)?;
+    let dungeon = Dungeon::from_str(dungeon_str, &room_data_storage)?;
     let mut server = Server::initialize_with_dungeon(network_tx, dungeon);
     server.world.server = &mut server;
     server.dungeon.server = &mut server;
@@ -145,7 +145,6 @@ async fn main() -> Result<()> {
     let dungeon = &server.dungeon;
 
     for room in &dungeon.rooms {
-        let room = room.borrow();
         // println!("Room: {:?} type={:?} rotation={:?} shape={:?} corner={:?}", room.segments, room.room_data.room_type, room.rotation, room.room_data.shape, room.get_corner_pos());
         room.load_into_world(&mut server.world);
 
@@ -192,7 +191,7 @@ async fn main() -> Result<()> {
     }
 
     for door in &dungeon.doors {
-        door.borrow().load_into_world(&mut server.world, &door_type_blocks);
+        door.load_into_world(&mut server.world, &door_type_blocks);
     }
 
     // let zombie_spawn_pos = DVec3 {
@@ -356,8 +355,8 @@ async fn main() -> Result<()> {
                 format!("{} {}{}", SKYBLOCK_MONTHS[month], day_of_month, suffix)
             };
 
-            let room_id = if let Some(room) = player.server_mut().dungeon.get_player_room(player) {
-                &room.borrow().room_data.id
+            let room_id = if let Some(room) = server.dungeon.get_player_room(player) {
+                &server.dungeon.rooms[room].room_data.id
             } else {
                 ""
             };
diff --git a/src/server/block/block_interact_action.rs b/src/server/block/block_interact_action.rs
@@ -39,7 +39,7 @@ impl BlockInteractAction {
 
                 if let DungeonState::Started { .. } = dungeon.state {
                     // todo check if player has a key
-                    let door = &dungeon.doors[*id].borrow();
+                    let door = &dungeon.doors[*id];
                     door.open_door(world);
                 }
             }
diff --git a/src/server/server.rs b/src/server/server.rs
@@ -1,7 +1,8 @@
 use crate::dungeon::dungeon::Dungeon;
 use crate::net::internal_packets::{MainThreadMessage, NetworkThreadMessage};
 use crate::net::packets::packet::ProcessPacket;
-use crate::net::protocol::play::clientbound::{AddEffect, EntityProperties, JoinGame, PlayerAbilities, PlayerListHeaderFooter, PositionLook};
+use crate::net::packets::packet_serialize::PacketSerializable;
+use crate::net::protocol::play::clientbound::{AddEffect, CustomPayload, EntityProperties, JoinGame, PlayerAbilities, PlayerListHeaderFooter, PositionLook};
 use crate::net::var_int::VarInt;
 use crate::server::items::Item;
 use crate::server::player::attribute::{Attribute, AttributeMap, AttributeModifier};
@@ -103,7 +104,7 @@ impl Server {
                 
                 player.sidebar.write_init_packets(&mut player.packet_buffer);
 
-                // player.send_packet(self.world.player_info.new_packet())?;
+                // player.write_packet(&self.world.player_info.new_packet());
 
                 player.write_packet(&PlayerListHeaderFooter {
                     header: header(),
@@ -172,6 +173,14 @@ impl Server {
                     walk_speed: playerspeed,
                 });
                 
+                // let mut buf = Vec::new();
+                // "hypixel".write(&mut buf);
+                
+                // player.write_packet(&CustomPayload {
+                //     channel: "MC|Brand".into(),
+                //     data: &buf,
+                // });
+                
                 player.flush_packets();
 
                 self.world.players.insert(client_id, player);

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl RoomShape {`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`- pub fn from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &Vec<Door>) -> RoomShape {`
	`45`	`+ pub fn from_segments(segments: &[RoomSegment], dungeon_doors: &[Door]) -> RoomShape {`
`46`	`46`
`47`	`47`	`let unique_x = segments.iter()`
`48`	`48`	`.map(\|segment\| segment.x)`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl BlockInteractAction {`
`39`	`39`
`40`	`40`	`if let DungeonState::Started { .. } = dungeon.state {`
`41`	`41`	`// todo check if player has a key`
`42`		`- let door = &dungeon.doors[*id].borrow();`
	`42`	`+ let door = &dungeon.doors[*id];`
`43`	`43`	`door.open_door(world);`
`44`	`44`	`}`
`45`	`45`	`}`