Use FxHash

noita-proxy/Cargo.lock

@@ -1820,6 +1820,7 @@ dependencies = [
  "poll-promise",
  "rand",
  "reqwest",
+ "rustc-hash",
  "self-replace",
  "serde",
  "serde_json",
@@ -2491,6 +2492,12 @@ version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
 [[package]]
 name = "rustix"
 version = "0.38.34"

noita-proxy/Cargo.toml

@@ -33,6 +33,7 @@ image = { version = "0.25.1", default_features = false, features = ["png"] }
 egui_extras = { version = "*", features = ["all_loaders"] }
 bytemuck = { version = "1.16.0", features = ["derive"] }
 bincode = "1.3.3"
+rustc-hash = "1.1.0"
 
 [profile.dev]
 opt-level = 1

noita-proxy/src/net/world.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::{fs::File, io::BufWriter};
+use world_model::WorldModel;
 
 pub use world_model::encoding::NoitaWorldUpdate;
 
@@ -12,22 +13,25 @@ pub enum WorldUpdateKind {
 }
 
 pub struct WorldManager {
-    pub(crate) writer: BufWriter<File>,
+    // pub(crate) writer: BufWriter<File>,
+    model: WorldModel,
 }
 
 impl WorldManager {
     pub fn new() -> Self {
         Self {
-            writer: BufWriter::new(File::create("worldlog.bin").unwrap()),
+            // writer: BufWriter::new(File::create("worldlog.bin").unwrap()),
+            model: WorldModel::new(),
         }
     }
 
     pub fn add_update(&mut self, update: NoitaWorldUpdate) {
-        bincode::serialize_into(&mut self.writer, &WorldUpdateKind::Update(update)).unwrap();
+        // bincode::serialize_into(&mut self.writer, &WorldUpdateKind::Update(update)).unwrap();
+        self.model.apply_noita_update(&update);
     }
 
     pub fn add_end(&mut self) {
-        bincode::serialize_into(&mut self.writer, &WorldUpdateKind::End).unwrap();
+        // bincode::serialize_into(&mut self.writer, &WorldUpdateKind::End).unwrap();
     }
 }
 
@@ -43,6 +47,8 @@ mod test {
         let mut model = WorldModel::new();
         let mut model2 = WorldModel::new();
         let mut entry_id = 0;
+        let mut deltas_size = 0;
+
         while let Ok(entry) = bincode::deserialize_from::<_, WorldUpdateKind>(&mut file)
             .inspect_err(|e| println!("{}", e))
         {
@@ -59,7 +65,7 @@ mod test {
                         entry.header.w as u32 + 1,
                         entry.header.h as u32 + 1,
                     );
-                    // TODO
+
                     assert_eq!(entry, new_update);
                 }
                 WorldUpdateKind::End => {
@@ -70,6 +76,7 @@ mod test {
                         img.save(format!("/tmp/img_{}.png", entry_id)).unwrap();
                     }
                     let deltas = model.get_all_deltas();
+                    deltas_size += lz4_flex::compress_prepend_size(&bitcode::encode(&deltas)).len();
 
                     model.reset_change_tracking();
                     model2.apply_all_deltas(&deltas);
@@ -84,6 +91,7 @@ mod test {
         let img = model2.gen_image(x, y, 2048 * 2, 2048 * 2);
         img.save(format!("/tmp/img_model2.png")).unwrap();
 
+        println!("Deltas: {} bytes", deltas_size)
         // let mut mats = model.mats.iter().copied().collect::<Vec<_>>();
         // mats.sort();
         // for mat in mats {

noita-proxy/src/net/world/world_model.rs

@@ -1,7 +1,9 @@
+use bitcode::{Decode, Encode};
 use chunk::{Chunk, Pixel, PixelFlags};
 use encoding::{NoitaWorldUpdate, PixelRun, PixelRunner};
 use image::{Rgb, RgbImage};
-use std::collections::{HashMap, HashSet};
+use rustc_hash::{FxHashMap, FxHashSet};
+use std::collections::HashSet;
 
 mod chunk;
 pub mod encoding;
@@ -11,8 +13,8 @@ const CHUNK_SIZE: usize = 256;
 type ChunkCoord = (i32, i32);
 
 pub struct WorldModel {
-    chunks: HashMap<ChunkCoord, Chunk>,
-    pub mats: HashSet<u16>,
+    chunks: FxHashMap<ChunkCoord, Chunk>,
+    pub mats: FxHashSet<u16>,
     palette: MatPalette,
     changed_chunks: HashSet<ChunkCoord>,
 }
@@ -21,7 +23,7 @@ struct MatPalette {
     colors: Vec<Rgb<u8>>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Encode, Decode)]
 pub struct ChunkDelta {
     runs: Vec<PixelRun<Option<Pixel>>>,
     chunk_coord: (i32, i32),

noita-proxy/src/net/world/world_model/chunk.rs

@@ -1,6 +1,8 @@
+use bitcode::{Decode, Encode};
+
 use super::{encoding::RawPixel, CHUNK_SIZE};
 
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Encode, Decode)]
 pub enum PixelFlags {
     #[default]
     Unknown,
@@ -8,7 +10,7 @@ pub enum PixelFlags {
     Fluid,
 }
 
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Encode, Decode)]
 pub struct Pixel {
     pub flags: PixelFlags,
     pub material: u16,

noita-proxy/src/net/world/world_model/encoding.rs

@@ -1,9 +1,8 @@
+use bitcode::{Decode, Encode};
 use bytemuck::{bytes_of, pod_read_unaligned, AnyBitPattern, NoUninit};
 use serde::{Deserialize, Serialize};
 use std::mem::size_of;
 
-use super::chunk::Pixel;
-
 #[derive(Debug, Clone, Copy, AnyBitPattern, NoUninit, Serialize, Deserialize, PartialEq, Eq)]
 #[repr(C)]
 pub(crate) struct Header {
@@ -28,7 +27,7 @@ pub(crate) struct RawPixel {
 
 /// Stores a run of pixels.
 /// Not specific to Noita side - length is an actual length
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Encode, Decode)]
 pub struct PixelRun<Pixel> {
     pub length: u32,
     pub data: Pixel,

quant.ew/files/src/system/world_sync2.lua

@@ -45,7 +45,7 @@ function world_sync.on_world_update_host()
         end_y = end_y + 2
 
         local rectangle = rect.Rectangle(start_x, start_y, end_x, end_y)
-        -- rect_optimiser:submit(rectangle)
+        rect_optimiser:submit(rectangle)
     end
     for i = 0, tonumber(thread_impl.world_update_params_count) - 1 do
         local wup = thread_impl.world_update_params.begin[i]
@@ -55,7 +55,7 @@ function world_sync.on_world_update_host()
         local end_y = wup.update_region.bottom_right.y
 
         local rectangle = rect.Rectangle(start_x, start_y, end_x, end_y)
-        -- rect_optimiser:submit(rectangle)
+        rect_optimiser:submit(rectangle)
     end
 
     local px, py = EntityGetTransform(ctx.my_player.entity)
@@ -74,7 +74,7 @@ function world_sync.on_world_update_host()
         end
     end
 
-    if GameGetFrameNum() % 1 == 0 then
+    if GameGetFrameNum() % 10 == 0 then
         rect_optimiser:scan()
 
         for crect in rect.parts(rect_optimiser:iterate(), 256) do