Final Fixes (I think)

Author: ReCore-sys

src/bin/src/packet_handlers/play_packets/player_action.rs

@@ -9,7 +9,6 @@ use ferrumc_net::PlayerActionReceiver;
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use ferrumc_state::GlobalStateResource;
 use ferrumc_world::block_id::BlockId;
-use ferrumc_world::vanilla_chunk_format::BlockData;
 use tracing::{debug, error, trace};
 
 pub fn handle(

src/lib/world/src/block_id.rs

@@ -5,6 +5,7 @@ use deepsize::DeepSizeOf;
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use lazy_static::lazy_static;
 use std::collections::HashMap;
+use std::fmt::Display;
 use std::process::exit;
 use tracing::error;
 
@@ -70,6 +71,16 @@ impl BlockId {
     }
 }
 
+impl Display for BlockId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(block_data) = self.to_block_data() {
+            write!(f, "BlockId({}: {:?})", self.0, block_data)
+        } else {
+            write!(f, "BlockId({}: Unknown)", self.0)
+        }
+    }
+}
+
 impl BlockData {
     /// Converts a BlockData to a BlockId. Will panic if the ID is not found.
     pub fn to_block_id(&self) -> BlockId {

src/lib/world/src/chunk_format.rs

@@ -5,12 +5,11 @@ use crate::{errors::WorldError, vanilla_chunk_format::VanillaHeightmaps};
 use bitcode_derive::{Decode, Encode};
 use deepsize::DeepSizeOf;
 use ferrumc_general_purpose::data_packing::i32::read_nbit_i32;
-use ferrumc_macros::{NBTDeserialize, NBTSerialize};
+use ferrumc_macros::{block, NBTDeserialize, NBTSerialize};
 use ferrumc_net_codec::net_types::var_int::VarInt;
 use std::cmp::max;
 use std::collections::HashMap;
 use tracing::error;
-use vanilla_chunk_format::BlockData;
 // #[cfg(test)]
 // const BLOCKSFILE: &[u8] = &[0];
 
@@ -76,7 +75,9 @@ pub struct BiomeStates {
     pub palette: Vec<VarInt>,
 }
 
-fn convert_to_net_palette(vanilla_palettes: Vec<BlockData>) -> Result<Vec<VarInt>, WorldError> {
+fn convert_to_net_palette(
+    vanilla_palettes: Vec<vanilla_chunk_format::BlockData>,
+) -> Result<Vec<VarInt>, WorldError> {
     let mut new_palette = Vec::new();
     for palette in vanilla_palettes {
         if let Some(id) = BLOCK2ID.get(&palette) {
@@ -135,17 +136,17 @@ impl VanillaChunk {
                 while i + bits_per_block < 64 {
                     let palette_index = read_nbit_i32(chunk, bits_per_block as usize, i as u32)?;
                     let block = match palette.get(palette_index as usize) {
-                        Some(block) => block,
+                        Some(block) => block.to_block_id(),
                         None => {
                             error!("Could not find block for palette index: {}", palette_index);
-                            &BlockData::default()
+                            BlockId::default()
                         }
                     };
 
-                    if let Some(count) = block_counts.get_mut(&block.to_block_id()) {
+                    if let Some(count) = block_counts.get_mut(&block) {
                         *count += 1;
                     } else {
-                        block_counts.insert(block.to_block_id(), 0);
+                        block_counts.insert(block, 0);
                     }
 
                     i += bits_per_block;
@@ -163,24 +164,8 @@ impl VanillaChunk {
             };
             // Count the number of blocks that are either air, void air, or cave air
             let mut air_blocks = *block_counts.get(&BlockId::default()).unwrap_or(&0) as u16;
-            air_blocks += *block_counts
-                .get(
-                    &BlockData {
-                        name: "minecraft:void_air".to_string(),
-                        properties: None,
-                    }
-                    .to_block_id(),
-                )
-                .unwrap_or(&0) as u16;
-            air_blocks += *block_counts
-                .get(
-                    &BlockData {
-                        name: "minecraft:cave_air".to_string(),
-                        properties: None,
-                    }
-                    .to_block_id(),
-                )
-                .unwrap_or(&0) as u16;
+            air_blocks += *block_counts.get(&block!("void_air")).unwrap_or(&0) as u16;
+            air_blocks += *block_counts.get(&block!("cave_air")).unwrap_or(&0) as u16;
             let non_air_blocks = 4096 - air_blocks;
             let block_states = BlockStates {
                 block_counts,
@@ -253,6 +238,7 @@ impl Chunk {
         for section in &mut sections {
             section.optimise().expect("Failed to optimise section");
         }
+        block!("stone");
         Chunk {
             x,
             z,
@@ -266,7 +252,6 @@ impl Chunk {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::block_id::BlockId;
     use ferrumc_macros::block;
 
     #[test]
@@ -322,11 +307,7 @@ mod tests {
     #[test]
     fn test_false_positive() {
         let mut chunk = Chunk::new(0, 0, "overworld".to_string());
-        let block = BlockData {
-            name: "minecraft:stone".to_string(),
-            properties: None,
-        }
-        .to_block_id();
+        let block = block!("stone");
         chunk.set_block(0, 0, 0, block).unwrap();
         assert_ne!(chunk.get_block(0, 1, 0).unwrap(), block);
     }

src/lib/world/src/edits.rs

@@ -1,10 +1,8 @@
-use crate::block_id::{BlockId, BLOCK2ID, ID2BLOCK};
+use crate::block_id::{BlockId, ID2BLOCK};
 use crate::chunk_format::{BlockStates, Chunk, PaletteType, Section};
 use crate::errors::WorldError;
-use crate::vanilla_chunk_format::BlockData;
 use crate::World;
 use ferrumc_general_purpose::data_packing::i32::read_nbit_i32;
-use ferrumc_net_codec::net_types::var_int::VarInt;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -94,20 +92,10 @@ impl BlockStates {
     pub fn resize(&mut self, new_bit_size: usize) -> Result<(), WorldError> {
         match &mut self.block_data {
             PaletteType::Single(val) => {
-                let block = ID2BLOCK
-                    .get(val.0 as usize)
-                    .cloned()
-                    .unwrap_or(BlockData::default());
-                let mut new_palette = vec![VarInt::from(0); 1];
-                if let Some(id) = BLOCK2ID.get(&block) {
-                    new_palette[0] = VarInt::from(*id);
-                } else {
-                    error!("Could not find block id for palette entry: {:?}", block);
-                }
                 self.block_data = PaletteType::Indirect {
                     bits_per_block: new_bit_size as u8,
                     data: vec![],
-                    palette: new_palette,
+                    palette: vec![*val; 1],
                 }
             }
             PaletteType::Indirect {
@@ -224,7 +212,6 @@ impl Chunk {
     /// the coordinates to section coordinates isn't really necessary, but you should probably do it
     /// anyway for readability's sake.
     pub fn set_block(&mut self, x: i32, y: i32, z: i32, block: BlockId) -> Result<(), WorldError> {
-        let block = block.into();
         // Get old block
         let old_block = self.get_block(x, y, z)?;
         if old_block == block {

src/lib/world/src/errors.rs

@@ -1,5 +1,5 @@
+use crate::block_id::BlockId;
 use crate::errors::WorldError::{CompressionError, GenericIOError, PermissionError};
-use crate::vanilla_chunk_format::BlockData;
 use errors::AnvilError;
 use ferrumc_anvil::errors;
 use ferrumc_general_purpose::data_packing::errors::DataPackingError;
@@ -37,7 +37,7 @@ pub enum WorldError {
     #[error("Anvil Decode Error: {0}")]
     AnvilDecodeError(AnvilError),
     #[error("Missing block mapping: {0}")]
-    MissingBlockMapping(BlockData),
+    MissingBlockMapping(BlockId),
     #[error("Invalid memory map size: {0}")]
     InvalidMapSize(u64),
     #[error("Task Join Error: {0}")]
@@ -47,7 +47,7 @@ pub enum WorldError {
     #[error("Invalid block state data")]
     InvalidBlockStateData(String),
     #[error("Invalid block: {0}")]
-    InvalidBlock(BlockData),
+    InvalidBlock(BlockId),
     #[error("Invalid batching operation: {0}")]
     InvalidBatchingOperation(String),
     #[error("Invalid block ID: {0}")]
@@ -68,7 +68,6 @@ impl From<std::io::Error> for WorldError {
     fn from(err: std::io::Error) -> Self {
         match err.kind() {
             ErrorKind::PermissionDenied => PermissionError(err.to_string()),
-            // ErrorKind::ReadOnlyFilesystem => PermissionError(err.to_string()),
             _ => GenericIOError(err.to_string()),
         }
     }