Merge from origin/main

Author: Stivais

src/dungeon/room/room.rs

@@ -126,10 +126,8 @@ impl Room {
 
         let mut num: u8 = 0;
         for i in 0..4 {
+            num <<= 1;
             num |= doors_opt[i] as u8;
-            if i < 3 {
-                num <<= 1;
-            }
         }
 
         // println!("{:04b} {:?}", num, doors_opt);
@@ -316,7 +314,15 @@ impl Room {
 
             world.set_block_at(block, corner.x + bp.x, y, corner.z + bp.z);
         }
+    }
+
+    pub fn get_world_pos(&self, room_pos: &BlockPos) -> BlockPos {
+        let corner = self.get_corner_pos();
 
+        room_pos.clone()
+            .rotate(self.rotation)
+            .add_x(corner.x)
+            .add_z(corner.z)
     }
 }
 

src/main.rs

@@ -6,13 +6,14 @@ mod utils;
 use crate::dungeon::door::DoorType;
 use crate::dungeon::dungeon::Dungeon;
 use crate::dungeon::dungeon_state::DungeonState;
-use crate::dungeon::room::room_data::RoomData;
+use crate::dungeon::room::room_data::{RoomData, RoomType};
 use crate::net::internal_packets::{MainThreadMessage, NetworkThreadMessage};
 use crate::net::packets::packet_buffer::PacketBuffer;
 use crate::net::protocol::play::clientbound;
 use crate::net::protocol::play::clientbound::AddEffect;
 use crate::net::run_network::run_network_thread;
 use crate::net::var_int::VarInt;
+use crate::server::block::block_position::BlockPos;
 use crate::server::block::blocks::Blocks;
 use crate::server::chunk::chunk::Chunk;
 use crate::server::chunk::chunk_grid::{for_each_diff, ChunkDiff};
@@ -95,6 +96,8 @@ async fn main() -> Result<()> {
         .split("\n")
         .collect::<Vec<&str>>();
 
+    // Check if a custom dungeon str has been given via cli args
+
     // let dungeon_str = "080809010400100211121300101415161304171418161300191403161304191905160600919999113099910991099909090099999919990929999999099999999009";
 
     let dungeon_str = match args.len() {
@@ -108,10 +111,10 @@ async fn main() -> Result<()> {
 
     let rng_seed: u64 = rand::random(); // using a second seed for rng enables the same layout to have randomized rooms. Maybe should be included in the dungeon seed string?
     // let rng_seed: u64 = 12946977352813673410;
-    
+
     println!("Rng Seed: {}", rng_seed);
     SeededRng::set_seed(rng_seed);
-    
+
     let dungeon = Dungeon::from_string(dungeon_str, &room_data_storage)?;
     let mut server = Server::initialize_with_dungeon(network_tx, dungeon);
     server.world.server = &mut server;
@@ -129,8 +132,20 @@ 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.borrow().load_into_world(&mut server.world);
+        room.load_into_world(&mut server.world);
+
+        // Set the spawn point to be inside of the spawn room
+        if room.room_data.room_type == RoomType::Entrance {
+            server.world.set_spawn_point(
+                room.get_world_pos(&BlockPos {
+                    x: 15,
+                    y: 72,
+                    z: 18
+                })
+            );
+        }
     }
 
     for door in &dungeon.doors {
@@ -347,7 +362,7 @@ async fn main() -> Result<()> {
 
             sidebar_lines.push_str("§emc.hypixel.net");
             player.sidebar.write_update(sidebar_lines, &mut player.packet_buffer);
-            
+
             if player.ticks_existed % 60 == 0 {
                 player.write_packet(&AddEffect {
                     entity_id: VarInt(player.entity_id),

src/server/block/block_position.rs

@@ -91,6 +91,22 @@ impl BlockPos {
             z: self.z + other.z
         }
     }
+
+    pub fn subtract(&self, other: &BlockPos) -> Self {
+        Self {
+            x: self.x - other.x,
+            y: self.y - other.y,
+            z: self.z - other.z
+        }
+    }
+
+    pub fn as_vec3f(&self) -> DVec3 {
+            DVec3 {
+                x: self.x as f64,
+                y: self.y as f64,
+                z: self.z as f64
+            }
+    }
 }
 
 const XZ_BITS: i32 = 26;

src/server/server.rs

@@ -7,7 +7,6 @@ use crate::server::items::Item;
 use crate::server::player::attribute::{Attribute, AttributeMap, AttributeModifier};
 use crate::server::player::inventory::ItemSlot;
 use crate::server::player::player::Player;
-use crate::server::utils::dvec3::DVec3;
 use crate::server::utils::player_list::footer::footer;
 use crate::server::utils::player_list::header::header;
 use crate::server::utils::tasks::Task;
@@ -50,17 +49,13 @@ impl Server {
             MainThreadMessage::NewPlayer { client_id, profile } => {
                 println!("added player with id {client_id}");
 
-                let spawn_point = DVec3 {
-                    x: 20.0,
-                    y: 69.0,
-                    z: 20.0,
-                };
+                let spawn_pos = self.world.spawn_point.as_vec3f();
 
                 let mut player = Player::new(
                     self,
                     client_id,
                     profile,
-                    spawn_point,
+                    spawn_pos,
                 );
                 println!("player entity id: {}", player.entity_id);
 

src/server/utils/nbt/mod.rs

@@ -1,4 +1,3 @@
 pub mod serialize;
 pub mod deserialize;
-pub mod nbt;
-
+pub mod nbt;

src/server/world.rs

@@ -36,6 +36,7 @@ pub struct World {
     // pub commands: Vec<Command>
 
     // pub player_info: PlayerList,
+    pub spawn_point: BlockPos,
 }
 
 impl World {
@@ -52,9 +53,12 @@ impl World {
             next_entity_id: 1, // might have to start at 1
             players: HashMap::new(),
             entities: HashMap::new(),
+            spawn_point: BlockPos {
+                x: 20,
+                y: 69,
+                z: 20,
+            },
             entities_for_removal: VecDeque::new(),
-
-            // commands: Vec::new()
         }
     }
 
@@ -167,6 +171,10 @@ impl World {
         self.chunk_grid.get_block_at(x, y, z)
     }
 
+    pub fn set_spawn_point(&mut self, new_spawn: BlockPos) {
+        self.spawn_point = new_spawn;
+    }
+
     pub fn fill_blocks(&mut self, block: Blocks, start: BlockPos, end: BlockPos) {
         iterate_blocks(start, end, |x, y, z| {
             self.set_block_at(block, x, y, z)