Merge remote-tracking branch 'origin/main'

Author: Stivais

Cargo.toml

@@ -24,4 +24,4 @@ opt-level = 3
 
 [profile.release]
 codegen-units = 1
-lto = "thin"
+lto = "thin"

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,

src/dungeon/dungeon.rs

@@ -1,4 +1,4 @@
-use crate::dungeon::door::DoorType;
+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;
@@ -121,52 +121,52 @@ impl DungeonMap {
             }
         }
     }
-
-    pub fn draw_room(&mut self, room: &Room) {
-
+    
+    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;
-
+            
             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() {
                 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() {
                 self.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())
+                    (&rooms[neighbour.room_index], &doors[neighbour.door_index])
                 };
-
+                
                 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);
+                
+                if neighbour_room.entered {
+                    let color = get_door_color(room, neighbour_room);
                     self.fill_px(x, y, width, height, color);
                 } else {
                     let color = match door.door_type {
@@ -195,7 +195,7 @@ impl DungeonMap {
                 }
             }
         }
-
+        
         // fill in hole
         if room.room_data.shape == RoomShape::TwoByTwo {
             let x = room.segments[0].x * 20 + 16;

src/dungeon/map.rs

@@ -7,21 +7,22 @@ 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_index: usize,
+    pub room_index: usize,
 }
 
+#[derive(Debug)]
 pub struct Room {
     pub segments: Vec<RoomSegment>,
     pub room_data: RoomData,
@@ -37,7 +38,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 +88,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 +109,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 +159,7 @@ impl Room {
         }
     }
 
-    pub fn get_rotation_from_segments(segments: &Vec<RoomSegment>, dungeon_doors: &Vec<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>>();

src/dungeon/room/room.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)

src/dungeon/room/room_data.rs

@@ -31,7 +31,7 @@ use crate::server::utils::dvec3::DVec3;
 use crate::server::world::VIEW_DISTANCE;
 use crate::utils::hasher::deterministic_hasher::DeterministicHashMap;
 use crate::utils::seeded_rng::SeededRng;
-use anyhow::Result;
+use anyhow::{bail, Result};
 use chrono::Local;
 use include_dir::include_dir;
 use indoc::formatdoc;
@@ -41,6 +41,7 @@ use std::env;
 use std::ops::Add;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tokio::sync::mpsc::unbounded_channel;
+use tokio::sync::mpsc::error::TryRecvError;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -130,7 +131,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 +146,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);
 
@@ -166,7 +166,7 @@ async fn main() -> Result<()> {
 
             // test
             pub struct MortImpl;
-            
+
             impl EntityImpl for MortImpl {
                 fn tick(&mut self, _: &mut Entity, _: &mut PacketBuffer) {
                     // rotate
@@ -178,7 +178,7 @@ async fn main() -> Result<()> {
                     player.open_ui(UI::MortReadyUpMenu);
                 }
             }
-            
+
             let id = server.world.spawn_entity(
                 room.get_world_block_pos(&BlockPos { x: 15, y: 69, z: 4 })
                     .as_dvec3()
@@ -192,7 +192,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 {
@@ -226,10 +226,14 @@ async fn main() -> Result<()> {
         tick_interval.tick().await;
         // let start = std::time::Instant::now();
 
-        while let Ok(message) = main_rx.try_recv() {
-            server.process_event(message).unwrap_or_else(|err| eprintln!("Error processing event: {err}"));
+        loop {
+            match main_rx.try_recv() {
+                Ok(message) => server.process_event(message).unwrap_or_else(|err| eprintln!("Error processing event: {err}")),
+                Err(TryRecvError::Empty) => break,
+                Err(TryRecvError::Disconnected) => bail!("Network thread dropped its reciever."),
+            }
         }
-
+        
         server.dungeon.tick()?;
         server.world.tick()?;
 
@@ -356,8 +360,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 {
                 ""
             };

src/main.rs

@@ -29,6 +29,9 @@ impl Client {
     }
 }
 
+// main thread tx errors can be ignored since the network/client threads will close eachother properly regardless of client status, 
+// which will in turn close the client handlers.
+
 pub async fn handle_client(
     client_id: ClientId,
     mut socket: TcpStream,

src/net/client.rs

@@ -19,6 +19,7 @@ pub enum NetworkThreadMessage {
     /// Disconnects the client from the server.
     /// This sends a close handler message to the client's handler.
     /// It should be sent after the vanilla disconnect packet is sent.
+    /// the main thread should wait for a ClientDisconnected response to handle actually removing the player.
     DisconnectClient {
         client_id: ClientId,
     },
@@ -41,11 +42,8 @@ pub enum MainThreadMessage {
         profile: GameProfile,
     },
 
+    /// sent to the main thread when a client is removed for any reason, even reasons caused by the main thread.
     ClientDisconnected {
         client_id: ClientId,
     },
-
-    Abort {
-        reason: String,
-    },
 }

src/net/internal_packets.rs

@@ -7,24 +7,22 @@ use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use crate::net::internal_packets::{ClientHandlerMessage, MainThreadMessage, NetworkThreadMessage};
 use crate::server::player::player::ClientId;
 
-/// runs the network thread. It is very important that nothing here panics without alerting the main thread.
-/// if a handle_client panics, it should send a disconnect player to the main thread. (however we dont have anything that could panic there atm)
+type ClientMap = HashMap<ClientId, UnboundedSender<ClientHandlerMessage>>;
+
 pub async fn run_network_thread(
     mut network_rx: UnboundedReceiver<NetworkThreadMessage>,
     network_tx: UnboundedSender<NetworkThreadMessage>,
     main_tx: UnboundedSender<MainThreadMessage>,
 ) {
-    let listener = TcpListener::bind("127.0.0.1:4972").await.unwrap_or_else(|err| {
-        let _ = main_tx.send(MainThreadMessage::Abort { reason: format!("TCP failed to bind: {}", err) });
-        panic!("{}", err)
-    });
+    let listener = TcpListener::bind("127.0.0.1:4972").await.unwrap();
     println!("Network thread listening on 127.0.0.1:4972");
 
-    let mut clients: HashMap<ClientId, UnboundedSender<ClientHandlerMessage>> = HashMap::new();
+    let mut clients: ClientMap = HashMap::new();
     let mut client_id_counter: ClientId = 1;
 
     loop {
         tokio::select! {
+            // a client failing to connect here is recoverable and doesnt really do anything, so we can just ignore it.
             Ok((socket, _)) = listener.accept() => {
                 let client_id: ClientId = client_id_counter;
                 client_id_counter += 1;
@@ -35,28 +33,39 @@ pub async fn run_network_thread(
                 tokio::spawn(handle_client(client_id, socket, client_rx, main_tx.clone(), network_tx.clone()));
             }
 
+            // this can never be none since this function owns a network_tx.
             Some(msg) = network_rx.recv() => {
-                match msg {
+                // we can just discard main thread -> network thread messages with a disconnected client_id
+                // as the main thread either already has or will be be informed shortly of this issue
+                match msg { 
                     NetworkThreadMessage::SendPackets { client_id, buffer } => {
                         if let Some(client_tx) = clients.get(&client_id) {
-                            let _ = client_tx.send(ClientHandlerMessage::Send(buffer));
+                            if let Err(e) = client_tx.send(ClientHandlerMessage::Send(buffer)) {
+                                eprintln!("Client {} handler dropped its reciever: {}", client_id, e);
+                                disconnect_client(client_id, &main_tx, &mut clients);
+                            }
                         }
                     }
-
+            
                     NetworkThreadMessage::DisconnectClient { client_id } => {
                         if let Some(client_tx) = clients.get(&client_id) {
-                            let _ = client_tx.send(ClientHandlerMessage::CloseHandler);
-                        } else {
-                            eprintln!("Attempted to disconnect nonexistent client {}", client_id);
+                            if let Err(e) = client_tx.send(ClientHandlerMessage::CloseHandler) {
+                                eprintln!("Client {} handler dropped its reciever: {}", client_id, e);
+                                disconnect_client(client_id, &main_tx, &mut clients);
+                            }
                         }
                     }
-
+            
                     NetworkThreadMessage::ConnectionClosed { client_id } => {
-                        let _ = main_tx.send(MainThreadMessage::ClientDisconnected { client_id });
-                        clients.remove(&client_id);
+                        disconnect_client(client_id, &main_tx, &mut clients);
                     }
                 }
             }
         }
     }
+}
+
+fn disconnect_client(client_id: ClientId, main_tx: &UnboundedSender<MainThreadMessage>, clients: &mut ClientMap) {
+    main_tx.send(MainThreadMessage::ClientDisconnected { client_id }).expect("Main thread should never drop its network reciever.");
+    clients.remove(&client_id);
 }