more random stuff

Author: SubAt0m1c

src/dungeon/door.rs

@@ -118,7 +118,8 @@ impl Door {
             BlockPos { x: self.x + 1, y: 72, z: self.z + 1 },
 
             |x,y, z| {
-                world.set_block_at(Blocks::Barrier, x, y, z);
+//                world.set_block_at(Blocks::Barrier, x, y, z);
+                world.set_block_at(Blocks::Air, x, y, z);
                 world.interactable_blocks.remove(&BlockPos { x, y, z });
 
                 let id = world.spawn_entity(

src/net/client.rs

@@ -92,7 +92,7 @@ async fn read_packets(
             Status => parse_from_packets::<Status>(&mut buffer, client, context).await,
             Login => parse_from_packets::<Login>(&mut buffer, client, context).await,
             Play => {
-                match <Play as PacketDeserializable>::read(&mut buffer) {
+                match Play::read(&mut buffer) {
                     Ok(packet) => {
                         if let Err(err) = packet.process(client, context).await {
                             eprintln!("error processing {err}");

src/net/packets/packet_buffer.rs

@@ -1,3 +1,7 @@
+use std::mem::take;
+
+use bytes::BufMut;
+
 use crate::net::internal_packets::NetworkThreadMessage;
 use crate::net::packets::packet::IdentifiedPacket;
 use crate::net::packets::packet_serialize::PacketSerializable;
@@ -27,7 +31,6 @@ impl PacketBuffer {
         self.buffer.extend(payload);
     }
 
-    // this will be faster if we use a bytesmut instead of a vec<u8>
     pub fn copy_from(&mut self, buf: &PacketBuffer) {
         self.buffer.extend(&buf.buffer)
     }
@@ -36,7 +39,7 @@ impl PacketBuffer {
     pub fn get_packet_message(&mut self, client_id: &ClientId) -> NetworkThreadMessage {
         NetworkThreadMessage::SendPackets {
             client_id: *client_id,
-            buffer: std::mem::replace(&mut self.buffer, Vec::new()),
+            buffer: take(&mut self.buffer),
         }
     }
 }

src/net/protocol/play/clientbound.rs

@@ -99,16 +99,12 @@ packet_serializable! {
     }
 }
 
-
-
 packet_serializable! {
     pub struct KeepAlive {
         pub current_time: i32,
     }
 }
 
-
-
 packet_serializable! {
     pub struct Chat {
         pub component: ChatComponentText,

src/server/block/block_position.rs

@@ -39,7 +39,7 @@ impl BlockPos {
     }
 
     pub fn distance_to(&self, other: &BlockPos) -> f32 {
-        (self.distance_squared(self) as f32).sqrt()
+        (self.distance_squared(other) as f32).sqrt()
     }
 
     pub fn replace_y(&self, y: i32) -> Self {

src/server/commands/impl/mort.rs

@@ -10,7 +10,7 @@ pub struct Mort;
 impl CommandMetadata for Mort {
     const NAME: &'static str = "mort";
 
-    fn run(_: &mut World, player: &mut Player, _: &[&str]) -> anyhow::Result<Outcome> { ;
+    fn run(_: &mut World, player: &mut Player, _: &[&str]) -> anyhow::Result<Outcome> {
         player.open_ui(UI::MortReadyUpMenu);
         Ok(Outcome::Success)
     }

src/server/player/container_ui.rs

@@ -54,7 +54,7 @@ impl UI {
                     tag_compound: Some(NBT::with_nodes(vec![
                         NBT::compound("display", vec![
                             NBT::string("Name", &format!("§7{}", player.profile.username)),
-                            NBT::list_from_string("Lore", &format!("{}", item_name))
+                            NBT::list_from_string("Lore", &item_name.to_string())
                         ]),
                         NBT::string("SkullOwner", &player.profile.username),
                     ])),
@@ -97,7 +97,7 @@ impl UI {
                     player.sync_inventory();
                     return;
                 }
-                if player.inventory.click_slot(&packet, &mut player.packet_buffer) {
+                if player.inventory.click_slot(packet, &mut player.packet_buffer) {
                     player.sync_inventory();
                 }
             },

src/server/player/scoreboard.rs

@@ -120,7 +120,7 @@ impl Scoreboard {
             if i == 0 {
                 packet_buffer.write_packet(&ScoreboardObjective {
                     objective_name: OBJECTIVE_NAME.into(),
-                    objective_value: new_str.clone().into(),
+                    objective_value: new_str.clone(),
                     render_type: "integer",
                     mode: UPDATE_NAME,
                 });

src/server/server.rs

@@ -1,5 +1,3 @@
-use std::any::Any;
-
 use crate::dungeon::dungeon::Dungeon;
 use crate::net::internal_packets::{MainThreadMessage, NetworkThreadMessage};
 use crate::net::packets::packet::ProcessPacket;
@@ -14,7 +12,7 @@ use crate::server::utils::player_list::footer::footer;
 use crate::server::utils::player_list::header::header;
 use crate::server::world;
 use crate::server::world::World;
-use anyhow::{anyhow, Context, Result};
+use anyhow::{Context, Result};
 use tokio::sync::mpsc::UnboundedSender;
 use uuid::Uuid;
 

src/utils/hasher/deterministic_hasher.rs

@@ -1,11 +1,16 @@
-use crate::utils::hasher::rapidhash::{rapidhash_known, rapidhash_nano};
+use crate::utils::hasher::rapidhash::rapidhash_nano;
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hasher};
+use std::u64;
+
+use super::rapidhash::finish;
+
+const DEFAULT_SEED: u64 = 0;
 
 /// reimplementation of rapidhash nano from [GitHub](https://github.com/Nicoshev/rapidhash/blob/master/rapidhash.h#L432)
 /// (nano because were basically never gonna be hashing more than 48 bytes)
 /// probably overkill but its really fast and i was bored.
-#[derive(Default)]
+/// these hashes are NOT portable for primitive ints.
 pub struct RapidHasher {
     state: u64,
 }
@@ -17,15 +22,6 @@ pub struct RapidHasher {
 /// This should also be faster than the default so maybe it could be used in place of the default for anythign that doesnt need the added security of the default hashing.
 pub type DeterministicHashMap<K, V> = HashMap<K, V, RapidHasher>;
 
-macro_rules! write_num {
-    ($name: ident, $ty: ty) => {
-        #[inline(always)]
-        fn $name(&mut self, i: $ty) {
-            self.state = rapidhash_known(&i.to_le_bytes())
-        }
-    };
-}
-
 impl Hasher for RapidHasher {
     #[inline(always)]
     fn finish(&self) -> u64 {
@@ -34,28 +30,70 @@ impl Hasher for RapidHasher {
 
     #[inline(always)]
     fn write(&mut self, bytes: &[u8]) {
-        self.state = rapidhash_nano(bytes)
-    }
-
-    // these can be optimized down to not convert to and from their bytes...
-    write_num!(write_u8, u8);
-    write_num!(write_u16, u16);
-    write_num!(write_u32, u32);
-    write_num!(write_u64, u64);
-    write_num!(write_u128, u128);
-    write_num!(write_usize, usize);
-    write_num!(write_i8, i8);
-    write_num!(write_i16, i16);
-    write_num!(write_i32, i32);
-    write_num!(write_i64, i64);
-    write_num!(write_i128, i128);
-    write_num!(write_isize, isize);
+        self.state = rapidhash_nano(self.state, bytes)
+    }
+
+    #[inline(always)]
+    fn write_u8(&mut self, i: u8) {
+        let (a, b) = (((i as u64) << 45) | i as u64, i as u64);
+        self.state = finish(a, b, self.state, 1);
+    }
+
+    #[inline(always)]
+    fn write_u16(&mut self, i: u16) {
+        let (hi, lo) = ((i >> 8) as u64, (i & 0xFF) as u64);
+        self.state = finish((hi << 45) | lo, lo, self.state, 2);
+    }
+
+    #[inline(always)]
+    fn write_u32(&mut self, i: u32) {
+        self.state = write_32(self.state ^ 4, i);
+    }
+
+    #[inline(always)]
+    fn write_u64(&mut self, i: u64) {
+        self.state = write_64(self.state ^ 8, i);
+    }
+
+    #[inline(always)]
+    fn write_u128(&mut self, i: u128) {
+        let (a, b) = ((i >> 64) as u64, i as u64); // mask is done automatically by casting down
+        self.state = finish(a, b, self.state ^ 16, 16);
+    }
+
+    #[inline(always)]
+    fn write_usize(&mut self, i: usize) {
+        self.state = if size_of::<usize>() == 4 {
+            write_32(self.state ^ 4, i as u32)
+        } else {
+            write_64(self.state ^ 8, i as u64)
+        };
+    }
+}
+
+impl Default for RapidHasher {
+    fn default() -> Self {
+        Self {
+            state: DEFAULT_SEED
+        }
+    }
 }
 
+
 impl BuildHasher for RapidHasher {
     type Hasher = Self;
 
     fn build_hasher(&self) -> Self::Hasher {
         Self::default()
     }
+}
+
+#[inline(always)]
+const fn write_64(seed: u64, i: u64) -> u64 {
+    finish(i >> 32, i & 0xFFFF_FFFF, seed, 8)
+}
+
+#[inline(always)]
+const fn write_32(seed: u64, i: u32) -> u64 { // no mask stuff is needed since for 4 bits it just reads both as the same...
+    finish(i as u64, i as u64, seed, 4)
 }