🔧 Add invalid_nbt flag.

schemsearch-lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "schemsearch-lib"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 
@@ -11,3 +11,4 @@ serde = { version = "1.0.160", features = ["derive"] }
 schemsearch-files = { path = "../schemsearch-files" }
 named-binary-tag = "0.6"
 libmath = "0.2.1"
+lazy_static = "1.4.0"

schemsearch-lib/src/blocks.txt

@@ -0,0 +1,163 @@
+oak_sign
+oak_wall_sign
+oak_hanging_sign
+oak_wall_hanging_sign
+birch_sign
+birch_wall_sign
+birch_hanging_sign
+birch_wall_hanging_sign
+spruce_sign
+spruce_wall_sign
+spruce_hanging_sign
+spruce_wall_hanging_sign
+jungle_sign
+jungle_wall_sign
+jungle_hanging_sign
+jungle_wall_hanging_sign
+dark_oak_sign
+dark_oak_wall_sign
+dark_oak_hanging_sign
+dark_oak_wall_hanging_sign
+acacia_sign
+acacia_wall_sign
+acacia_hanging_sign
+acacia_wall_hanging_sign
+mangrove_sign
+mangrove_wall_sign
+mangrove_hanging_sign
+mangrove_wall_hanging_sign
+cherry_sign
+cherry_wall_sign
+cherry_hanging_sign
+cherry_wall_hanging_sign
+bamboo_sign
+bamboo_wall_sign
+bamboo_hanging_sign
+bamboo_wall_hanging_sign
+warped_sign
+warped_wall_sign
+warped_hanging_sign
+warped_wall_hanging_sign
+crimson_sign
+crimson_wall_sign
+crimson_hanging_sign
+crimson_wall_hanging_sign
+suspicious_gravel
+suspicious_sand
+white_banner
+light_gray_banner
+gray_banner
+black_banner
+brown_banner
+red_banner
+orange_banner
+yellow_banner
+lime_banner
+green_banner
+cyan_banner
+light_blue_banner
+blue_banner
+purple_banner
+magenta_banner
+pink_banner
+white_wall_banner
+light_gray_wall_banner
+gray_wall_banner
+black_wall_banner
+brown_wall_banner
+red_wall_banner
+orange_wall_banner
+yellow_wall_banner
+lime_wall_banner
+green_wall_banner
+cyan_wall_banner
+light_blue_wall_banner
+blue_wall_banner
+purple_wall_banner
+magenta_wall_banner
+pink_wall_banner
+white_bed
+light_gray_bed
+gray_bed
+black_bed
+brown_bed
+red_bed
+orange_bed
+yellow_bed
+lime_bed
+green_bed
+cyan_bed
+light_blue_bed
+blue_bed
+purple_bed
+magenta_bed
+pink_bed
+shulker_box
+white_shulker_box
+light_gray_shulker_box
+gray_shulker_box
+black_shulker_box
+brown_shulker_box
+red_shulker_box
+orange_shulker_box
+yellow_shulker_box
+lime_shulker_box
+green_shulker_box
+cyan_shulker_box
+light_blue_shulker_box
+blue_shulker_box
+purple_shulker_box
+magenta_shulker_box
+pink_shulker_box
+furnace
+blast_furnace
+smoker
+chest
+trapped_chest
+ender_chest
+enchanting_table
+barrel
+lectern
+jukebox
+bell
+brewing_stand
+bee_nest
+beehive
+decorated_pot
+beacon
+conduit
+campfire
+soul_campfire
+redstone_comparator
+hopper
+dispenser
+dropper
+moving_piston
+daylight_detector
+sculk_sensor
+calibrated_sculk_sensor
+sculk_catalyst
+sculk_shrieker
+player_head
+player_wall_head
+wither_skeleton_skull
+wither_skeleton_wall_skull
+zombie_head
+zombie_wall_head
+skeleton_skull
+skeleton_wall_skull
+creeper_head
+creeper_wall_head
+piglin_head
+piglin_wall_head
+dragon_head
+dragon_wall_head
+chiseled_bookshelf
+command_block
+chain_command_block
+repeating_command_block
+structure_block
+jigsaw_block
+end_portal
+end_gateway
+monster_spawner

schemsearch-lib/src/lib.rs

@@ -16,12 +16,10 @@
  */
 
 pub mod pattern_mapper;
+pub mod search;
+pub mod nbt_search;
 
 use serde::{Serialize, Deserialize};
-use pattern_mapper::match_palette;
-use schemsearch_files::SpongeSchematic;
-use crate::pattern_mapper::match_palette_adapt;
-use math::round::ceil;
 
 #[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub struct SearchBehavior {
@@ -31,89 +29,7 @@ pub struct SearchBehavior {
     pub air_as_any: bool,
     pub ignore_entities: bool,
     pub threshold: f32,
-}
-
-pub fn search(
-    schem: SpongeSchematic,
-    pattern_schem: &SpongeSchematic,
-    search_behavior: SearchBehavior,
-) -> Vec<Match> {
-    if schem.width < pattern_schem.width || schem.height < pattern_schem.height || schem.length < pattern_schem.length {
-        return Vec::new();
-    }
-
-    if pattern_schem.palette.len() > schem.palette.len() {
-        return Vec::new();
-    }
-
-    let pattern_schem = match_palette(&schem, &pattern_schem, search_behavior.ignore_block_data);
-
-    let mut matches: Vec<Match> = Vec::with_capacity(4);
-
-    let pattern_data = pattern_schem.block_data.as_ptr();
-
-    let schem_data = if search_behavior.ignore_block_data {
-        match_palette_adapt(&schem, &pattern_schem.palette, search_behavior.ignore_block_data)
-    } else {
-        schem.block_data
-    };
-
-    let schem_data = schem_data.as_ptr();
-
-    let air_id = if search_behavior.ignore_air || search_behavior.air_as_any { pattern_schem.palette.get("minecraft:air").unwrap_or(&-1) } else { &-1};
-
-    let pattern_blocks = pattern_schem.block_data.len() as f32;
-    let i_pattern_blocks = pattern_blocks as i32;
-
-    let pattern_width = pattern_schem.width as usize;
-    let pattern_height = pattern_schem.height as usize;
-    let pattern_length = pattern_schem.length as usize;
-
-    let schem_width = schem.width as usize;
-    let schem_height = schem.height as usize;
-    let schem_length = schem.length as usize;
-
-    let skip_amount = ceil((pattern_blocks * (1.0 - search_behavior.threshold)) as f64, 0) as i32;
-
-    for y in 0..=schem_height - pattern_height {
-        for z in 0..=schem_length - pattern_length {
-            for x in 0..=schem_width - pattern_width {
-                let mut not_matching = 0;
-                'outer:
-                for j in 0..pattern_height {
-                    for k in 0..pattern_length {
-                        'inner:
-                        for i in 0..pattern_width {
-                            let index = (x + i) + schem_width * ((z + k) + (y + j) * schem_length);
-                            let pattern_index = i + pattern_width * (k + j * pattern_length);
-                            let data = unsafe { *schem_data.add(index) };
-                            let pattern_data = unsafe { *pattern_data.add(pattern_index) };
-                            if (search_behavior.ignore_air && data != *air_id) || (search_behavior.air_as_any && pattern_data != *air_id) {
-                                continue 'inner;
-                            }
-                            if data != pattern_data {
-                                not_matching += 1;
-                                if not_matching >= skip_amount {
-                                    break 'outer;
-                                }
-                            }
-                        }
-                    }
-                }
-
-                if not_matching < skip_amount {
-                    matches.push(Match {
-                        x: x as u16,
-                        y: y as u16,
-                        z: z as u16,
-                        percent: (i_pattern_blocks - not_matching) as f32 / pattern_blocks,
-                    });
-                }
-            }
-        }
-    }
-
-    return matches;
+    pub invalid_nbt: bool,
 }
 
 #[derive(Debug, Clone, Copy, Default, Deserialize, Serialize)]
@@ -137,7 +53,9 @@ pub fn normalize_data(data: &str, ignore_data: bool) -> &str {
 #[cfg(test)]
 mod tests {
     use std::path::{Path, PathBuf};
-    use crate::pattern_mapper::strip_data;
+    use schemsearch_files::SpongeSchematic;
+    use crate::pattern_mapper::{match_palette, strip_data};
+    use crate::search::search;
     use super::*;
 
     #[test]
@@ -191,7 +109,8 @@ mod tests {
             ignore_entities: true,
             ignore_air: false,
             air_as_any: false,
-            threshold: 0.9
+            threshold: 0.9,
+            invalid_nbt: false
         });
     }
 
@@ -206,7 +125,8 @@ mod tests {
             ignore_entities: true,
             ignore_air: false,
             air_as_any: false,
-            threshold: 0.9
+            threshold: 0.9,
+            invalid_nbt: false
         });
 
         assert_eq!(matches.len(), 1);
@@ -227,7 +147,8 @@ mod tests {
             ignore_entities: false,
             ignore_air: false,
             air_as_any: false,
-            threshold: 0.9
+            threshold: 0.9,
+            invalid_nbt: false
         });
 
         assert_eq!(matches.len(), 1);

schemsearch-lib/src/nbt_search.rs

@@ -0,0 +1,27 @@
+use std::borrow::ToOwned;
+use std::collections::HashSet;
+use std::iter::Iterator;
+use lazy_static::lazy_static;
+use schemsearch_files::SpongeSchematic;
+
+const NBT_BLOCKS: &str = include_str!("blocks.txt");
+
+lazy_static! {
+    static ref NBT_BLOCKS_SET: HashSet<String> = NBT_BLOCKS.lines().map(ToOwned::to_owned).collect();
+}
+
+pub fn has_invalid_nbt(schem: SpongeSchematic) -> bool {
+    if schem.block_entities.is_empty() && schem.palette.keys().any(|v| NBT_BLOCKS_SET.contains(v)) {
+        return true;
+    }
+
+    let nbt_blocks = schem.palette.iter().filter(|(k, _)| NBT_BLOCKS_SET.contains(*k)).map(|(_, v)| *v).collect::<HashSet<i32>>();
+
+    for block_entity in schem.block_data.iter() {
+        if nbt_blocks.contains(block_entity) {
+            return true;
+        }
+    }
+
+    return false;
+}

schemsearch-lib/src/search.rs

@@ -0,0 +1,87 @@
+use math::round::ceil;
+use schemsearch_files::SpongeSchematic;
+use crate::{Match, SearchBehavior};
+use crate::pattern_mapper::{match_palette, match_palette_adapt};
+
+pub fn search(
+    schem: SpongeSchematic,
+    pattern_schem: &SpongeSchematic,
+    search_behavior: SearchBehavior,
+) -> Vec<Match> {
+    if schem.width < pattern_schem.width || schem.height < pattern_schem.height || schem.length < pattern_schem.length {
+        return Vec::new();
+    }
+
+    if pattern_schem.palette.len() > schem.palette.len() {
+        return Vec::new();
+    }
+
+    let pattern_schem = match_palette(&schem, &pattern_schem, search_behavior.ignore_block_data);
+
+    let mut matches: Vec<Match> = Vec::with_capacity(4);
+
+    let pattern_data = pattern_schem.block_data.as_ptr();
+
+    let schem_data = if search_behavior.ignore_block_data {
+        match_palette_adapt(&schem, &pattern_schem.palette, search_behavior.ignore_block_data)
+    } else {
+        schem.block_data
+    };
+
+    let schem_data = schem_data.as_ptr();
+
+    let air_id = if search_behavior.ignore_air || search_behavior.air_as_any { pattern_schem.palette.get("minecraft:air").unwrap_or(&-1) } else { &-1};
+
+    let pattern_blocks = pattern_schem.block_data.len() as f32;
+    let i_pattern_blocks = pattern_blocks as i32;
+
+    let pattern_width = pattern_schem.width as usize;
+    let pattern_height = pattern_schem.height as usize;
+    let pattern_length = pattern_schem.length as usize;
+
+    let schem_width = schem.width as usize;
+    let schem_height = schem.height as usize;
+    let schem_length = schem.length as usize;
+
+    let skip_amount = ceil((pattern_blocks * (1.0 - search_behavior.threshold)) as f64, 0) as i32;
+
+    for y in 0..=schem_height - pattern_height {
+        for z in 0..=schem_length - pattern_length {
+            for x in 0..=schem_width - pattern_width {
+                let mut not_matching = 0;
+                'outer:
+                for j in 0..pattern_height {
+                    for k in 0..pattern_length {
+                        'inner:
+                        for i in 0..pattern_width {
+                            let index = (x + i) + schem_width * ((z + k) + (y + j) * schem_length);
+                            let pattern_index = i + pattern_width * (k + j * pattern_length);
+                            let data = unsafe { *schem_data.add(index) };
+                            let pattern_data = unsafe { *pattern_data.add(pattern_index) };
+                            if (search_behavior.ignore_air && data != *air_id) || (search_behavior.air_as_any && pattern_data != *air_id) {
+                                continue 'inner;
+                            }
+                            if data != pattern_data {
+                                not_matching += 1;
+                                if not_matching >= skip_amount {
+                                    break 'outer;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if not_matching < skip_amount {
+                    matches.push(Match {
+                        x: x as u16,
+                        y: y as u16,
+                        z: z as u16,
+                        percent: (i_pattern_blocks - not_matching) as f32 / pattern_blocks,
+                    });
+                }
+            }
+        }
+    }
+
+    return matches;
+}