Chunk structure rewrite

Cargo.toml

@@ -186,6 +186,7 @@ toml = "0.9.8"
 craftflow-nbt = "2.1.0"
 figment = { version = "0.10.19", features = ["toml", "env"] }
 simd-json = "0.17.0"
+bytemuck = { version = "1.24.0", features = ["extern_crate_alloc"] }
 
 # Bit manipulation
 byteorder = "1.5.0"

src/bin/src/packet_handlers/play_packets/place_block.rs

@@ -76,10 +76,7 @@ pub fn handle(
                         "overworld",
                     )
                     .expect("Failed to load or generate chunk");
-                    let Ok(block_clicked) = chunk.get_block(pos.chunk_block_pos()) else {
-                        debug!("Failed to get block at position: {}", pos);
-                        continue 'ev_loop;
-                    };
+                    let block_clicked = chunk.get_block(pos.chunk_block_pos());
                     trace!("Block clicked: {:?}", block_clicked);
                     // Use the face to determine the offset of the block to place
                     let offset_pos = pos
@@ -126,11 +123,7 @@ pub fn handle(
                         continue 'ev_loop;
                     }
 
-                    if let Err(err) = chunk.set_block(pos.chunk_block_pos(), *mapped_block_state_id)
-                    {
-                        error!("Failed to set block: {:?}", err);
-                        continue 'ev_loop;
-                    }
+                    chunk.set_block(pos.chunk_block_pos(), *mapped_block_state_id);
                     let ack_packet = BlockChangeAck {
                         sequence: event.sequence,
                     };

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

@@ -48,9 +48,7 @@ pub fn handle(
                         "overworld",
                     )
                     .expect("Failed to load or generate chunk");
-                    chunk
-                        .set_block(pos.chunk_block_pos(), BlockStateId::default())
-                        .map_err(BinaryError::World)?;
+                    chunk.set_block(pos.chunk_block_pos(), BlockStateId::default());
 
                     // Send block broken event for un-grounding system
                     block_break_events.write(BlockBrokenEvent { position: pos });

src/bin/src/systems/listeners/digging_system.rs

@@ -280,9 +280,7 @@ fn break_block(
     let pos: BlockPos = position.clone().into();
     let mut chunk = ferrumc_utils::world::load_or_generate_mut(&state.0, pos.chunk(), "overworld")
         .expect("Failed to load or generate chunk");
-    chunk
-        .set_block(pos.chunk_block_pos(), BlockStateId::default())
-        .map_err(BinaryError::World)?;
+    chunk.set_block(pos.chunk_block_pos(), BlockStateId::default());
 
     // Send block broken event for un-grounding system
     debug!("Sending BlockBrokenEvent for block at {:?}", pos.pos);

src/bin/src/systems/physics/collisions.rs

@@ -118,13 +118,12 @@ pub fn handle(
 
 pub fn is_solid_block(state: &GlobalState, pos: IVec3) -> bool {
     let chunk_coordinates = ChunkPos::from(pos.as_dvec3());
-    ferrumc_utils::world::load_or_generate_mut(state, chunk_coordinates, "overworld")
-        .expect("Failed to load or generate chunk")
-        .get_block(ChunkBlockPos::from(pos))
-        .map(|block_state| {
-            !match_block!("air", block_state)
-                && !match_block!("void_air", block_state)
-                && !match_block!("cave_air", block_state)
-        })
-        .unwrap_or(false)
+    let block_state =
+        ferrumc_utils::world::load_or_generate_mut(state, chunk_coordinates, "overworld")
+            .expect("Failed to load or generate chunk")
+            .get_block(ChunkBlockPos::from(pos));
+
+    !match_block!("air", block_state)
+        && !match_block!("void_air", block_state)
+        && !match_block!("air", block_state)
 }

src/bin/src/systems/physics/drag.rs

@@ -17,10 +17,10 @@ pub fn handle(
             let chunk =
                 ferrumc_utils::world::load_or_generate_mut(&state.0, chunk_pos, "overworld")
                     .expect("Failed to load or generate chunk");
-            let is_in_water = chunk
-                .get_block(ChunkBlockPos::from(pos.coords.as_ivec3()))
-                .map(|block| match_block!("water", block))
-                .unwrap_or(false);
+            let is_in_water = match_block!(
+                "water",
+                chunk.get_block(ChunkBlockPos::from(pos.coords.as_ivec3()))
+            );
             if is_in_water {
                 vel.y *= 0.98;
                 vel.x *= 0.91;

src/lib/net/crates/codec/src/encode/primitives.rs

@@ -2,8 +2,10 @@ use crate::encode::errors::NetEncodeError;
 use crate::encode::AsyncWrite;
 use crate::encode::{NetEncode, NetEncodeOpts};
 use crate::net_types::var_int::VarInt;
+use std::borrow::Cow;
 use std::collections::HashMap;
 use std::io::Write;
+use std::ops::Deref;
 use tokio::io::AsyncWriteExt;
 
 macro_rules! impl_for_primitives {
@@ -134,6 +136,7 @@ impl NetEncode for &[u8] {
         }
 
         writer.write_all(self)?;
+
         Ok(())
     }
     async fn encode_async<W: AsyncWrite + Unpin>(
@@ -147,20 +150,20 @@ impl NetEncode for &[u8] {
         }
 
         writer.write_all(self).await?;
+
         Ok(())
     }
 }
 
-impl NetEncode for &[&str] {
+impl NetEncode for [u8] {
     fn encode<W: Write>(&self, writer: &mut W, opts: &NetEncodeOpts) -> Result<(), NetEncodeError> {
         if matches!(opts, NetEncodeOpts::SizePrefixed) {
             let len: VarInt = VarInt::new(self.len() as i32);
             len.encode(writer, opts)?;
         }
 
-        for item in *self {
-            item.encode(writer, opts)?;
-        }
+        writer.write_all(self)?;
+
         Ok(())
     }
     async fn encode_async<W: AsyncWrite + Unpin>(
@@ -173,13 +176,26 @@ impl NetEncode for &[&str] {
             len.encode_async(writer, opts).await?;
         }
 
-        for item in *self {
-            item.encode_async(writer, opts).await?;
-        }
+        writer.write_all(self).await?;
+
         Ok(())
     }
 }
 
+impl<T: NetEncode + ?Sized + ToOwned> NetEncode for Cow<'_, T> {
+    fn encode<W: Write>(&self, writer: &mut W, opts: &NetEncodeOpts) -> Result<(), NetEncodeError> {
+        self.deref().encode(writer, opts)
+    }
+
+    async fn encode_async<W: AsyncWrite + Unpin>(
+        &self,
+        writer: &mut W,
+        opts: &NetEncodeOpts,
+    ) -> Result<(), NetEncodeError> {
+        self.deref().encode_async(writer, opts).await
+    }
+}
+
 impl<T: NetEncode> NetEncode for Option<T> {
     fn encode<W: Write>(&self, writer: &mut W, opts: &NetEncodeOpts) -> Result<(), NetEncodeError> {
         match self {

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

@@ -2,6 +2,7 @@ pub mod angle;
 pub mod bitset;
 pub mod byte_array;
 pub mod length_prefixed_vec;
+pub mod net_array;
 pub mod network_position;
 pub mod prefixed_optional;
 pub mod teleport_flags;

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

@@ -0,0 +1,54 @@
+use crate::encode::errors::NetEncodeError;
+use crate::encode::{NetEncode, NetEncodeOpts};
+use crate::net_types::var_int::VarInt;
+use std::borrow::Cow;
+use std::io::Write;
+use tokio::io::AsyncWrite;
+
+pub struct NetworkArray<'data, T: NetEncode + ToOwned + Clone>(Cow<'data, [T]>);
+
+impl<'data, T: NetEncode + ToOwned + Clone> NetworkArray<'data, T> {
+    pub fn new_borrowed(data: &'data [T]) -> Self {
+        NetworkArray(Cow::Borrowed(data))
+    }
+
+    pub fn new_owned(data: <[T] as ToOwned>::Owned) -> Self {
+        NetworkArray(Cow::Owned(data))
+    }
+
+    pub fn into_inner(self) -> <[T] as ToOwned>::Owned {
+        self.0.into_owned()
+    }
+}
+
+impl<'data, T: NetEncode + ToOwned + Clone> NetEncode for NetworkArray<'data, T> {
+    fn encode<W: Write>(&self, writer: &mut W, opts: &NetEncodeOpts) -> Result<(), NetEncodeError> {
+        if matches!(opts, NetEncodeOpts::SizePrefixed) {
+            let len: VarInt = VarInt::new(self.0.len() as i32);
+            len.encode(writer, opts)?;
+        }
+
+        for item in self.0.iter() {
+            item.encode(writer, opts)?;
+        }
+
+        Ok(())
+    }
+
+    async fn encode_async<W: AsyncWrite + Unpin>(
+        &self,
+        writer: &mut W,
+        opts: &NetEncodeOpts,
+    ) -> Result<(), NetEncodeError> {
+        if matches!(opts, NetEncodeOpts::SizePrefixed) {
+            let len: VarInt = VarInt::new(self.0.len() as i32);
+            len.encode_async(writer, opts).await?;
+        }
+
+        for item in self.0.iter() {
+            item.encode_async(writer, opts).await?;
+        }
+
+        Ok(())
+    }
+}