Restructure

schemsearch-lib/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "schemsearch-lib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+hematite-nbt = "0.5.2"
+serde = "1.0.152"
+schemsearch-files = { path = "../schemsearch-files" }

schemsearch-lib/src/lib.rs

@@ -0,0 +1,157 @@
+use pattern_mapper::match_palette;
+use schemsearch_files::Schematic;
+
+pub mod pattern_mapper;
+
+#[derive(Debug, Clone, Copy)]
+pub struct SearchBehavior {
+    ignore_block_data: bool,
+    ignore_block_entities: bool,
+    ignore_entities: bool,
+}
+
+pub fn search(
+    data: &Vec<u8>,
+    pattern: &Vec<u8>,
+    search_behavior: SearchBehavior,
+) -> Vec<(u16, u16, u16)> {
+    let schem: Schematic = parse_schematic(data);
+    let pattern_schem: Schematic = parse_schematic(pattern);
+
+    if schem.width < pattern_schem.width || schem.height < pattern_schem.height || schem.length < pattern_schem.length {
+        return vec![];
+    }
+
+    if pattern_schem.palette.len() > schem.palette.len() {
+        return vec![];
+    }
+
+    let (schem, pattern_schem) = match_palette(&schem, &pattern_schem, search_behavior.ignore_block_data);
+
+    let mut matches: Vec<(u16, u16, u16)> = Vec::new();
+
+    println!("{:?}", schem);
+    println!("{:?}", pattern_schem);
+
+    let pattern_data = pattern_schem.read_blockdata();
+    let schem_data = schem.read_blockdata();
+
+    for x in 0..=schem.width - pattern_schem.width {
+        for y in 0..=schem.height - pattern_schem.height {
+            for z in 0..=schem.length - pattern_schem.length {
+                let mut match_found = true;
+                'outer: for i in 0..pattern_schem.width {
+                    for j in 0..pattern_schem.height {
+                        for k in 0..pattern_schem.length {
+                            let index = (x + i) + (y + j) * schem.width + (z + k) * schem.width * schem.height;
+                            let pattern_index = i + j * pattern_schem.width + k * pattern_schem.width * pattern_schem.height;
+                            if schem_data.get(index as usize) != pattern_data.get(pattern_index as usize) {
+                                match_found = false;
+                                break 'outer;
+                            }
+                        }
+                    }
+                }
+                if match_found {
+                    matches.push((x, y, z));
+                }
+            }
+        }
+    }
+
+    /*
+    [
+     0, -1,  1, 1,  2,
+     0, -1,  2, 1,  0,
+     2, -1, -1, 2, -1,
+     2,  0,  0, 2, -1,
+     2,  1,  2, 2,  1
+     ]
+
+     */
+
+    return matches;
+
+}
+
+pub fn normalize_data(data: &String, ignore_data: bool) -> String {
+    if ignore_data {
+        data.split('[').next().unwrap().to_string()
+    } else {
+        data.clone()
+    }
+}
+
+pub fn parse_schematic(data: &Vec<u8>) -> Schematic {
+    if data[0] == 0x1f && data[1] == 0x8b {
+        // gzip
+        nbt::from_gzip_reader(data.as_slice()).unwrap()
+    } else {
+        // uncompressed
+        nbt::from_reader(data.as_slice()).unwrap()
+    }
+}
+
+#[allow(unused_imports)]
+mod tests {
+    use std::path::Path;
+    use schemsearch_files::Schematic;
+    use crate::pattern_mapper::strip_data;
+    use super::*;
+
+    #[test]
+    fn read_schematic() {
+        let schematic = Schematic::load(Path::new("../tests/simple.schem"));
+        assert_eq!(schematic.width as usize * schematic.height as usize * schematic.length as usize, schematic.block_data.len());
+        assert_eq!(schematic.palette_max, schematic.palette.len() as i32);
+        println!("{:?}", schematic);
+    }
+
+    #[test]
+    fn test_parse_function() {
+        let file = std::fs::File::open("../tests/simple.schem").expect("Failed to open file");
+        let schematic: Schematic = parse_schematic(&std::io::Read::bytes(file).map(|b| b.unwrap()).collect());
+        assert_eq!(schematic.width as usize * schematic.height as usize * schematic.length as usize, schematic.block_data.len());
+        assert_eq!(schematic.palette_max, schematic.palette.len() as i32);
+        println!("{:?}", schematic);
+    }
+
+    #[test]
+    fn test_strip_schem() {
+        let schematic = Schematic::load(Path::new("../tests/simple.schem"));
+        let stripped = strip_data(&schematic);
+
+        assert_eq!(stripped.palette.keys().any(|k| k.contains('[')), false);
+        println!("{:?}", stripped);
+    }
+
+    #[test]
+    fn test_match_palette() {
+        let schematic = Schematic::load(Path::new("../tests/simple.schem"));
+        let endstone = Schematic::load(Path::new("../tests/endstone.schem"));
+
+        let (matched_schematic, matched_endstone) = match_palette(&schematic, &endstone, true);
+
+        println!("{:?}", matched_schematic);
+        println!("{:?}", matched_endstone);
+    }
+
+    #[test]
+    pub fn test_search() {
+        let file = std::fs::File::open("../tests/Random.schem").expect("Failed to open file");
+        let schematic = &std::io::Read::bytes(file).map(|b| b.unwrap()).collect();
+        println!("{:?}", schematic);
+        let file = std::fs::File::open("../tests/Pattern.schem").expect("Failed to open file");
+        let pattern = &std::io::Read::bytes(file).map(|b| b.unwrap()).collect();
+
+        let matches = search(schematic, pattern, SearchBehavior {
+            ignore_block_data: true,
+            ignore_block_entities: true,
+            ignore_entities: true,
+        });
+
+        println!("{:?}", matches);
+        assert_eq!(matches.len(), 1);
+        assert_eq!(matches[0], (1, 0, 3));
+    }
+}

schemsearch-lib/src/pattern_mapper.rs

@@ -0,0 +1,129 @@
+use nbt::Map;
+use schemsearch_files::{Schematic, to_varint_array};
+use crate::normalize_data;
+
+fn create_reverse_palette(schem: &Schematic) -> Vec<String> {
+    let mut reverse_palette = Vec::with_capacity(schem.palette_max as usize);
+    (0..schem.palette_max).for_each(|_| reverse_palette.push(String::new()));
+    for (key, value) in schem.palette.iter() {
+        reverse_palette[*value as usize] = key.clone();
+    }
+    reverse_palette
+}
+
+pub fn strip_data(schem: &Schematic) -> Schematic {
+    let mut data: Vec<i32> = Vec::new();
+
+    let mut palette: Map<String, i32> = Map::new();
+    let mut palette_max: i32 = 0;
+    let reverse_palette = create_reverse_palette(schem);
+    let dat = schem.read_blockdata();
+
+    for block in dat.iter() {
+        let block_name = reverse_palette[*block as usize].clone();
+        let block_name = block_name.split('[').next().unwrap().to_string();
+
+        let entry = palette.entry(block_name).or_insert_with(|| {
+            let value = palette_max;
+            palette_max += 1;
+            value
+        });
+        data.push(*entry);
+    }
+
+    Schematic {
+        version: schem.version,
+        data_version: schem.data_version,
+        palette,
+        palette_max,
+        block_data: to_varint_array(&data),
+        block_entities: schem.block_entities.clone(),
+        height: schem.height,
+        length: schem.length,
+        width: schem.width,
+        metadata: schem.metadata.clone(),
+        offset: schem.offset.clone(),
+        entities: None,
+    }
+}
+
+fn match_palette_adapt(schem: &Schematic, matching_palette: Map<String, i32>, ignore_data: bool) -> Vec<i32> {
+    let mut data: Vec<i32> = Vec::new();
+
+    for x in schem.read_blockdata().iter() {
+        let blockname = schem.palette.iter().find(|(_, &v)| v == *x).expect("Invalid Schematic").0;
+        let blockname = if ignore_data { normalize_data(&blockname, ignore_data) } else { blockname.clone() };
+        let block_id = matching_palette.get(&blockname).unwrap_or(&-1);
+        data.push(*block_id);
+    }
+
+    data
+}
+
+pub fn match_palette(
+    schem: &Schematic,
+    pattern: &Schematic,
+    ignore_data: bool,
+) -> (Schematic, Schematic) {
+    if ignore_data {
+        match_palette_internal(&strip_data(schem), &strip_data(pattern), ignore_data)
+    } else {
+        match_palette_internal(schem, pattern, ignore_data)
+    }
+}
+
+fn match_palette_internal(
+    schem: &Schematic,
+    pattern: &Schematic,
+    ignore_data: bool,
+) -> (Schematic, Schematic) {
+
+    if schem.palette.len() < pattern.palette.len() {
+        panic!("Schematic palette is larger than pattern palette");
+    }
+
+    let mut matching_palette: Map<String, i32> = Map::new();
+    let mut matching_palette_max: i32 = 0;
+
+    for (block_name, _) in pattern.palette.iter() {
+        let block_name = normalize_data(block_name, true);
+        let schem_block_id = pattern.palette.get(&block_name).expect("Pattern block not found in schematic palette");
+        matching_palette.insert(block_name, *schem_block_id);
+        matching_palette_max += 1;
+    }
+
+    let data_schem: Vec<i32> = match_palette_adapt(&schem, matching_palette.clone(), true);
+
+    let data_pattern: Vec<i32> = match_palette_adapt(&pattern, matching_palette.clone(), true);
+
+    let schem = Schematic {
+        version: schem.version.clone(),
+        data_version: schem.data_version.clone(),
+        palette: matching_palette.clone(),
+        palette_max: matching_palette_max.clone(),
+        block_data: to_varint_array(&data_schem),
+        block_entities: schem.block_entities.clone(),
+        height: schem.height.clone(),
+        length: schem.length.clone(),
+        width: schem.width.clone(),
+        metadata: schem.metadata.clone(),
+        offset: schem.offset.clone(),
+        entities: None,
+    };
+    let pattern = Schematic {
+        version: pattern.version.clone(),
+        data_version: pattern.data_version.clone(),
+        palette: matching_palette.clone(),
+        palette_max: matching_palette_max.clone(),
+        block_data: to_varint_array(&data_pattern),
+        block_entities: pattern.block_entities.clone(),
+        height: pattern.height.clone(),
+        length: pattern.length.clone(),
+        width: pattern.width.clone(),
+        metadata: pattern.metadata.clone(),
+        offset: pattern.offset.clone(),
+        entities: None,
+    };
+
+    (schem, pattern)
+}