Add light updates

minecraft-entities-derive/examples/main.rs

@@ -17,6 +17,7 @@ enum AnyEntity {
     Cow(Cow),
 }
 
+#[derive(Debug)]
 pub struct Handler<T> {
     uuid: Eid,
     world: Arc<Mutex<()>>,

minecraft-positions/src/lib.rs

@@ -1,5 +1,7 @@
 mod shards;
 
+use std::ops::{AddAssign, Add};
+
 pub use minecraft_protocol::packets::Position as NetworkPosition;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
@@ -175,6 +177,17 @@ pub struct ChunkColumnPosition {
     pub cz: i32,
 }
 
+impl Add<ChunkColumnPosition> for ChunkColumnPosition {
+    type Output = ChunkColumnPosition;
+
+    fn add(self, rhs: ChunkColumnPosition) -> Self::Output {
+        ChunkColumnPosition {
+            cx: self.cx + rhs.cx,
+            cz: self.cz + rhs.cz,
+        }
+    }
+}
+
 impl ChunkColumnPosition {
     pub fn chunk(&self, cy: i32) -> ChunkPosition {
         ChunkPosition {

minecraft-positions/src/shards.rs

@@ -2,6 +2,9 @@ use crate::*;
 
 impl ChunkColumnPosition {
     pub fn shard(&self, shard_count: usize) -> usize {
-        (self.cx + self.cz).unsigned_abs() as usize % shard_count
+        const REGION_SIZE: i32 = 8;
+        let region_x = self.cx.div_euclid(REGION_SIZE);
+        let region_z = self.cz.div_euclid(REGION_SIZE);
+        (region_x + region_z).unsigned_abs() as usize % shard_count
     }
 }

minecraft-protocol/build/items.rs

@@ -60,6 +60,13 @@ pub enum Item {{
 {variants}
 }}
 
+impl Default for Item {{
+    #[inline]
+    fn default() -> Self {{
+        Item::Air
+    }}
+}}
+
 impl Item {{
     #[inline]
     pub fn from_id(id: u32) -> Option<Item> {{

minecraft-protocol/src/components/chunk.rs

@@ -1,4 +1,4 @@
-use crate::{nbt::NbtTag, *, components::blocks::BlockEntity};
+use crate::{nbt::NbtTag, *, components::blocks::BlockEntity, packets::serializer::BitSet};
 
 /// A complex data structure including block data and optionally entities of a chunk.
 ///
@@ -24,19 +24,19 @@ pub struct ChunkData<'a> {
     /// BitSet containing bits for each section in the world + 2.
     /// Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Sky Light array below.
     /// The least significant bit is for blocks 16 blocks to 1 block below the min world height (one section below the world), while the most significant bit covers blocks 1 to 16 blocks above the max world height (one section above the world).
-    pub sky_light_mask: Array<'a, u64, VarInt>,
+    pub sky_light_mask: BitSet<'a>,
     /// BitSet containing bits for each section in the world + 2.
     /// Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Block Light array below.
     /// The order of bits is the same as in Sky Light Mask.
-    pub block_light_mask: Array<'a, u64, VarInt>,
+    pub block_light_mask: BitSet<'a>,
     /// BitSet containing bits for each section in the world + 2.
     /// Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Block Light array below.
     /// The order of bits is the same as in Sky Light Mask.
-    pub empty_sky_light_mask: Array<'a, u64, VarInt>,
+    pub empty_sky_light_mask: BitSet<'a>,
     /// BitSet containing bits for each section in the world + 2.
     /// Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Block Light array below.
     /// The order of bits is the same as in Sky Light Mask.
-    pub empty_block_light_mask: Array<'a, u64, VarInt>,
+    pub empty_block_light_mask: BitSet<'a>,
     /// Length should match the number of bits set in Sky Light Mask.
     /// Each entry is an array of 2048 bytes.
     /// There is 1 array for each bit set to true in the sky light mask, starting with the lowest value. Half a byte per light value. Indexed ((y<<8) | (z<<4) | x) / 2

minecraft-protocol/src/components/mod.rs

@@ -21,4 +21,4 @@ pub mod slots;
 pub mod sound;
 pub mod tags;
 pub mod teams;
-pub mod trades;
+pub mod trades;

minecraft-protocol/src/components/slots.rs

@@ -9,7 +9,7 @@ pub struct Slot {
 }
 
 #[cfg_attr(test, derive(PartialEq))]
-#[derive(Debug, Clone, MinecraftPacketPart)]
+#[derive(Debug, Clone, Default, MinecraftPacketPart)]
 pub struct SlotItem {
     /// The [item](crate::ids::items::Item).
     /// Item IDs are distinct from [block IDs](crate::ids::blocks::Block); see [crate::ids] for more information.

minecraft-protocol/src/nbt/mod.rs

@@ -25,6 +25,12 @@ pub enum NbtTag {
     RootCompound(String, HashMap<String, NbtTag>),
 }
 
+impl Default for NbtTag {
+    fn default() -> Self {
+        NbtTag::Null
+    }
+}
+
 impl NbtTag {
     #[inline]
     pub fn is_null(&self) -> bool {

minecraft-protocol/src/packets/play_clientbound.rs

@@ -443,8 +443,20 @@ pub enum ClientboundPacket<'a> {
 
     /// Updates light levels for a chunk
     UpdateLight {
-        /// TODO: parse this
-        data: RawBytes<'a>,
+        /// Chunk coordinate (block coordinate divided by 16, rounded down)
+        cx: VarInt,
+        /// Chunk coordinate (block coordinate divided by 16, rounded down)
+        cz: VarInt,
+        /// BitSet containing bits for each section in the world + 2. Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Sky Light array below. The least significant bit is for blocks 16 blocks to 1 block below the min world height (one section below the world), while the most significant bit covers blocks 1 to 16 blocks above the max world height (one section above the world).
+        sky_light_mask: BitSet<'a>,
+        /// BitSet containing bits for each section in the world + 2. Each set bit indicates that the corresponding 16×16×16 chunk section has data in the Block Light array below. The order of bits is the same as in Sky Light Mask.
+        block_light_mask: BitSet<'a>,
+        /// BitSet containing bits for each section in the world + 2. Each set bit indicates that the corresponding 16×16×16 chunk section has all zeros for its Sky Light data. The order of bits is the same as in Sky Light Mask.
+        empty_sky_light_mask: BitSet<'a>,
+        /// BitSet containing bits for each section in the world + 2. Each set bit indicates that the corresponding 16×16×16 chunk section has all zeros for its Block Light data. The order of bits is the same as in Sky Light Mask.
+        empty_block_light_mask: BitSet<'a>,
+        sky_light_arrays: Array<'a, Array<'a, u8, VarInt>, VarInt>,
+        block_light_arrays: Array<'a, Array<'a, u8, VarInt>, VarInt>,
     },
 
     /// See [Protocol Encryption](https://wiki.vg/Protocol_Encryption) for information on logging in.

minecraft-server/Cargo.toml

@@ -7,10 +7,18 @@ edition = "2021"
 
 [dependencies]
 env_logger = "0.10.0"
-log = "0.4.20"
 tokio = { version = "1.33.0", features = ["full"] }
 futures = "0.3.29"
 minecraft-protocol = { path="../minecraft-protocol" }
 minecraft-positions = { path="../minecraft-positions" }
 minecraft-entities-derive = { path="../minecraft-entities-derive" }
 rand = "0.8.4"
+tracy-client = { version = "0.16.4", features = ["enable"], optional = true}
+tracing-tracy = { version = "0.10.4", features = ["enable", "system-tracing"], optional = true}
+tracing-subscriber = "0.3.18"
+log = "0.4.17"
+tracing = { version = "0.1", features = ["attributes"] }
+
+[features]
+default = []
+tracing = ["tracy-client", "tracing-tracy"]

minecraft-server/src/entities/entity.rs

@@ -7,6 +7,8 @@ use super::*;
         init(self, server_msg_rcvr: BroadcastReceiver<ServerMessage>);
     }
 )]
+
+#[derive(Debug)]
 pub struct Entity {
     pub position: Position,
     pub velocity: Translation,
@@ -29,6 +31,7 @@ pub struct Entity {
 }
 
 impl Handler<Entity> {
+    #[instrument(skip_all)]
     pub async fn init(self, server_msg_rcvr: BroadcastReceiver<ServerMessage>) {
         self.insert_task("newton", tokio::spawn(newton_task(self.clone(), server_msg_rcvr))).await;
     }

minecraft-server/src/entities/player.rs

@@ -87,6 +87,7 @@ impl Player {
 }
 
 impl Handler<Player> {
+    #[instrument(skip_all)]
     async fn update_center_chunk(self) {
         let Some((old_center_chunk, new_center_chunk, render_distance)) = self.mutate(|player| {
             let old_center_chunk = player.center_chunk.clone();
@@ -115,10 +116,10 @@ impl Handler<Player> {
             if loaded_chunks_after == player.loaded_chunks { return (None, EntityChanges::nothing()) };
             let mut newly_loaded_chunks: Vec<_> = loaded_chunks_after.difference(&player.loaded_chunks).cloned().collect();
             let unloaded_chunks: Vec<_> = player.loaded_chunks.difference(&loaded_chunks_after).cloned().collect();
-            for skipped in newly_loaded_chunks.iter().skip(50) {
+            for skipped in newly_loaded_chunks.iter().skip(2) {
                 loaded_chunks_after.remove(skipped);
             }
-            newly_loaded_chunks.truncate(50);
+            newly_loaded_chunks.truncate(2);
             let uuid = player.info.uuid;
             player.loaded_chunks = loaded_chunks_after.clone();
             (Some((loaded_chunks_after, newly_loaded_chunks, unloaded_chunks, uuid)), EntityChanges::other())
@@ -128,39 +129,17 @@ impl Handler<Player> {
         self.world.update_loaded_chunks(uuid, loaded_chunks_after).await;
 
         // Send the chunks to the client
-        let mut heightmaps = HashMap::new();
-        heightmaps.insert(String::from("MOTION_BLOCKING"), NbtTag::LongArray(vec![0; 37]));
-        let heightmaps = NbtTag::Compound(heightmaps);
+        let mut chunks = Vec::new();
         for newly_loaded_chunk in newly_loaded_chunks {
-            let mut column = Vec::new();
-            for cy in -4..20 {
-                let chunk = self.world.get_network_chunk(newly_loaded_chunk.chunk(cy)).await.unwrap_or_else(|| {
-                    error!("Chunk not loaded: {newly_loaded_chunk:?}");
-                    NetworkChunk { // TODO hard error
-                        block_count: 0,
-                        blocks: PalettedData::Single { value: 0 },
-                        biomes: PalettedData::Single { value: 4 },
-                    }
-                });
-                column.push(chunk);
-            }
-            let serialized: Vec<u8> = NetworkChunk::into_data(column).unwrap();
-            let chunk_data = PlayClientbound::ChunkData {
-                value: ChunkData {
-                    chunk_x: newly_loaded_chunk.cx,
-                    chunk_z: newly_loaded_chunk.cz,
-                    heightmaps: heightmaps.clone(),
-                    data: Array::from(serialized.clone()),
-                    block_entities: Array::default(),
-                    sky_light_mask: Array::default(),
-                    block_light_mask: Array::default(),
-                    empty_sky_light_mask: Array::default(),
-                    empty_block_light_mask: Array::default(),
-                    sky_light: Array::default(),
-                    block_light: Array::default(),
-                }
-            };
-            self.send_packet(chunk_data).await;
+            let chunk = self.world.get_network_chunk_column_data(newly_loaded_chunk.clone()).await.unwrap_or_else(|| {
+                error!("Chunk not loaded: {newly_loaded_chunk:?}");
+                panic!("Chunk not loaded: {newly_loaded_chunk:?}");
+            });
+            chunks.push(chunk);
+        }
+
+        for chunk in chunks {
+            self.send_raw_packet(chunk).await;
         }
 
         // Tell the client to unload chunks
@@ -172,6 +151,7 @@ impl Handler<Player> {
         }
     }
 
+    #[instrument(skip_all)]
     async fn send_packet<'a>(&self, packet: PlayClientbound<'a>) {
         let packet = packet.serialize_minecraft_packet().unwrap();
         let packets_sent = self.mutate(|player| {
@@ -185,10 +165,28 @@ impl Handler<Player> {
         packet_sender.send(packet).await.unwrap();
     }
 
+    #[instrument(skip_all)]
+    async fn send_raw_packet(&self, packet: Vec<u8>) {
+        let packets_sent = self.mutate(|player| {
+            player.packets_sent += 1;
+            (player.packets_sent, EntityChanges::other())
+        }).await.unwrap_or(0);
+        if packets_sent > 500 {
+            warn!("Many packets sent ({packets_sent})");
+        }
+        let Some(packet_sender) = self.observe(|player| player.packet_sender.clone()).await else {return};
+        packet_sender.send(packet).await.unwrap();
+    }
+
     async fn on_server_message(self, message: ServerMessage) {
         use ServerMessage::*;
         match message {
             Tick(tick_id) => {
+                #[cfg(feature = "tracing")] {
+                    let span = info_span!("player tick");
+                    let _enter: tracing::span::Entered<'_> = span.enter();    
+                }
+
                 if tick_id % (20*10) == 0 {
                     self.send_packet(PlayClientbound::KeepAlive { keep_alive_id: tick_id as u64 }).await;
                 }
@@ -201,6 +199,7 @@ impl Handler<Player> {
         }
     }
 
+    #[instrument(skip_all)]
     async fn on_world_change(self, change: WorldChange) {
         match change {
             WorldChange::Block(position, block) => {
@@ -293,6 +292,7 @@ impl Handler<Player> {
         }
     }
 
+    #[instrument(skip_all)]
     async fn on_packet<'a>(mut self, packet: PlayServerbound<'a>) {
         use PlayServerbound::*;
         match packet {
@@ -367,6 +367,7 @@ impl Handler<Player> {
     }
 }
 
+#[instrument(skip_all)]
 async fn handle_player(h: Handler<Player>, uuid: UUID, stream: TcpStream, packet_receiver: MpscReceiver<Vec<u8>>, server_msg_rcvr: BroadcastReceiver<ServerMessage>, change_receiver: MpscReceiver<WorldChange>) {
     let r = handle_player_inner(h.clone(), stream, packet_receiver, server_msg_rcvr, change_receiver).await;
     match r {
@@ -376,6 +377,7 @@ async fn handle_player(h: Handler<Player>, uuid: UUID, stream: TcpStream, packet
     h.world.remove_loader(uuid).await;
 }
 
+#[instrument(skip_all)]
 async fn handle_player_inner(h: Handler<Player>, stream: TcpStream, mut packet_receiver: MpscReceiver<Vec<u8>>, mut server_msg_rcvr: BroadcastReceiver<ServerMessage>, mut change_receiver: MpscReceiver<WorldChange>) -> Result<(), ()> {
     let (mut reader_stream, mut writer_stream) = stream.into_split();
 

minecraft-server/src/main.rs

@@ -23,6 +23,22 @@ impl std::future::Future for ServerFuture {
 
 #[tokio::main]
 async fn main() {
+    #[cfg(feature = "tracing")]
+    #[global_allocator]
+    static GLOBAL: tracy_client::ProfiledAllocator<std::alloc::System> =
+        tracy_client::ProfiledAllocator::new(std::alloc::System, 100);
+
+    use tracing_subscriber::{fmt, layer::SubscriberExt, Registry};
+
+    let subscriber = Registry::default()
+                                .with(fmt::layer());
+    #[cfg(feature = "tracing")]
+    let subscriber = subscriber
+        .with(tracing_tracy::TracyLayer::new());
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("setting up tracing");
+
     env_logger::init();
 
     let server = ServerBehavior::init().await;

minecraft-server/src/player_handler/connect.rs

@@ -1,5 +1,7 @@
 use super::*;
 
+
+#[instrument(skip_all)]
 pub async fn handle_connection(
     mut stream: TcpStream,
     addr: SocketAddr,