From fb6cb1773a734aaf091dbbc840632905a2a40cad Mon Sep 17 00:00:00 2001
From: Chaoscaot <chaoscaot@zohomail.eu>
Date: Wed, 1 Feb 2023 15:05:52 +0100
Subject: [PATCH] Initial Commit

---
 .gitignore            |   3 +
 Cargo.toml            |  10 +++
 src/lib.rs            | 144 ++++++++++++++++++++++++++++++++++++++++++
 src/pattern_mapper.rs | 118 ++++++++++++++++++++++++++++++++++
 src/schematic.rs      |  58 +++++++++++++++++
 tests/endstone.schem  | Bin 0 -> 204 bytes
 tests/simple.schem    | Bin 0 -> 4920 bytes
 7 files changed, 333 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 Cargo.toml
 create mode 100644 src/lib.rs
 create mode 100644 src/pattern_mapper.rs
 create mode 100644 src/schematic.rs
 create mode 100644 tests/endstone.schem
 create mode 100644 tests/simple.schem

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..7d11246
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+/target
+/Cargo.lock
+/.idea/
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..03109d7
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "schemsearch"
+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"
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..baecb33
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,144 @@
+#![allow(unused_variables)]
+
+use crate::pattern_mapper::match_palette;
+use crate::schematic::Schematic;
+
+mod schematic;
+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();
+
+    for i in 0..schem.width - pattern_schem.width {
+        for j in 0..schem.height - pattern_schem.height {
+            for k in 0..schem.length - pattern_schem.length {
+                let mut match_found = true;
+                for x in 0..pattern_schem.width {
+                    for y in 0..pattern_schem.height {
+                        for z in 0..pattern_schem.length {
+                            let index = (i + x) as usize + (j + y) as usize * schem.width as usize + (k + z) as usize * schem.width as usize * schem.height as usize;
+                            let pattern_index = x as usize + y as usize * pattern_schem.width as usize + z as usize * pattern_schem.width as usize * pattern_schem.height as usize;
+                            if schem.block_data[index] != pattern_schem.block_data[pattern_index] {
+                                match_found = false;
+                                break;
+                            }
+                        }
+                        if !match_found {
+                            break;
+                        }
+                    }
+                    if !match_found {
+                        break;
+                    }
+                }
+                if match_found {
+                    matches.push((i, j, k));
+                }
+            }
+        }
+    }
+
+    return matches;
+
+}
+
+pub(crate) fn normalize_data(data: &String, ignore_data: bool) -> String {
+    if ignore_data {
+        data.split('[').next().unwrap().to_string()
+    } else {
+        data.clone()
+    }
+}
+
+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()
+    }
+}
+
+mod tests {
+    use std::path::Path;
+    use crate::pattern_mapper::{match_palette, 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]
+    fn test_search() {
+        let file = std::fs::File::open("tests/simple.schem").expect("Failed to open file");
+        let schematic = &std::io::Read::bytes(file).map(|b| b.unwrap()).collect();
+        let file = std::fs::File::open("tests/endstone.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);
+    }
+}
diff --git a/src/pattern_mapper.rs b/src/pattern_mapper.rs
new file mode 100644
index 0000000..8b3855a
--- /dev/null
+++ b/src/pattern_mapper.rs
@@ -0,0 +1,118 @@
+use nbt::Map;
+use crate::normalize_data;
+use crate::schematic::Schematic;
+
+pub(crate) 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;
+
+    for block in schem.block_data.iter() {
+        let block_name = schem.palette.iter().find(|(_, &v)| v == *block).expect("Invalid Schematic").0;
+        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: 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.block_data.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(crate) 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, block_id) 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 mut data_schem: Vec<i32> = match_palette_adapt(&schem, matching_palette.clone(), true);
+
+    let mut 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: 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: 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)
+}
\ No newline at end of file
diff --git a/src/schematic.rs b/src/schematic.rs
new file mode 100644
index 0000000..9a105ff
--- /dev/null
+++ b/src/schematic.rs
@@ -0,0 +1,58 @@
+use std::path::Path;
+use nbt::{Map, Value};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub(crate) struct Schematic {
+    #[serde(rename = "Version")]
+    pub(crate) version: i32,
+    #[serde(rename = "DataVersion")]
+    pub(crate) data_version: i32,
+    #[serde(rename = "Metadata")]
+    pub(crate) metadata: Map<String, Value>,
+    #[serde(rename = "Width")]
+    pub(crate) width: u16,
+    #[serde(rename = "Height")]
+    pub(crate) height: u16,
+    #[serde(rename = "Length")]
+    pub(crate) length: u16,
+    #[serde(rename = "Offset")]
+    pub(crate) offset: [i32; 3],
+    #[serde(rename = "PaletteMax")]
+    pub(crate) palette_max: i32,
+    #[serde(rename = "Palette")]
+    pub(crate) palette: Map<String, i32>,
+    #[serde(rename = "BlockData")]
+    pub(crate) block_data: Vec<i32>,
+    #[serde(rename = "BlockEntities")]
+    pub(crate) block_entities: Vec<BlockEntity>,
+    #[serde(rename = "Entities")]
+    pub(crate) entities: Option<Vec<Entity>>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub(crate) struct BlockEntity {
+    #[serde(rename = "Id")]
+    pub(crate) id: String,
+    #[serde(rename = "Pos")]
+    pub(crate) pos: [i32; 3],
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub(crate) struct Entity {
+    #[serde(rename = "Id")]
+    pub(crate) id: String,
+    #[serde(rename = "Pos")]
+    pub(crate) pos: [i32; 3],
+}
+
+impl Schematic {
+    pub(crate) fn load(path: &Path) -> Schematic {
+        let file = std::fs::File::open(path).expect("Failed to open file");
+        let schematic: Schematic = match nbt::from_gzip_reader(file) {
+            Ok(schem) => schem,
+            Err(e) => panic!("Failed to parse schematic: {}", e),
+        };
+        schematic
+    }
+}
diff --git a/tests/endstone.schem b/tests/endstone.schem
new file mode 100644
index 0000000000000000000000000000000000000000..f2d73ece70d83d756c0e9d68b50cf9fd0ae0169a
GIT binary patch
literal 204
zcmV;-05ks|iwFP!00000|6Ptx55YhX#h-4dEl$3Ovl~%yAS4pSMK<kJH`pdR2cO3m
zW!C?A$z=21?EGdT=w({a$*@foqJ=pUGtJBeKrKS}3KY60>nJ^&ocrXmUB#s%cqxP{
zI#;%IVuApTDY-otP!XClVv`v*3a#-ViNF73N+<C=&nx21P4wfpe}3&f1Uw<TFBmnU
zjRg9kwR<7-@K~k?9}8ULEsf5j5j(bQsd|I~>WR(#i7hmqJN!km<tlF?wZ<KESTEri
G0RR9vnOa5w

literal 0
HcmV?d00001

diff --git a/tests/simple.schem b/tests/simple.schem
new file mode 100644
index 0000000000000000000000000000000000000000..db5adcab76a9cd2d90276cf0a895975635501069
GIT binary patch
literal 4920
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
TZ*6IQGj?5lW&ZdV&w>8~zlhl<

literal 0
HcmV?d00001