fix: bedrock SActorEvent packet

Author: Snowiiii

pumpkin-protocol/src/bedrock/server/actor_event.rs

@@ -1,4 +1,4 @@
-use crate::serial::PacketWrite;
+use crate::{codec::var_long::VarLong, serial::PacketWrite};
 use std::io::{Error, Write};
 
 use pumpkin_macros::packet;
@@ -9,7 +9,7 @@ use crate::codec::var_int::VarInt;
 #[derive(Debug, PacketWrite)]
 #[packet(27)]
 pub struct SActorEvent {
-    pub entity_runtime_id: VarInt,
+    pub entity_runtime_id: VarLong,
     pub event_type: ActorEventType,
     pub event_data: VarInt,
     pub fire_at_position: Option<Vector3<f32>>,

pumpkin-protocol/src/java/client/config/registry_data.rs

@@ -5,38 +5,26 @@ use crate::{
     codec::var_int::VarInt,
     ser::{NetworkWriteExt, WritingError},
 };
-use pumpkin_data::packet::clientbound::CONFIG_REGISTRY_DATA;
+use pumpkin_data::{packet::clientbound::CONFIG_REGISTRY_DATA, registry::RegistryEntryData};
 use pumpkin_macros::java_packet;
 use pumpkin_util::{resource_location::ResourceLocation, version::JavaMinecraftVersion};
 
 #[java_packet(CONFIG_REGISTRY_DATA)]
 pub struct CRegistryData<'a> {
     pub registry_id: &'a ResourceLocation,
-    pub entries: &'a [RegistryEntry],
+    pub entries: &'a [RegistryEntryData],
 }
 
 impl<'a> CRegistryData<'a> {
     #[must_use]
-    pub const fn new(registry_id: &'a ResourceLocation, entries: &'a [RegistryEntry]) -> Self {
+    pub const fn new(registry_id: &'a ResourceLocation, entries: &'a [RegistryEntryData]) -> Self {
         Self {
             registry_id,
             entries,
         }
     }
 }
 
-pub struct RegistryEntry {
-    pub entry_id: ResourceLocation,
-    pub data: Option<Box<[u8]>>,
-}
-
-impl RegistryEntry {
-    #[must_use]
-    pub const fn new(entry_id: ResourceLocation, data: Option<Box<[u8]>>) -> Self {
-        Self { entry_id, data }
-    }
-}
-
 impl ClientPacket for CRegistryData<'_> {
     fn write_packet_data(
         &self,

pumpkin-util/src/math/pool.rs

@@ -15,22 +15,28 @@ impl Pool {
     ///
     /// # Returns
     /// An `Option<E>` representing the selected element, or `None` if the distribution is empty.
-    pub fn get<E: Clone>(distribution: &[Weighted<E>], random: &mut RandomGenerator) -> Option<E> {
+    pub fn get<'a, E>(
+        distribution: &'a [Weighted<E>],
+        random: &mut RandomGenerator,
+    ) -> Option<&'a E> {
         let mut total_weight = 0;
         for dist in distribution {
             total_weight += dist.weight;
         }
+
         let mut index = random.next_bounded_i32(total_weight);
+
         if total_weight < 64 {
             return Some(FlattenedContent::get(index, distribution, total_weight));
         }
+
         // WrappedContent
         for dist in distribution {
             index -= dist.weight;
             if index >= 0 {
                 continue;
             }
-            return Some(dist.data.clone());
+            return Some(&dist.data);
         }
         None
     }
@@ -58,16 +64,17 @@ impl FlattenedContent {
     ///
     /// # Returns
     /// The element corresponding to the given index.
-    pub fn get<E: Clone>(index: i32, entries: &[Weighted<E>], total_weight: i32) -> E {
-        let mut final_entries = Vec::with_capacity(total_weight as usize);
+    pub fn get<E>(index: i32, entries: &[Weighted<E>], _total_weight: i32) -> &E {
         let mut cur_index = 0;
+
         for entry in entries {
             let weight = entry.weight;
-            for i in cur_index..cur_index + weight {
-                final_entries.insert(i as usize, entry.data.clone());
+            if index >= cur_index && index < cur_index + weight {
+                return &entry.data;
             }
             cur_index += weight;
         }
-        final_entries[index as usize].clone()
+
+        &entries[0].data
     }
 }

pumpkin-world/build.rs

@@ -21,11 +21,10 @@ fn main() {
 
         for (pool_id, elements) in pools {
             pool_code.push_str(&format!(
-                "        \"minecraft:{}\" | \"{}\" => Some(&[\n",
-                pool_id, pool_id
+                "        \"minecraft:{pool_id}\" | \"{pool_id}\" => Some(&[\n"
             ));
             for element in elements {
-                pool_code.push_str(&format!("            \"{}\",\n", element));
+                pool_code.push_str(&format!("            \"{element}\",\n"));
             }
             pool_code.push_str("        ]),\n");
         }
@@ -37,7 +36,7 @@ fn main() {
     pool_code.push_str("        _ => None,\n");
     pool_code.push_str("    }\n}\n");
 
-    fs::write(&dest_path, format!("{}\n{}", code, pool_code)).unwrap();
+    fs::write(&dest_path, format!("{code}\n{pool_code}")).unwrap();
     println!("cargo:rerun-if-changed=assets/structures");
 }
 
@@ -56,7 +55,7 @@ fn process_dir(
             let new_prefix = if prefix.is_empty() {
                 name
             } else {
-                format!("{}/{}", prefix, name)
+                format!("{prefix}/{name}")
             };
             process_dir(&path, &new_prefix, code, pools);
         } else if name.ends_with(".nbt") {

pumpkin-world/src/block/state.rs

@@ -11,19 +11,19 @@ impl RawBlockState {
 
     #[inline]
     #[must_use]
-    pub fn to_state(&self) -> &'static BlockState {
+    pub const fn to_state(&self) -> &'static BlockState {
         BlockState::from_id(self.0)
     }
 
     #[inline]
     #[must_use]
-    pub fn to_block(&self) -> &'static Block {
+    pub const fn to_block(&self) -> &'static Block {
         Block::from_state_id(self.0)
     }
 
     #[inline]
     #[must_use]
-    pub fn to_block_id(&self) -> u16 {
+    pub const fn to_block_id(&self) -> u16 {
         Block::get_raw_id_from_state_id(self.0)
     }
 }

pumpkin-world/src/generation/noise/router/chunk_density_function.rs

@@ -161,7 +161,7 @@ pub struct ChunkNoiseFunctionBuilderOptions {
 impl ChunkNoiseFunctionBuilderOptions {
     #[must_use]
     #[allow(clippy::too_many_arguments)]
-    pub fn new(
+    pub const fn new(
         horizontal_cell_block_count: usize,
         vertical_cell_block_count: usize,
         vertical_cell_count: usize,

pumpkin-world/src/generation/noise/router/density_function/beardifier.rs

@@ -114,7 +114,7 @@ pub struct Beardifier {
 }
 
 impl Beardifier {
-    pub fn new(
+    pub const fn new(
         structures: Vec<BeardifierStructure>,
         junctions: Vec<BeardifierJunction>,
         affected_box: Option<BlockBox>,

pumpkin-world/src/generation/noise/router/find_top_surface.rs

@@ -34,17 +34,17 @@ impl FindTopSurface {
     }
 
     #[must_use]
-    pub fn density_index(&self) -> usize {
+    pub const fn density_index(&self) -> usize {
         self.density_index
     }
 
     #[must_use]
-    pub fn upper_bound_index(&self) -> usize {
+    pub const fn upper_bound_index(&self) -> usize {
         self.upper_bound_index
     }
 
     #[must_use]
-    pub fn cell_height(&self) -> i32 {
+    pub const fn cell_height(&self) -> i32 {
         self.data.cell_height
     }
 }

pumpkin-world/src/generation/noise/router/proto_noise_router.rs

@@ -458,7 +458,7 @@ impl ProtoNoiseRouters {
                 } => {
                     let mut min_value = f64::INFINITY;
                     let mut max_value = f64::NEG_INFINITY;
-                    for &idx in functions_indices.iter() {
+                    for &idx in *functions_indices {
                         let min = stack[idx].min();
                         let max = stack[idx].max();
                         if min < min_value {

pumpkin-world/src/generation/proto_chunk.rs

@@ -348,7 +348,7 @@ impl ProtoChunk {
     }
 
     #[must_use]
-    pub fn get_top_y(&self, heightmap: &HeightMap, x: i32, z: i32) -> i32 {
+    pub const fn get_top_y(&self, heightmap: &HeightMap, x: i32, z: i32) -> i32 {
         match heightmap {
             HeightMap::WorldSurfaceWg => self.top_block_height_exclusive(x, z),
             HeightMap::WorldSurface => self.top_block_height_exclusive(x, z),
@@ -395,15 +395,15 @@ impl ProtoChunk {
     }
 
     #[inline]
-    fn local_pos_to_block_index(&self, x: i32, y: i32, z: i32) -> usize {
+    const fn local_pos_to_block_index(&self, x: i32, y: i32, z: i32) -> usize {
         self.height() as usize * CHUNK_DIM as usize * x as usize
             + CHUNK_DIM as usize * y as usize
             + z as usize
     }
 
     #[inline]
     #[must_use]
-    pub fn local_biome_pos_to_biome_index(&self, x: i32, y: i32, z: i32) -> usize {
+    pub const fn local_biome_pos_to_biome_index(&self, x: i32, y: i32, z: i32) -> usize {
         let biome_height = self.height() as usize >> 2;
         biome_height * biome_coords::from_block(CHUNK_DIM as i32) as usize * x as usize
             + biome_coords::from_block(CHUNK_DIM as i32) as usize * y as usize