feature/ng-chunk

.gitignore

@@ -18,7 +18,6 @@ result-*
 profile.json.gz
 .DS_Store
 
-/world
 whitelist.txt
 
 logs/

Cargo.toml

@@ -14,15 +14,12 @@ resolver = "2"
 members = [
     "src/bin",
     "src/lib/adapters/anvil",
-    "src/lib/adapters/anvil",
-    "src/lib/adapters/nbt",
     "src/lib/adapters/nbt",
     "src/lib/commands",
     "src/lib/default_commands",
     "src/lib/core",
     "src/lib/core/state",
     "src/lib/derive_macros",
-    "src/lib/derive_macros",
     "src/lib/net",
     "src/lib/net/crates/codec",
     "src/lib/net/crates/encryption",
@@ -39,6 +36,7 @@ members = [
     "src/lib/inventories",
     "src/lib/registry",
     "src/lib/scheduler",
+    "src/tests",
 ]
 
 #================== Lints ==================#
@@ -141,6 +139,7 @@ rand = "0.10.0-rc.0"
 fnv = "1.0.7"
 wyhash = "0.6.0"
 ahash = "0.8.12"
+cthash = "0.9.0"
 
 # Encoding/Serialization
 serde = { version = "1.0.228", features = ["derive"] }
@@ -196,14 +195,15 @@ colored = "3.0.0"
 deepsize = "0.2.0"
 page_size = "0.6.0"
 enum-ordinalize = "4.3.0"
-regex = "1.12.2"
-noise = "0.9.0"
-ctrlc = "3.5.0"
+regex = "1.11.1"
+ctrlc = "3.4.7"
 num_cpus = "1.17.0"
 typename = "0.1.2"
 bevy_ecs = { version = "0.16.1", features = ["multi_threaded", "trace"] }
 bevy_math = "0.16.1"
 once_cell = "1.21.3"
+itertools = "0.14.0"
+const-str = "0.7.0"
 
 # I/O
 memmap2 = "0.9.8"

src/bin/Cargo.toml

@@ -11,6 +11,7 @@ thiserror = { workspace = true }
 
 ferrumc-core = { workspace = true }
 bevy_ecs = { workspace = true }
+bevy_math = { workspace = true }
 ferrumc-scheduler = { workspace = true }
 
 ferrumc-net = { workspace = true }

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

@@ -48,7 +48,7 @@ pub fn handle(
         match event.hand.0 {
             0 => {
                 let slot_index = hotbar.selected_slot as usize;
-                let Ok(slot) = inventory.get_item(slot_index) else {
+                let Ok(slot) = inventory.get_item(slot_index + 36) else {
                     error!("Could not fetch {:?}", eid);
                     continue 'ev_loop;
                 };
@@ -78,9 +78,7 @@ pub fn handle(
                         }
                     };
                     let Ok(block_clicked) = chunk.get_block(
-                        event.position.x,
-                        event.position.y as i32,
-                        event.position.z,
+                        (event.position.x, event.position.y as i32, event.position.z).into(),
                     ) else {
                         debug!("Failed to get block at position: {:?}", event.position);
                         continue 'ev_loop;
@@ -131,9 +129,7 @@ pub fn handle(
                     }
 
                     if let Err(err) = chunk.set_block(
-                        x & 0xF,
-                        y as i32,
-                        z & 0xF,
+                        (x, y as i32, z).into(),
                         BlockStateId(*mapped_block_state_id as u32),
                     ) {
                         error!("Failed to set block: {:?}", err);

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

@@ -37,13 +37,10 @@ pub fn handle(
                                 .map_err(BinaryError::WorldGen)?
                         }
                     };
-                    let (relative_x, relative_y, relative_z) = (
-                        event.location.x.abs() % 16,
-                        event.location.y as i32,
-                        event.location.z.abs() % 16,
-                    );
+                    let relative =
+                        (event.location.x, event.location.y as i32, event.location.z).into();
                     chunk
-                        .set_block(relative_x, relative_y, relative_z, BlockStateId::default())
+                        .set_block(relative, BlockStateId::default())
                         .map_err(BinaryError::World)?;
                     // Save the chunk to disk
                     state

src/bin/src/packet_handlers/play_packets/player_loaded.rs

@@ -25,9 +25,12 @@ pub fn handle(
             continue;
         }
         let head_block = state.0.world.get_block_and_fetch(
-            player_pos.x as i32,
-            player_pos.y as i32,
-            player_pos.z as i32,
+            (
+                player_pos.x as i32,
+                player_pos.y as i32,
+                player_pos.z as i32,
+            )
+                .into(),
             "overworld",
         );
         if let Ok(head_block) = head_block {

src/lib/derive_macros/Cargo.toml

@@ -22,6 +22,11 @@ craftflow-nbt = { workspace = true }
 indexmap = { workspace = true, features = ["serde"] }
 bitcode = { workspace = true }
 simd-json = { workspace = true }
+phf = "0.13.1"
 
 [dev-dependencies]
 ferrumc-world = { workspace = true }
+
+[build-dependencies]
+phf_codegen = "0.13.1"
+simd-json = { workspace = true }

src/lib/derive_macros/build.rs

@@ -0,0 +1,80 @@
+use std::{
+    collections::{HashMap, HashSet},
+    env,
+    fs::File,
+    io::{BufWriter, Write},
+    path::Path,
+};
+
+use simd_json::{
+    self,
+    base::{ValueAsObject, ValueAsScalar},
+    derived::ValueTryAsObject,
+};
+
+const JSON_FILE: &[u8] = include_bytes!("../../../assets/data/blockstates.json");
+
+fn main() {
+    let mut buf = JSON_FILE.to_owned();
+    let v = simd_json::to_borrowed_value(&mut buf).unwrap();
+    let mut map = phf_codegen::Map::new();
+    let mut prop_map = phf_codegen::Map::new();
+    let mut rev_map: HashMap<String, Vec<u32>> = HashMap::new();
+    let mut rev_prop: HashMap<String, HashSet<String>> = HashMap::new();
+    for (key, value) in v.try_as_object().expect("object value") {
+        let id = key.parse::<u32>().expect("integer value");
+        let block = value.as_object().expect("object value");
+        let name = block
+            .get("name")
+            .expect("all block states have names")
+            .as_str()
+            .expect("names are strings")
+            .split_once("minecraft:")
+            .expect("names start with \"minecraft:\"")
+            .1;
+        let props = block.get("properties");
+        rev_map.entry(name.to_owned()).or_default().push(id);
+        rev_prop.entry(name.to_string()).or_default();
+        if let Some(props) = props {
+            for (prop_key, prop_val) in props.as_object().expect("properties is object") {
+                let map_key = format!("{}:{}", prop_key, prop_val);
+                rev_prop
+                    .entry(prop_key.to_string())
+                    .or_default()
+                    .insert(prop_val.to_string());
+                rev_prop
+                    .entry(name.to_string())
+                    .or_default()
+                    .insert(prop_key.to_string());
+                rev_map.entry(map_key).or_default().push(id);
+            }
+        }
+    }
+    for (k, v) in rev_map.iter_mut() {
+        v.sort();
+        map.entry(k.clone(), format!("&{:?}", v));
+    }
+
+    for (k, v) in rev_prop.iter() {
+        let mut v: Vec<String> = v.iter().cloned().collect();
+        v.sort();
+        prop_map.entry(k.clone(), format!("&{:?}", v));
+    }
+    let map = map.build();
+    let prop_map = prop_map.build();
+    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
+    let mut file = BufWriter::new(File::create(&path).unwrap());
+    writeln!(
+        &mut file,
+        "static BLOCK_STATES: phf::Map<&'static str, &[u16]> = {};",
+        map
+    )
+    .expect("able to write to file");
+    writeln!(
+        &mut file,
+        "static PROP_PARTS: phf::Map<&'static str, &[&'static str]> = {};",
+        prop_map
+    )
+    .expect("able to write to file");
+    println!("created {}", &path.to_string_lossy());
+}

src/lib/derive_macros/src/block/matches.rs

@@ -1,8 +1,6 @@
-use crate::block::JSON_FILE;
+use crate::block::BLOCK_STATES;
 use proc_macro::TokenStream;
 use quote::quote;
-use simd_json::base::{ValueAsObject, ValueAsScalar};
-use simd_json::derived::ValueObjectAccess;
 
 struct Input {
     name: String,
@@ -21,42 +19,32 @@ impl syn::parse::Parse for Input {
     }
 }
 
-// match_block!("stone", block_state_id); -> "if block_state_id == BlockStateId(1) { ... }
-// match_block!("dirt", block_state_id); -> "if block_name == BlockStateId( { ... }
 pub fn matches_block(input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as Input);
-    let block_name = &input.name;
-    let block_name = if block_name.starts_with("minecraft:") {
-        block_name.to_string()
-    } else {
-        format!("minecraft:{}", block_name)
-    };
-    let block_state_id_var = &input.id_var;
-    let mut buf = JSON_FILE.to_vec();
-    let v = simd_json::to_owned_value(&mut buf).unwrap();
-    let filtered_names = v
-        .as_object()
-        .unwrap()
-        .iter()
-        .filter(|(_, v)| v.get("name").as_str() == Some(&block_name))
-        .map(|(k, v)| (k.parse::<u32>().unwrap(), v))
-        .collect::<Vec<_>>();
-    if filtered_names.is_empty() {
+    let block_name = input
+        .name
+        .split_once("minecraft:")
+        .map(|x| x.1)
+        .unwrap_or(input.name.as_str());
+    let block_id_var = &input.id_var;
+
+    let states = BLOCK_STATES.get(block_name);
+    if states.is_none_or(|x| x.is_empty()) {
         return syn::Error::new_spanned(
             &input.id_var,
             format!("Block name '{}' not found in registry", block_name),
         )
         .to_compile_error()
         .into();
     }
-    let mut arms = Vec::new();
-    for (id, _) in filtered_names {
-        arms.push(quote! {
-            #block_state_id_var == BlockStateId(#id)
-        });
-    }
-    let joined = quote! {
-        #(#arms)||*
+
+    let states = states.unwrap().iter().map(|&x| x as u32);
+
+    let matched = quote! {
+        match #block_id_var {
+            BlockStateId(#(#states)|*) => true,
+            _ => false
+        }
     };
-    joined.into()
+    matched.into()
 }