nucleation 0.1.140__tar.gz → 0.1.142__tar.gz

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

@@ -234,12 +234,14 @@ dependencies = [
 
 [[package]]
 name = "blockpedia"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9df0036f61590846453a0ed67c3df0b9f57ccb1184b8d91a1995a2e2cc9eaf74"
+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.140"
+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.140 → nucleation-0.1.142}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nucleation"
-version = "0.1.140"
+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.6", 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.140 → nucleation-0.1.142}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucleation
-Version: 0.1.140
+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.140 → nucleation-0.1.142}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "nucleation"
-version = "0.1.140"
+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.140 → 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.140",
+  "version": "0.1.142",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",

{nucleation-0.1.140 → nucleation-0.1.142}/src/formats/litematic.rs

@@ -446,7 +446,7 @@ mod tests {
         let mut region = Region::new("TestRegion".to_string(), (0, 0, 0), (2, 2, 2));
 
         let stone = BlockState::new("minecraft:stone".to_string());
-        let air = BlockState::new("minecraft:air".to_string());
+        let _air = BlockState::new("minecraft:air".to_string());
 
         region.set_block(0, 0, 0, &stone.clone());
         region.set_block(1, 1, 1, &stone.clone());
@@ -577,7 +577,7 @@ mod tests {
             .expect("Failed to write to file");
 
         // Read the .litematic file back
-        let loaded_litematic_data =
+        let _loaded_litematic_data =
             std::fs::read("simple_cube.litematic").expect("Failed to read file");
 
         // Clean up the generated file
@@ -592,7 +592,7 @@ mod tests {
         let mut region = Region::new("TestRegion".to_string(), (0, 0, 0), (2, 2, 2));
 
         let stone = BlockState::new("minecraft:stone".to_string());
-        let air = BlockState::new("minecraft:air".to_string());
+        let _air = BlockState::new("minecraft:air".to_string());
 
         region.set_block(0, 0, 0, &stone.clone());
         region.set_block(1, 1, 1, &stone.clone());

{nucleation-0.1.140 → 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;
 
@@ -120,10 +121,12 @@ pub fn from_mcstructure(data: &[u8]) -> Result<UniversalSchematic, Box<dyn std::
                 for (key, val) in states.iter() {
                     let val_str = match val {
                         NbtValue::Byte(b) => {
-                            if *b != 0 {
+                            if *b == 1 {
                                 "true".to_string()
-                            } else {
+                            } else if *b == 0 {
                                 "false".to_string()
+                            } else {
+                                b.to_string()
                             }
                         }
                         NbtValue::Int(i) => i.to_string(),
@@ -150,55 +153,73 @@ pub fn from_mcstructure(data: &[u8]) -> Result<UniversalSchematic, Box<dyn std::
         }
     }
 
-    // Parse Block Indices
+    // Construct Region
+    let mut region = Region::new("Main".to_string(), (0, 0, 0), (width, height, length));
+
+    // Parse Block Indices (Multi-layer support)
     let block_indices_list = match structure.get("block_indices") {
         Some(NbtValue::List(l)) => l,
         _ => return Err("Missing block_indices".into()),
     };
-    let mut indices_iter = block_indices_list.iter();
-    let primary_layer = indices_iter.next().ok_or("Missing primary layer")?;
-
-    let indices: Vec<i32> = match primary_layer {
-        NbtValue::List(list) => list
-            .iter()
-            .filter_map(|t| {
-                if let NbtValue::Int(i) = t {
-                    Some(*i)
-                } else {
-                    None
-                }
-            })
-            .collect(),
-        _ => return Err("Primary layer is not a list".into()),
-    };
-
-    // Construct Region
-    let mut region = Region::new("Main".to_string(), (0, 0, 0), (width, height, length));
-
-    // Set blocks
-    // Indices are ZYX order: X outer, Y middle, Z inner
-    // index = SZ*SY*X + SZ*Y + Z
-
-    for (i, &palette_idx) in indices.iter().enumerate() {
-        if palette_idx < 0 {
-            continue;
-        } // -1 is void/air-skip
-
-        let i = i as i32;
-        let sz = length;
-        let sy = height;
 
-        if sz == 0 || sy == 0 {
-            continue;
-        }
+    for layer in block_indices_list {
+        let indices: Vec<i32> = match layer {
+            NbtValue::List(list) => list
+                .iter()
+                .filter_map(|t| {
+                    if let NbtValue::Int(i) = t {
+                        Some(*i)
+                    } else {
+                        None
+                    }
+                })
+                .collect(),
+            _ => continue,
+        };
+
+        // Set blocks
+        // Indices are ZYX order: X outer, Y middle, Z inner
+        // index = SZ*SY*X + SZ*Y + Z
+        for (i, &palette_idx) in indices.iter().enumerate() {
+            if palette_idx < 0 {
+                continue;
+            } // -1 is void/air-skip
+
+            let i = i as i32;
+            let sz = length;
+            let sy = height;
+
+            if sz == 0 || sy == 0 {
+                continue;
+            }
 
-        let x = i / sz / sy;
-        let y = (i / sz) % sy;
-        let z = i % sz;
+            let x = i / sz / sy;
+            let y = (i / sz) % sy;
+            let z = i % sz;
+
+            if palette_idx < palette.len() as i32 {
+                let block = palette[palette_idx as usize].clone();
+
+                // Simple merge logic:
+                // If the block is water/lava and we already have a block here,
+                // try to set waterlogged=true instead of overwriting.
+                if (block.name == "minecraft:water" || block.name == "minecraft:flowing_water")
+                    && region.get_block(x, y, z).is_some()
+                {
+                    if let Some(existing_block) = region.get_block(x, y, z) {
+                        if existing_block.name != "minecraft:air" {
+                            let mut updated_block = existing_block.clone();
+                            updated_block
+                                .properties
+                                .insert("waterlogged".to_string(), "true".to_string());
+                            region.set_block(x, y, z, &updated_block);
+                            continue;
+                        }
+                    }
+                }
 
-        if palette_idx < palette.len() as i32 {
-            let block = palette[palette_idx as usize].clone();
-            region.set_block(x, y, z, &block);
+                region.set_block(x, y, z, &block);
+            }
         }
     }
 
@@ -226,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")
@@ -268,6 +301,10 @@ pub fn from_mcstructure(data: &[u8]) -> Result<UniversalSchematic, Box<dyn std::
 
     let mut schematic = UniversalSchematic::new("Unnamed".to_string());
     schematic.add_region(region);
+
+    // Post-fix redstone connectivity
+    schematic.fix_redstone_connectivity();
+
     Ok(schematic)
 }
 
@@ -433,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.140 → nucleation-0.1.142}/src/formats/schematic.rs

@@ -896,7 +896,7 @@ mod tests {
         let schem_data =
             fs::read(schem_path).expect(format!("Failed to read {}", input_path_str).as_str());
 
-        let mut schematic = from_schematic(&schem_data).expect("Failed to parse schematic");
+        let schematic = from_schematic(&schem_data).expect("Failed to parse schematic");
         assert_eq!(schematic.metadata.name, Some("Unnamed".to_string()));
     }
 

{nucleation-0.1.140 → nucleation-0.1.142}/src/region.rs

@@ -1282,7 +1282,7 @@ mod tests {
         for i in 1..=16 {
             palette.push(BlockState::new(format!("minecraft:wool{}", i)));
         }
-        let mut region = Region {
+        let region = Region {
             name: "Test".to_string(),
             position: (0, 0, 0),
             size: (16, 1, 1),
@@ -1715,7 +1715,7 @@ mod tests {
     fn test_coords_to_index() {
         let mut region = Region::new("Test".to_string(), (0, 0, 0), (2, 2, 2));
 
-        let mut volume1 = region.volume();
+        let volume1 = region.volume();
         for i in 0..8 {
             let coords = region.index_to_coords(i);
             let index = region.coords_to_index(coords.0, coords.1, coords.2);
@@ -1725,7 +1725,7 @@ mod tests {
 
         let region2 = Region::new("Test".to_string(), (0, 0, 0), (-2, -2, -2));
 
-        let mut volume2 = region2.volume();
+        let volume2 = region2.volume();
         for i in 0..8 {
             let coords = region2.index_to_coords(i);
             let index = region2.coords_to_index(coords.0, coords.1, coords.2);
@@ -1735,7 +1735,7 @@ mod tests {
 
         region.merge(&region2);
 
-        let mut volume3 = region.volume();
+        let volume3 = region.volume();
         for i in 0..27 {
             let coords = region.index_to_coords(i);
             let index = region.coords_to_index(coords.0, coords.1, coords.2);

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

@@ -567,6 +567,150 @@ impl UniversalSchematic {
         }
     }
 
+    pub fn fix_redstone_connectivity(&mut self) {
+        let regions: Vec<String> = self.get_all_regions().keys().cloned().collect();
+        for region_name in regions {
+            self.fix_redstone_connectivity_for_region(&region_name);
+        }
+    }
+
+    pub fn fix_redstone_connectivity_for_region(&mut self, region_name: &str) {
+        let (min, max) = {
+            let region = match self.get_region(region_name) {
+                Some(r) => r,
+                None => return,
+            };
+            let (width, height, length) = region.size;
+            let (pos_x, pos_y, pos_z) = region.position;
+            (
+                (pos_x, pos_y, pos_z),
+                (pos_x + width, pos_y + height, pos_z + length),
+            )
+        };
+
+        for y in min.1..max.1 {
+            for x in min.0..max.0 {
+                for z in min.2..max.2 {
+                    let block = match self.get_block_from_region(region_name, x, y, z) {
+                        Some(b) if b.name == "minecraft:redstone_wire" => b.clone(),
+                        _ => continue,
+                    };
+
+                    let mut new_block = block.clone();
+                    let directions = [
+                        ("north", 0, -1),
+                        ("south", 0, 1),
+                        ("east", 1, 0),
+                        ("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)
+                        {
+                            "side"
+                        } else if self.should_connect_redstone_up(region_name, x, y, z, dx, dz) {
+                            "up"
+                        } else {
+                            "none"
+                        };
+
+                        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);
+                }
+            }
+        }
+    }
+
+    fn should_connect_redstone(
+        &self,
+        region_name: &str,
+        x: i32,
+        y: i32,
+        z: i32,
+        dx: i32,
+        dz: i32,
+    ) -> bool {
+        // Same level
+        if let Some(neighbor) = self.get_block_from_region(region_name, x + dx, y, z + dz) {
+            if is_redstone_connectable(neighbor) {
+                return true;
+            }
+        }
+        // One level down
+        if let Some(neighbor_down) = self.get_block_from_region(region_name, x + dx, y - 1, z + dz)
+        {
+            if neighbor_down.name == "minecraft:redstone_wire" {
+                // Only if the block above neighbor_down is air or non-opaque
+                if let Some(above_neighbor_down) =
+                    self.get_block_from_region(region_name, x + dx, y, z + dz)
+                {
+                    if !is_opaque(above_neighbor_down) {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
+    }
+
+    fn should_connect_redstone_up(
+        &self,
+        region_name: &str,
+        x: i32,
+        y: i32,
+        z: i32,
+        dx: i32,
+        dz: i32,
+    ) -> bool {
+        // One level up
+        // Only if the block above the current wire is not opaque
+        if let Some(above_current) = self.get_block_from_region(region_name, x, y + 1, z) {
+            if is_opaque(above_current) {
+                return false;
+            }
+        }
+
+        if let Some(neighbor_up) = self.get_block_from_region(region_name, x + dx, y + 1, z + dz) {
+            if neighbor_up.name == "minecraft:redstone_wire" {
+                return true;
+            }
+        }
+        false
+    }
+
     pub fn get_merged_region(&self) -> Region {
         let mut merged_region = self.default_region.clone();
 
@@ -1958,6 +2102,40 @@ impl UniversalSchematic {
     }
 }
 
+pub fn is_redstone_connectable(block: &BlockState) -> bool {
+    let name = block.name.as_str();
+    name == "minecraft:redstone_wire"
+        || name == "minecraft:repeater"
+        || name == "minecraft:comparator"
+        || name == "minecraft:observer"
+        || name == "minecraft:target"
+}
+
+pub fn is_opaque(block: &BlockState) -> bool {
+    let name = block.name.as_str();
+    // Simplified opaque check - most common non-opaque blocks
+    !(name == "minecraft:air"
+        || name == "minecraft:cave_air"
+        || name == "minecraft:void_air"
+        || name.contains("glass")
+        || name.contains("slab")
+        || name.contains("stairs")
+        || name.contains("fence")
+        || name.contains("wall")
+        || name.contains("iron_bars")
+        || name.contains("door")
+        || name.contains("trapdoor")
+        || name.contains("torch")
+        || name.contains("button")
+        || name.contains("pressure_plate")
+        || name.contains("sign")
+        || name == "minecraft:redstone_wire"
+        || name == "minecraft:repeater"
+        || name == "minecraft:comparator"
+        || name == "minecraft:lever"
+        || name == "minecraft:hopper")
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;