random cleanup

Author: SubAt0m1c

src/dungeon/dungeon.rs

@@ -448,14 +448,12 @@ impl Dungeon {
         let entry = self.room_grid.get(grid_x + (grid_z * 6));
         entry.and_then(|e| *e)
     }
-
+    
     pub fn get_player_room(&mut self, player: &Player) -> Option<usize> {
-        let room =         self.get_room_at(
+        self.get_room_at(
             player.position.x as i32,
             player.position.z as i32
-        );
-        println!("{:?}", room);
-        room
+        )
     }
 
     pub fn start_dungeon(&mut self) {
@@ -512,16 +510,16 @@ impl Dungeon {
             DungeonState::Started { current_ticks } => {
                 *current_ticks += 1;
                 for (_, player) in &mut server.world.players  {
-                    if let Some(room_index) = server.dungeon.get_player_room(player) {
-                        let room = server.dungeon.rooms.get_mut(room_index).unwrap();
+                    if let Some(room_index) = self.get_player_room(player) {
+                        let room = self.rooms.get_mut(room_index).unwrap();
 
                         for crusher in room.crushers.iter_mut() {
                             crusher.tick(player);
                         }
 
                         if !room.entered {
                             room.entered = true;
-                            DungeonMap::draw_room(self, room_index);
+                            self.map.draw_room(&self.rooms, &self.doors, room_index);
 
                             // this needs to happen once a tick,
                             // but currently the ticking stuff is a mess

src/dungeon/map.rs

@@ -1,5 +1,4 @@
-use crate::dungeon::door::DoorType;
-use crate::dungeon::dungeon::Dungeon;
+use crate::dungeon::door::{Door, DoorType};
 use crate::dungeon::room::room::Room;
 use crate::dungeon::room::room_data::{RoomData, RoomShape, RoomType::*};
 use crate::server::block::block_parameter::Axis;
@@ -123,21 +122,20 @@ impl DungeonMap {
         }
     }
 
-    pub fn draw_room(dungeon: &mut Dungeon, room: usize) {
-        let room = &dungeon.rooms[room];
-        let map = &mut dungeon.map;
+    pub fn draw_room(&mut self, rooms: &[Room], doors: &[Door], room_index: usize) {
+        let room = &rooms[room_index];
         let color = get_room_color(&room.room_data);
 
         for segment in room.segments.iter() {
             let x = segment.x * 20;
             let y = segment.z * 20;
 
-            map.fill_px(x, y, 16, 16, color);
+            self.fill_px(x, y, 16, 16, color);
             if room.segments.iter().find(|seg| seg.x == segment.x + 1 && seg.z == segment.z).is_some() {
-                map.fill_px(x + 16, y, 4, 16, color);
+                self.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() {
-                map.fill_px(x, y + 16, 16, 4, color);
+                self.fill_px(x, y + 16, 16, 4, color);
             }
 
             for (index, neighbour) in segment.neighbours.iter().enumerate() {
@@ -147,9 +145,7 @@ impl DungeonMap {
 
                 let (neighbour_room, door) = {
                     let neighbour = neighbour.as_ref().unwrap();
-                    let room = dungeon.rooms.get(neighbour.room_index).unwrap();
-                    let door = dungeon.doors.get(neighbour.door_index).unwrap();
-                    (room, door)
+                    (&rooms[neighbour.room_index], &doors[neighbour.door_index])
                 };
 
                 let mut x = segment.x * 20 + 6;
@@ -170,15 +166,15 @@ impl DungeonMap {
                 };
 
                 if neighbour_room.entered {
-                    let color = get_door_color(room, &*neighbour_room);
-                    map.fill_px(x, y, width, height, color);
+                    let color = get_door_color(room, neighbour_room);
+                    self.fill_px(x, y, width, height, color);
                 } else {
                     let color = match door.door_type {
                         DoorType::WITHER => BLACK,
                         DoorType::BLOOD => RED,
                         _ => GRAY,
                     };
-                    map.fill_px(x, y, width, height, color);
+                    self.fill_px(x, y, width, height, color);
 
                     let mut x = segment.x * 20;
                     let mut y = segment.z * 20;
@@ -191,28 +187,28 @@ impl DungeonMap {
                         _ => unreachable!()
                     }
 
-                    map.fill_px(x ,y, 16, 16, GRAY);
+                    self.fill_px(x ,y, 16, 16, GRAY);
 
                     for (qx, qy) in QUESTION_MARK_POSITIONS {
-                        map.set_px(x + qx + 5, y + qy + 5, BLACK);
+                        self.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;
-            map.fill_px(x, y, 4, 4, color)
+            self.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 {
-                map.set_px(x + cx, y + cy, GREEN)
+                self.set_px(x + cx, y + cy, GREEN)
             }
         }
     }

src/dungeon/room/room.rs

@@ -18,9 +18,6 @@ pub struct RoomSegment {
 
 #[derive(Debug)]
 pub struct RoomNeighbour {
-    // pub door: Rc<RefCell<Door>>,
-    // pub room: Rc<RefCell<Room>>,
-    
     pub door_index: usize,
     pub room_index: usize,
 }
@@ -162,7 +159,7 @@ impl Room {
         }
     }
 
-    pub fn get_rotation_from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &[Door]) -> Direction {
+    pub fn get_rotation_from_segments(segments: &[RoomSegment], dungeon_doors: &[Door]) -> Direction {
         let unique_x = segments.iter()
             .map(|segment| segment.x)
             .collect::<HashSet<usize>>();