nucleation 0.1.140__tar.gz → 0.1.141__tar.gz

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

@@ -234,9 +234,9 @@ dependencies = [
 
 [[package]]
 name = "blockpedia"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9df0036f61590846453a0ed67c3df0b9f57ccb1184b8d91a1995a2e2cc9eaf74"
+checksum = "9fd332d4a740078986617b2989e8d285b8e7b5e113b86732dbfd0fe168a0f878"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1845,7 +1845,7 @@ dependencies = [
 
 [[package]]
 name = "nucleation"
-version = "0.1.140"
+version = "0.1.141"
 dependencies = [
  "base64",
  "blockpedia",

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

@@ -1,6 +1,6 @@
 [package]
 name = "nucleation"
-version = "0.1.140"
+version = "0.1.141"
 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.7", default-features = false, features = ["wasm"] }
 
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 hematite-nbt = "*"

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

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

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

{nucleation-0.1.140 → nucleation-0.1.141}/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.141}/src/formats/mcstructure.rs

@@ -120,10 +120,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 +152,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);
+            }
         }
     }
 
@@ -268,6 +288,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)
 }
 

{nucleation-0.1.140 → nucleation-0.1.141}/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.141}/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.141}/src/universal_schematic.rs

@@ -567,6 +567,119 @@ 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),
+                    ];
+
+                    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"
+                        };
+                        new_block
+                            .properties
+                            .insert(dir.to_string(), side_val.to_string());
+                    }
+                    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 +2071,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::*;

{nucleation-0.1.140 → nucleation-0.1.141}/tests/integration_tests.rs

@@ -15,8 +15,7 @@ fn litematic_to_schem_conversion(name: &str) {
         fs::read(litematic_path).expect(format!("Failed to read {}", input_path_str).as_str());
 
     // Parse the .litematic data into a UniversalSchematic
-    let mut schematic =
-        litematic::from_litematic(&litematic_data).expect("Failed to parse litematic");
+    let schematic = litematic::from_litematic(&litematic_data).expect("Failed to parse litematic");
 
     // let region_blocks = schematic.get_region_from_index(0).unwrap().blocks.clone();
 
@@ -73,7 +72,7 @@ fn litematic_to_schem_conversion(name: &str) {
     println!("Successfully converted sample.litematic to .schem format and verified the contents.");
 }
 
-fn schema_to_litematic_conversion(name: &str) {
+fn _schema_to_litematic_conversion(name: &str) {
     // Path to the sample .schem file
     let input_path_str = format!("tests/samples/{}.schem", name);
     let schem_path = Path::new(&input_path_str);
@@ -130,7 +129,7 @@ fn test_cube_schematic() {
 }
 
 // #[test]
-fn time_load_large_schematic() {
+fn _time_load_large_schematic() {
     let input_path_str = format!("tests/samples/large_schematic.schem");
     let schem_path = Path::new(&input_path_str);
     let schem_data =

{nucleation-0.1.140 → nucleation-0.1.141}/tests/test_region_expansion_bugs.rs

@@ -1,7 +1,7 @@
 use nucleation::block_entity::BlockEntity;
 use nucleation::schematic;
 use nucleation::{BlockState, Region, UniversalSchematic};
-use std::fs;
+// use std::fs;
 
 #[test]
 fn test_basic_dimension_expansion_bug() {