Now works a little bit more, still broken af

Author: ReCore-sys

src/bin/Cargo.toml

@@ -35,7 +35,7 @@ async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 flate2 = { workspace = true }
 ctor = { workspace = true }
-log = "0.4.22"
+rand = { workspace = true }
 
 
 [[bin]]

src/bin/src/systems/chunk_fetcher.rs

@@ -6,7 +6,7 @@ use ferrumc_core::chunks::chunk_receiver::ChunkSendState::{Fetching, Sending};
 use ferrumc_state::GlobalState;
 use ferrumc_world::chunk_format::Chunk;
 use ferrumc_world::vanilla_chunk_format::BlockData;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 use tokio::task::JoinSet;
@@ -16,6 +16,22 @@ pub struct ChunkFetcher {
     stop: AtomicBool,
 }
 
+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()
+    }
+    new_chunk
+}
+
 impl ChunkFetcher {
     pub(crate) fn new() -> Self {
         Self {
@@ -61,24 +77,14 @@ impl System for ChunkFetcher {
                             state.world.load_chunk(key.0, key.1, &key.2.clone()).await?
                         } else {
                             debug!("Chunk not found, creating new chunk");
-                            let mut new_chunk = Chunk::new(key.0, key.1, key.2.clone());
-                            for section in 0..8 {
-                                new_chunk.set_section(
-                                    section,
-                                    BlockData {
-                                        name: "minecraft:grass_block".to_string(),
-                                        properties: Some(BTreeMap::from([(
-                                            "snowy".to_string(),
-                                            "false".to_string(),
-                                        )])),
-                                    },
-                                )?;
-                            }
+                            let new_chunk = generate_chunk(key.0, key.1);
+
                             state.world.save_chunk(new_chunk.clone()).await?;
                             new_chunk
                         };
                         *chunk = Some(fetched_chunk);
                     }
+                    state.world.sync().await?;
                     // Insert the fetched chunks back into the component
                     {
                         let Ok(mut chunk_recv) = state.universe.get_mut::<ChunkReceiver>(eid)

src/bin/src/systems/chunk_sender.rs

@@ -15,7 +15,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::task::JoinSet;
-use tracing::{debug, error, info, trace};
+use tracing::{error, info, trace};
 
 pub(super) struct ChunkSenderSystem {
     pub stop: AtomicBool,
@@ -74,11 +74,10 @@ impl System for ChunkSenderSystem {
                             .get_mut::<ChunkReceiver>(eid)
                             .expect("ChunkReceiver not found");
                         trace!("Got chunk_recv 3 for sender");
-                        for (key, chunk) in chunk_recv.needed_chunks.iter_mut() {
+                        for (_key, chunk) in chunk_recv.needed_chunks.iter_mut() {
                             if let Sending(confirmed_chunk) = chunk {
                                 match ChunkAndLightData::from_chunk(&confirmed_chunk.clone()) {
                                     Ok(packet) => {
-                                        debug!("Queuing chunk for sending");
                                         packets.push(packet);
                                     }
                                     Err(e) => {

src/lib/core/src/chunks/chunk_receiver.rs

@@ -46,6 +46,15 @@ impl ChunkReceiver {
             }
         }
     }
+
+    pub fn queue_from_chunk(&mut self, chunk: Chunk) {
+        let key = (chunk.x, chunk.z, chunk.dimension.clone());
+
+        if self.can_see.contains(&key) {
+            self.needed_chunks
+                .insert(key, ChunkSendState::Sending(chunk));
+        }
+    }
 }
 
 impl ChunkReceiver {

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

@@ -102,6 +102,7 @@ impl IncomingPacket for PlaceBlock {
                     },
                 )?;
                 state.world.save_chunk(chunk).await?;
+                state.world.sync().await?;
                 let q = state.universe.query::<&mut ChunkReceiver>();
                 for (_, mut chunk_recv) in q {
                     chunk_recv.queue_chunk_resend(x >> 4, z >> 4, "overworld".to_string());

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

@@ -1,8 +1,8 @@
 use crate::connection::StreamWriter;
 use crate::packets::outgoing::block_change_ack::BlockChangeAck;
+use crate::packets::outgoing::chunk_and_light_data::ChunkAndLightData;
 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;
@@ -34,36 +34,40 @@ impl IncomingPacket for PlayerAction {
                 let block =
                     chunk.get_block(self.location.x, self.location.y as i32, self.location.z)?;
                 debug!("Block: {:?}", block);
-                chunk.set_block(
-                    self.location.x,
+                let (relative_x, relative_y, relative_z) = (
+                    self.location.x & 0xF,
                     self.location.y as i32,
-                    self.location.z,
-                    BlockData::default(),
-                )?;
-                state.world.save_chunk(chunk).await?;
+                    self.location.z & 0xF,
+                );
+                chunk.set_block(relative_x, relative_y, relative_z, BlockData::default())?;
+                // debug!(chunk = ?chunk, "Chunk after block placement");
+                state.world.save_chunk(chunk.clone()).await?;
+                state.world.sync().await?;
                 {
-                    let packet = BlockChangeAck {
+                    let ack_packet = BlockChangeAck {
                         sequence: self.sequence,
                     };
                     if let Ok(mut conn) = state.universe.get_mut::<StreamWriter>(conn_id) {
-                        conn.send_packet(packet, &NetEncodeOpts::WithLength)?;
+                        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"
                         );
                     }
                 }
-                {
-                    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(),
-                        );
-                    }
-                }
+                // {
+                //     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/chunk_and_light_data.rs

@@ -7,7 +7,7 @@ use ferrumc_net_codec::net_types::var_int::VarInt;
 use ferrumc_world::chunk_format::{Chunk, Heightmaps, PaletteType};
 use std::io::{Cursor, Write};
 use std::ops::Not;
-use tracing::{debug, warn};
+use tracing::warn;
 
 const SECTIONS: usize = 24; // Number of sections, adjust for your Y range (-64 to 319)
 
@@ -64,7 +64,6 @@ impl ChunkAndLightData {
     }
 
     pub fn from_chunk(chunk: &Chunk) -> Result<Self, NetError> {
-        debug!("Serializing chunk at {}, {}", chunk.x, chunk.z);
         let mut raw_data = Cursor::new(Vec::new());
         let mut sky_light_data = Vec::new();
         let mut block_light_data = Vec::new();

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::{debug, error, warn};
+use tracing::{error, warn};
 use vanilla_chunk_format::BlockData;
 
 #[cfg(test)]
@@ -41,7 +41,7 @@ lazy_static! {
         ID2BLOCK.iter().map(|(k, v)| (v.clone(), *k)).collect();
 }
 
-#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq)]
+#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq, Debug)]
 // This is a placeholder for the actual chunk format
 pub struct Chunk {
     pub x: i32,
@@ -51,7 +51,7 @@ pub struct Chunk {
     pub heightmaps: Heightmaps,
 }
 
-#[derive(Encode, Decode, NBTDeserialize, NBTSerialize, Clone, DeepSizeOf)]
+#[derive(Encode, Decode, NBTDeserialize, NBTSerialize, Clone, DeepSizeOf, Debug)]
 #[nbt(net_encode)]
 #[derive(Eq, PartialEq)]
 pub struct Heightmaps {
@@ -60,22 +60,22 @@ pub struct Heightmaps {
     #[nbt(rename = "WORLD_SURFACE")]
     pub world_surface: Vec<i64>,
 }
-#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq)]
+#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq, Debug)]
 pub struct Section {
     pub y: i8,
     pub block_states: BlockStates,
     pub biome_states: BiomeStates,
     pub block_light: Vec<u8>,
     pub sky_light: Vec<u8>,
 }
-#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq)]
+#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq, Debug)]
 pub struct BlockStates {
     pub non_air_blocks: u16,
     pub block_data: PaletteType,
     pub block_counts: HashMap<BlockData, i32>,
 }
 
-#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq)]
+#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq, Debug)]
 pub enum PaletteType {
     Single(VarInt),
     Indirect {
@@ -89,7 +89,7 @@ pub enum PaletteType {
     },
 }
 
-#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq)]
+#[derive(Encode, Decode, Clone, DeepSizeOf, Eq, PartialEq, Debug)]
 pub struct BiomeStates {
     pub bits_per_biome: u8,
     pub data: Vec<i64>,
@@ -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
@@ -393,25 +393,39 @@ impl Chunk {
             .iter_mut()
             .find(|section| section.y == (y >> 4) as i8)
             .ok_or(WorldError::SectionOutOfBounds(y >> 4))?;
+
+        let mut converted = false;
+        let mut new_contents = PaletteType::Indirect {
+            bits_per_block: 4,
+            data: vec![],
+            palette: vec![],
+        };
+
+        if let PaletteType::Single(val) = &section.block_states.block_data {
+            new_contents = PaletteType::Indirect {
+                bits_per_block: 4,
+                data: vec![0; 255],
+                palette: vec![val.clone()],
+            };
+            converted = true;
+        }
+
+        if converted {
+            section.block_states.block_data = new_contents;
+        }
+
         // Do different things based on the palette type
         match &mut section.block_states.block_data {
-            PaletteType::Single(val) => {
-                debug!("Converting single block to indirect palette");
-                // If it's a single block, convert it to indirect then re-run the function
-                section.block_states.block_data = PaletteType::Indirect {
-                    bits_per_block: 4,
-                    data: vec![0; 256],
-                    palette: vec![val.clone()],
-                };
-                self.set_block(x, y, z, block)?;
+            PaletteType::Single(_val) => {
+                panic!("Single palette type should have been converted to indirect palette type");
             }
             PaletteType::Indirect {
                 bits_per_block,
                 data,
                 palette,
             } => {
-                let block_counts = &mut section.block_states.block_counts;
-                match block_counts.entry(old_block.clone()) {
+                // debug!("Indirect mode");
+                match section.block_states.block_counts.entry(old_block.clone()) {
                     Entry::Occupied(mut occ_entry) => {
                         let count = occ_entry.get_mut();
                         if *count <= 0 {
@@ -431,9 +445,13 @@ impl Chunk {
                 if let Some(e) = section.block_states.block_counts.get(&block) {
                     section.block_states.block_counts.insert(block, e + 1);
                 } else {
-                    debug!("Adding block to block counts");
+                    // debug!("Adding block to block counts");
                     section.block_states.block_counts.insert(block, 1);
                 }
+                // let required_bits = max((palette.len() as f32).log2().ceil() as u8, 4);
+                // if *bits_per_block != required_bits {
+                //     section.block_states.resize(required_bits as usize)?;
+                // }
                 // Get block index
                 let block_palette_index = palette
                     .iter()
@@ -546,11 +564,7 @@ impl Chunk {
                 y: y as i8,
                 block_states: BlockStates {
                     non_air_blocks: 0,
-                    block_data: PaletteType::Indirect {
-                        bits_per_block: 4,
-                        data: vec![0; 256],
-                        palette: vec![VarInt::from(0)],
-                    },
+                    block_data: PaletteType::Single(VarInt::from(0)),
                     block_counts: HashMap::from([(BlockData::default(), 4096)]),
                 },
                 biome_states: BiomeStates {