nucleation 0.1.141__tar.gz → 0.1.142__tar.gz

{nucleation-0.1.141 → nucleation-0.1.142}/Cargo.lock

@@ -234,12 +234,14 @@ dependencies = [
 
 [[package]]
 name = "blockpedia"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fd332d4a740078986617b2989e8d285b8e7b5e113b86732dbfd0fe168a0f878"
+checksum = "616422e09c183aa4dca9b226ac5a12766df2bb69f7a570ea3a9785e3a8d35ba1"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
+ "fastnbt",
+ "flate2",
  "image",
  "js-sys",
  "palette",
@@ -247,6 +249,7 @@ dependencies = [
  "phf_codegen",
  "serde",
  "serde-wasm-bindgen 0.6.5",
+ "serde_bytes",
  "serde_json",
  "thiserror 1.0.69",
  "tokio",
@@ -953,6 +956,18 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd2e7510819d6fbf51a5545c8f922716ecfb14df168a3242f7d33e0239efe6a1"
 
+[[package]]
+name = "fastnbt"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29e3bb1f9ba8b6dbb35d89b415216041c2cad0c3e0b329db85ef5d4fc9e80cd6"
+dependencies = [
+ "byteorder",
+ "cesu8",
+ "serde",
+ "serde_bytes",
+]
+
 [[package]]
 name = "fastrand"
 version = "2.3.0"
@@ -1845,7 +1860,7 @@ dependencies = [
 
 [[package]]
 name = "nucleation"
-version = "0.1.141"
+version = "0.1.142"
 dependencies = [
  "base64",
  "blockpedia",
@@ -2757,6 +2772,16 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"

{nucleation-0.1.141 → nucleation-0.1.142}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nucleation"
-version = "0.1.141"
+version = "0.1.142"
 edition = "2021"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = ["Nano nano@schem.at"]
@@ -44,7 +44,7 @@ flate2 = "1.1.2"
 log = "0.4.22"
 console = "0.15.8"
 insign = "0.1.1"
-blockpedia = { version = "0.1.7", default-features = false, features = ["wasm"] }
+blockpedia = { version = "0.1.8", default-features = false, features = ["wasm"] }
 
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 hematite-nbt = "*"

{nucleation-0.1.141 → nucleation-0.1.142}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucleation
-Version: 0.1.141
+Version: 0.1.142
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3

{nucleation-0.1.141 → nucleation-0.1.142}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "nucleation"
-version = "0.1.141"
+version = "0.1.142"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = [{ name = "Nano", email = "nano@schem.at" }]
 license = { text = "AGPL-3.0-only" }

{nucleation-0.1.141 → nucleation-0.1.142}/release-artifacts/package.json

@@ -5,7 +5,7 @@
     "Nano nano@schem.at"
   ],
   "description": "A high-performance Minecraft schematic parser and utility library",
-  "version": "0.1.141",
+  "version": "0.1.142",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

{nucleation-0.1.141 → nucleation-0.1.142}/src/formats/mcstructure.rs

@@ -7,6 +7,7 @@ use crate::region::Region;
 use crate::universal_schematic::UniversalSchematic;
 use crate::BlockState;
 use blockpedia;
+use blockpedia::block_entity::{BlockEntityTranslator, NbtValue as BpNbtValue};
 use std::collections::HashMap;
 use std::io::Cursor;
 
@@ -246,6 +247,18 @@ pub fn from_mcstructure(data: &[u8]) -> Result<UniversalSchematic, Box<dyn std::
                             be_nbt.insert("y".to_string(), NbtValue::Int(y));
                             be_nbt.insert("z".to_string(), NbtValue::Int(z));
 
+                            // Translate NBT using Blockpedia
+                            let bp_nbt = to_bp_nbt(&NbtValue::Compound(be_nbt.clone()));
+                            if let BpNbtValue::Compound(bp_map) = bp_nbt {
+                                let translated_bp_map =
+                                    BlockEntityTranslator::translate_bedrock_to_java(&bp_map);
+                                if let NbtValue::Compound(translated_map) =
+                                    from_bp_nbt(&BpNbtValue::Compound(translated_bp_map))
+                                {
+                                    be_nbt = translated_map;
+                                }
+                            }
+
                             // Extract ID and Pos for BlockEntity constructor
                             let id = be_nbt
                                 .get("id")
@@ -457,3 +470,49 @@ pub fn to_mcstructure(
 
     Ok(cursor.into_inner())
 }
+
+fn to_bp_nbt(val: &NbtValue) -> BpNbtValue {
+    match val {
+        NbtValue::Byte(v) => BpNbtValue::Byte(*v),
+        NbtValue::Short(v) => BpNbtValue::Short(*v),
+        NbtValue::Int(v) => BpNbtValue::Int(*v),
+        NbtValue::Long(v) => BpNbtValue::Long(*v),
+        NbtValue::Float(v) => BpNbtValue::Float(*v),
+        NbtValue::Double(v) => BpNbtValue::Double(*v),
+        NbtValue::String(v) => BpNbtValue::String(v.clone()),
+        NbtValue::ByteArray(v) => BpNbtValue::ByteArray(v.clone()),
+        NbtValue::IntArray(v) => BpNbtValue::IntArray(v.clone()),
+        NbtValue::LongArray(v) => BpNbtValue::LongArray(v.clone()),
+        NbtValue::List(v) => BpNbtValue::List(v.iter().map(to_bp_nbt).collect()),
+        NbtValue::Compound(v) => {
+            let mut map = HashMap::new();
+            for (k, val) in v.iter() {
+                map.insert(k.clone(), to_bp_nbt(val));
+            }
+            BpNbtValue::Compound(map)
+        }
+    }
+}
+
+fn from_bp_nbt(val: &BpNbtValue) -> NbtValue {
+    match val {
+        BpNbtValue::Byte(v) => NbtValue::Byte(*v),
+        BpNbtValue::Short(v) => NbtValue::Short(*v),
+        BpNbtValue::Int(v) => NbtValue::Int(*v),
+        BpNbtValue::Long(v) => NbtValue::Long(*v),
+        BpNbtValue::Float(v) => NbtValue::Float(*v),
+        BpNbtValue::Double(v) => NbtValue::Double(*v),
+        BpNbtValue::String(v) => NbtValue::String(v.clone()),
+        BpNbtValue::ByteArray(v) => NbtValue::ByteArray(v.clone()),
+        BpNbtValue::IntArray(v) => NbtValue::IntArray(v.clone()),
+        BpNbtValue::LongArray(v) => NbtValue::LongArray(v.clone()),
+        BpNbtValue::List(v) => NbtValue::List(v.iter().map(from_bp_nbt).collect()),
+        BpNbtValue::Compound(v) => {
+            let mut map = NbtMap::new();
+            for (k, val) in v {
+                map.insert(k.clone(), from_bp_nbt(val));
+            }
+            NbtValue::Compound(map)
+        }
+    }
+}

{nucleation-0.1.141 → nucleation-0.1.142}/src/universal_schematic.rs

@@ -604,6 +604,9 @@ impl UniversalSchematic {
                         ("west", -1, 0),
                     ];
 
+                    let mut connection_states = Vec::new();
+                    let mut connected_count = 0;
+
                     for (dir, dx, dz) in directions {
                         let side_val = if self.should_connect_redstone(region_name, x, y, z, dx, dz)
                         {
@@ -613,10 +616,38 @@ impl UniversalSchematic {
                         } else {
                             "none"
                         };
-                        new_block
-                            .properties
-                            .insert(dir.to_string(), side_val.to_string());
+
+                        if side_val != "none" {
+                            connected_count += 1;
+                        }
+                        connection_states.push((dir, side_val.to_string()));
+                    }
+
+                    // Fix single connection issue: if only 1 connected, opposite becomes side
+                    if connected_count == 1 {
+                        // Find the connected one
+                        if let Some(idx) =
+                            connection_states.iter().position(|(_, val)| val != "none")
+                        {
+                            // 0=north, 1=south, 2=east, 3=west
+                            // Opposites: 0<->1, 2<->3
+                            let opposite_idx = match idx {
+                                0 => 1,
+                                1 => 0,
+                                2 => 3,
+                                3 => 2,
+                                _ => unreachable!(),
+                            };
+
+                            // Force opposite to be "side"
+                            connection_states[opposite_idx].1 = "side".to_string();
+                        }
                     }
+
+                    for (dir, val) in connection_states {
+                        new_block.properties.insert(dir.to_string(), val);
+                    }
+
                     self.set_block_in_region(region_name, x, y, z, &new_block);
                 }
             }

nucleation-0.1.142/tests/bedrock_conversion_tests.rs

@@ -0,0 +1,118 @@
+use nucleation::formats::mcstructure::from_mcstructure;
+use nucleation::formats::schematic::to_schematic;
+use nucleation::nbt::NbtValue;
+use std::io::Write;
+use std::path::PathBuf;
+
+#[test]
+fn test_auto_register_conversion() {
+    let path =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/samples/auto_register.mcstructure");
+
+    if !path.exists() {
+        // Skip if file not present (e.g. CI)
+        return;
+    }
+
+    let data = std::fs::read(&path).expect("Failed to read file");
+    let schematic = from_mcstructure(&data).expect("Failed to import mcstructure");
+    let region = schematic.get_merged_region();
+    let palette = region.get_palette();
+
+    // 1. Check Comparators
+    let comparators: Vec<_> = palette
+        .iter()
+        .filter(|b| b.name == "minecraft:comparator")
+        .collect();
+
+    assert!(
+        !comparators.is_empty(),
+        "Should have translated comparators"
+    );
+
+    for comp in comparators {
+        assert!(
+            comp.properties.contains_key("facing"),
+            "Comparator missing facing: {:?}",
+            comp
+        );
+        assert!(
+            comp.properties.contains_key("mode"),
+            "Comparator missing mode: {:?}",
+            comp
+        );
+        assert!(
+            comp.properties.contains_key("powered"),
+            "Comparator missing powered: {:?}",
+            comp
+        );
+
+        let mode = comp.properties.get("mode").unwrap();
+        assert!(
+            mode == "compare" || mode == "subtract",
+            "Invalid mode: {}",
+            mode
+        );
+    }
+
+    // 2. Check Barrels (Items translation)
+    let barrels_count = region
+        .block_entities
+        .iter()
+        .filter(|(_, be)| be.id == "Barrel" || be.id == "minecraft:barrel")
+        .count();
+    assert!(barrels_count > 0, "Should have barrels");
+
+    for (_, be) in &region.block_entities {
+        if be.id.to_lowercase().contains("barrel") {
+            if let Some(NbtValue::List(items)) = be.nbt.get("Items") {
+                for item in items {
+                    if let NbtValue::Compound(c) = item {
+                        assert!(c.get("id").is_some(), "Item missing id: {:?}", c);
+                        assert!(
+                            c.get("Name").is_none(),
+                            "Item should not have Name: {:?}",
+                            c
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    // 3. Check Redstone connections
+    let redstone_wires: Vec<_> = palette
+        .iter()
+        .filter(|b| b.name == "minecraft:redstone_wire")
+        .collect();
+
+    for wire in redstone_wires {
+        let directions = ["north", "south", "east", "west"];
+        let mut connections = 0;
+        for dir in directions {
+            if let Some(val) = wire.properties.get(dir) {
+                if val != "none" {
+                    connections += 1;
+                }
+            }
+        }
+
+        // This assertion might fail for wires that are truly isolated (0 connections),
+        // but the fix ensures that if there is 1, it becomes 2.
+        // So connections can be 0 or >= 2. It cannot be 1.
+        assert!(
+            connections != 1,
+            "Redstone wire has exactly 1 connection: {:?}",
+            wire
+        );
+    }
+
+    // 4. Export to .schem
+    let schem_data = to_schematic(&schematic).expect("Failed to export to .schem");
+    let output_path =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/samples/auto_register.schem");
+    let mut file = std::fs::File::create(&output_path).expect("Failed to create output file");
+    file.write_all(&schem_data)
+        .expect("Failed to write to file");
+    println!("Exported converted schematic to: {:?}", output_path);
+}

{nucleation-0.1.141 → nucleation-0.1.142}/tests/mcstructure_tests.rs

@@ -60,8 +60,9 @@ fn test_mcstructure_properties() {
     props.insert("powered".to_string(), "true".to_string()); // Should become Byte(1)
     props.insert("layers".to_string(), "8".to_string()); // Should become Int(8)
 
+    // Use a custom block to avoid blockpedia validation stripping invalid properties for vanilla blocks
     let block = BlockState {
-        name: "minecraft:snow".to_string(),
+        name: "custom:snow_variant".to_string(),
         properties: props,
     };
 
@@ -72,7 +73,7 @@ fn test_mcstructure_properties() {
     let loaded = from_mcstructure(&data).expect("Failed to import");
 
     let loaded_block = loaded.get_block(0, 0, 0).unwrap();
-    assert_eq!(loaded_block.name, "minecraft:snow");
+    assert_eq!(loaded_block.name, "custom:snow_variant");
     assert_eq!(loaded_block.properties.get("facing").unwrap(), "north");
     assert_eq!(loaded_block.properties.get("powered").unwrap(), "true");
     assert_eq!(loaded_block.properties.get("layers").unwrap(), "8");

{nucleation-0.1.141 → nucleation-0.1.142}/release-artifacts/nucleation.d.ts

@@ -1314,16 +1314,16 @@ export interface InitOutput {
   readonly definitionregionwrapper_copy: (a: number) => number;
   readonly schematicwrapper_create_simulation_world: (a: number) => [number, number, number];
   readonly __wbg_blockposition_free: (a: number, b: number) => void;
-  readonly __wbg_blockstatewrapper_free: (a: number, b: number) => void;
   readonly __wbg_get_blockposition_x: (a: number) => number;
   readonly __wbg_get_blockposition_y: (a: number) => number;
   readonly __wbg_get_blockposition_z: (a: number) => number;
-  readonly __wbg_lazychunkiterator_free: (a: number, b: number) => void;
-  readonly __wbg_schematicwrapper_free: (a: number, b: number) => void;
   readonly __wbg_set_blockposition_x: (a: number, b: number) => void;
   readonly __wbg_set_blockposition_y: (a: number, b: number) => void;
   readonly __wbg_set_blockposition_z: (a: number, b: number) => void;
   readonly blockposition_new: (a: number, b: number, c: number) => number;
+  readonly __wbg_blockstatewrapper_free: (a: number, b: number) => void;
+  readonly __wbg_lazychunkiterator_free: (a: number, b: number) => void;
+  readonly __wbg_schematicwrapper_free: (a: number, b: number) => void;
   readonly blockstatewrapper_name: (a: number) => [number, number];
   readonly blockstatewrapper_new: (a: number, b: number) => number;
   readonly blockstatewrapper_properties: (a: number) => any;

{nucleation-0.1.141 → nucleation-0.1.142}/release-artifacts/nucleation_bg.wasm.d.ts

@@ -190,16 +190,16 @@ export const sortstrategywrapper_zyx: () => number;
 export const definitionregionwrapper_copy: (a: number) => number;
 export const schematicwrapper_create_simulation_world: (a: number) => [number, number, number];
 export const __wbg_blockposition_free: (a: number, b: number) => void;
-export const __wbg_blockstatewrapper_free: (a: number, b: number) => void;
 export const __wbg_get_blockposition_x: (a: number) => number;
 export const __wbg_get_blockposition_y: (a: number) => number;
 export const __wbg_get_blockposition_z: (a: number) => number;
-export const __wbg_lazychunkiterator_free: (a: number, b: number) => void;
-export const __wbg_schematicwrapper_free: (a: number, b: number) => void;
 export const __wbg_set_blockposition_x: (a: number, b: number) => void;
 export const __wbg_set_blockposition_y: (a: number, b: number) => void;
 export const __wbg_set_blockposition_z: (a: number, b: number) => void;
 export const blockposition_new: (a: number, b: number, c: number) => number;
+export const __wbg_blockstatewrapper_free: (a: number, b: number) => void;
+export const __wbg_lazychunkiterator_free: (a: number, b: number) => void;
+export const __wbg_schematicwrapper_free: (a: number, b: number) => void;
 export const blockstatewrapper_name: (a: number) => [number, number];
 export const blockstatewrapper_new: (a: number, b: number) => number;
 export const blockstatewrapper_properties: (a: number) => any;