It works!

Author: ReCore-sys

scripts/new_packet.py

@@ -24,7 +24,7 @@
 use std::io::Write;
 
 #[derive(NetEncode)]
-#[packet(packet_id = "++id++")]
+#[packet(packet_id = "++id++", state="play")]
 pub struct ++name++ {}
 """
 

src/bin/src/systems/chunk_fetcher.rs

@@ -18,16 +18,25 @@ pub struct ChunkFetcher {
 
 fn generate_chunk(x: i32, z: i32) -> Chunk {
     let mut new_chunk = Chunk::new(x, z, "overworld".to_string());
-    for y in 0..10 {
-        new_chunk
-            .set_section(
-                y,
-                BlockData {
-                    name: "minecraft:stone".to_string(),
-                    properties: None,
-                },
-            )
-            .unwrap()
+    for x in 0..16 {
+        for z in 0..16 {
+            let mut base_y = (x as f64).sin() / 32.0;
+            base_y += (z as f64).cos() / 32.0;
+            let scaled_y = ((base_y + 1.0) * 64.0) as i32;
+            for y in 0..scaled_y {
+                new_chunk
+                    .set_block(
+                        x,
+                        y,
+                        z,
+                        BlockData {
+                            name: "minecraft:stone".to_string(),
+                            properties: None,
+                        },
+                    )
+                    .unwrap();
+            }
+        }
     }
     new_chunk
 }

src/lib/net/crates/codec/src/net_types/var_int.rs

@@ -18,6 +18,8 @@ pub struct VarInt {
 
 mod adapters {
     use crate::net_types::var_int::VarInt;
+    use std::ops::Add;
+    use std::ops::Sub;
 
     impl From<usize> for VarInt {
         fn from(value: usize) -> Self {
@@ -54,6 +56,22 @@ mod adapters {
             self.val == *other as i32
         }
     }
+
+    impl Add<Self> for VarInt {
+        type Output = Self;
+
+        fn add(self, other: Self) -> Self {
+            Self::new(self.val + other.val)
+        }
+    }
+
+    impl Sub<Self> for VarInt {
+        type Output = Self;
+
+        fn sub(self, other: Self) -> Self {
+            Self::new(self.val - other.val)
+        }
+    }
 }
 
 impl PartialEq for VarInt {

src/lib/net/src/packets/incoming/player_action.rs

@@ -1,13 +1,15 @@
 use crate::connection::StreamWriter;
 use crate::packets::outgoing::block_change_ack::BlockChangeAck;
-use crate::packets::outgoing::chunk_and_light_data::ChunkAndLightData;
+use crate::packets::outgoing::block_update::BlockUpdate;
 use crate::packets::IncomingPacket;
 use crate::NetResult;
+use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_macros::{packet, NetDecode};
 use ferrumc_net_codec::encode::NetEncodeOpts;
 use ferrumc_net_codec::net_types::network_position::NetworkPosition;
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use ferrumc_state::ServerState;
+use ferrumc_world::chunk_format::BLOCK2ID;
 use ferrumc_world::vanilla_chunk_format::BlockData;
 use std::sync::Arc;
 use tracing::debug;
@@ -39,35 +41,57 @@ impl IncomingPacket for PlayerAction {
                     self.location.y as i32,
                     self.location.z & 0xF,
                 );
-                chunk.set_block(relative_x, relative_y, relative_z, BlockData::default())?;
-                // debug!(chunk = ?chunk, "Chunk after block placement");
+                chunk.set_block(
+                    relative_x & 0xf,
+                    relative_y,
+                    relative_z & 0xf,
+                    BlockData::default(),
+                )?;
+                // Save the chunk to disk
                 state.world.save_chunk(chunk.clone()).await?;
                 state.world.sync().await?;
                 {
-                    let ack_packet = BlockChangeAck {
-                        sequence: self.sequence,
-                    };
-                    if let Ok(mut conn) = state.universe.get_mut::<StreamWriter>(conn_id) {
-                        let chunk_packet = ChunkAndLightData::from_chunk(&chunk)?;
-                        conn.send_packet(chunk_packet, &NetEncodeOpts::WithLength)?;
-                        conn.send_packet(ack_packet, &NetEncodeOpts::WithLength)?;
-                    } else {
-                        debug!(
-                            "Player disconnected before we could send the BlockChangeAck packet"
-                        );
+                    // Send the block update packet to all players
+                    let query = state
+                        .universe
+                        .query::<(&mut StreamWriter, &mut ChunkReceiver)>()
+                        .into_entities();
+                    for entity_id in query {
+                        if let Ok(mut connection) = state.universe.get_mut::<StreamWriter>(conn_id)
+                        {
+                            // Don't send the block update packet if the player can't see the chunk
+                            if let Ok(chunk_recv) = state.universe.get::<ChunkReceiver>(entity_id) {
+                                if chunk_recv.can_see.contains(&(
+                                    self.location.x >> 4,
+                                    self.location.z >> 4,
+                                    "overworld".to_string(),
+                                )) {
+                                    let block_update_packet = BlockUpdate {
+                                        location: self.location.clone(),
+                                        block_id: VarInt::from(*BLOCK2ID.get(&BlockData::default()).expect(
+                                            "BlockData::default() should always have a corresponding block ID",
+                                        )),
+                                    };
+                                    connection.send_packet(
+                                        block_update_packet,
+                                        &NetEncodeOpts::WithLength,
+                                    )?;
+                                }
+                            }
+
+                            // If the player is the one who placed the block, send the BlockChangeAck packet
+                            // We do this here to avoid locking the streamwriter multiple times
+                            if entity_id == conn_id {
+                                let ack_packet = BlockChangeAck {
+                                    sequence: self.sequence.clone(),
+                                };
+                                connection.send_packet(ack_packet, &NetEncodeOpts::WithLength)?;
+                            }
+                        } else {
+                            debug!("Player disconnected before we could send the BlockChangeAck packet");
+                        }
                     }
                 }
-                // {
-                //     let q = state.universe.query::<&mut ChunkReceiver>();
-                //     for (_, mut chunk_receiver) in q {
-                //         debug!("Queueing chunk resend");
-                //         chunk_receiver.queue_chunk_resend(
-                //             self.location.x >> 4,
-                //             self.location.z >> 4,
-                //             "overworld".to_string(),
-                //         );
-                //     }
-                // }
             }
             1 => {
                 debug!("You shouldn't be seeing this in creative mode.");

src/lib/net/src/packets/outgoing/block_update.rs

@@ -0,0 +1,11 @@
+use ferrumc_macros::{packet, NetEncode};
+use ferrumc_net_codec::net_types::network_position::NetworkPosition;
+use ferrumc_net_codec::net_types::var_int::VarInt;
+use std::io::Write;
+
+#[derive(NetEncode)]
+#[packet(packet_id = "block_update", state = "play")]
+pub struct BlockUpdate {
+    pub location: NetworkPosition,
+    pub block_id: VarInt,
+}

src/lib/net/src/packets/outgoing/mod.rs

@@ -34,3 +34,5 @@ pub mod update_entity_rotation;
 // -----------------------------
 
 pub mod block_change_ack;
+
+pub mod block_update;

src/lib/world/src/chunk_format.rs

@@ -12,7 +12,7 @@ use std::cmp::max;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::io::Read;
-use tracing::{error, warn};
+use tracing::{debug, error, warn};
 use vanilla_chunk_format::BlockData;
 
 #[cfg(test)]
@@ -384,7 +384,7 @@ impl Chunk {
         // Get old block
         let old_block = self.get_block(x, y, z)?;
         if old_block == block {
-            // debug!("Block is the same as the old block");
+            debug!("Block is the same as the old block");
             return Ok(());
         }
         // Get section
@@ -404,7 +404,7 @@ impl Chunk {
         if let PaletteType::Single(val) = &section.block_states.block_data {
             new_contents = PaletteType::Indirect {
                 bits_per_block: 4,
-                data: vec![0; 255],
+                data: vec![0; 256],
                 palette: vec![val.clone()],
             };
             converted = true;
@@ -464,8 +464,9 @@ impl Chunk {
                     });
                 // Set block
                 let blocks_per_i64 = (64f64 / *bits_per_block as f64).floor() as usize;
-                let index = ((y & 0xf) * 256 + (z & 0xf) * 16 + (x & 0xf)) as usize;
-                let i64_index = (index / blocks_per_i64) - 1;
+                let index =
+                    ((y.abs() & 0xf) * 256 + (z.abs() & 0xf) * 16 + (x.abs() & 0xf)) as usize;
+                let i64_index = index / blocks_per_i64;
                 let packed_u64 = data
                     .get_mut(i64_index)
                     .ok_or(InvalidBlockStateData(format!(
@@ -500,6 +501,10 @@ impl Chunk {
             })
             .map(|(_, count)| *count as u16)
             .sum();
+
+        self.sections
+            .iter_mut()
+            .for_each(|section| section.optimise().unwrap());
         Ok(())
     }
 
@@ -524,10 +529,11 @@ impl Chunk {
         let section = self
             .sections
             .iter()
-            .find(|section| section.y == (y >> 4) as i8)
+            .find(|section| section.y == y.div_floor(16) as i8)
             .ok_or(WorldError::SectionOutOfBounds(y >> 4))?;
         match &section.block_states.block_data {
             PaletteType::Single(val) => {
+                debug!(x, y, z, "Single palette type");
                 let block_id = val.val;
                 ID2BLOCK
                     .get(&block_id)
@@ -547,7 +553,7 @@ impl Chunk {
                 }
                 let blocks_per_i64 = (64f64 / *bits_per_block as f64).floor() as usize;
                 let index = ((y & 0xf) * 256 + (z & 0xf) * 16 + (x & 0xf)) as usize;
-                let i64_index = (index / blocks_per_i64) - 1;
+                let i64_index = index / blocks_per_i64;
                 let packed_u64 = data.get(i64_index).ok_or(InvalidBlockStateData(format!(
                     "Invalid block state data at index {}",
                     i64_index
@@ -569,7 +575,7 @@ impl Chunk {
     }
 
     pub fn new(x: i32, z: i32, dimension: String) -> Self {
-        let sections: Vec<Section> = (0..24)
+        let sections: Vec<Section> = (-4..20)
             .map(|y| Section {
                 y: y as i8,
                 block_states: BlockStates {

src/lib/world/src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(hasher_prefixfree_extras)]
+#![feature(int_roundings)]
 
 pub mod chunk_format;
 mod db_functions;