A very rude implementation for Tile-Entity Search

.github/ISSUE_TEMPLATE/bug.yml

@@ -1,40 +0,0 @@
-name: Bug Report
-description: Create a report to fix a bug
-labels: [bug]
-title: "[BUG] <title>"
-body:
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: A clear and concise description of what the bug is.
-    validations:
-      required: true
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: Reproduction
-      description: Steps to reproduce the behavior.
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: Expected Behavior
-      description: A clear and concise description of what you expected to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: Actual Behavior
-      description: A clear and concise description of what actually happened.
-    validations:
-      required: true
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: Add any other context about the problem here.
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/feature.yml

@@ -1,35 +0,0 @@
-name: Feature Request
-description: Suggest an idea for this project
-
-title: "[FEATURE] <title>"
-labels: [enhancement]
-
-body:
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-    validations:
-      required: true
-  - type: textarea
-    id: solution
-    attributes:
-      label: Proposed Solution
-      description: A clear and concise description of what you want to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives
-      description: A clear and concise description of any alternative solutions or features you've considered.
-    validations:
-      required: false
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: Additional Context
-      description: Add any other context or screenshots about the feature request here.
-    validations:
-      required: false

.github/dependabot.yml

@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/master-build.yml

@@ -19,38 +19,34 @@ jobs:
       - name: Cache Cargo modules
         id: cache-cargo
         uses: actions/cache@v3
-        continue-on-error: false
+        env:
+          cache-name: cache-cargo-target-debug
         with:
-          path: |
+          path: target
-            ~/.cargo/registry
+          key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-            ~/.cargo/git
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
-            ${{ runner.os }}-cargo-
+            ${{ runner.os }}-${{ env.cache-name }}-
       - name: Build
-        run: make debug
+        run: cargo build --verbose
       - name: Run tests
         run: cargo test --verbose -p schemsearch-lib
 
   build-release:
-    needs:
-      - build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - name: Cache Cargo modules
         id: cache-cargo
         uses: actions/cache@v3
-        continue-on-error: false
+        env:
+          cache-name: cache-cargo-target-release
         with:
-          path: |
+          path: target
-            ~/.cargo/registry
+          key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-            ~/.cargo/git
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
-            ${{ runner.os }}-cargo-
+            ${{ runner.os }}-${{ env.cache-name }}-
       - name: Build
-        run: make
+        run: cargo build --verbose --release -p schemsearch-cli
       - name: Upload a Build Artifact
         uses: actions/upload-artifact@v3.1.2
         with:

.github/workflows/release-build.yml

@@ -22,16 +22,15 @@ jobs:
       - name: Cache Cargo modules
         id: cache-cargo
         uses: actions/cache@v3
-        continue-on-error: false
+        env:
+          cache-name: cache-cargo-target-release
         with:
-          path: |
+          path: target
-            ~/.cargo/registry
+          key: ${{ runner.os }}-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-            ~/.cargo/git
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
-            ${{ runner.os }}-cargo-
+            ${{ runner.os }}-${{ env.cache-name }}-
       - name: Build
-        run: make
+        run: cargo build --verbose --release -p schemsearch-cli
       - name: Create Tarball
         if: ${{ matrix.os != 'windows-latest' }}
         run: tar -czvf schemsearch-cli-${{ matrix.os }}.tar.gz -C target/release schemsearch-cli

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-chaoscaot@zohomail.eu.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

Cargo.toml

@@ -2,10 +2,11 @@
 members = [
     "schemsearch-cli",
     "schemsearch-lib",
+    "schemsearch-faster",
     "schemsearch-files",
     "schemsearch-sql",
-    "schemsearch-ocl-matcher"]
+    "schemsearch-java"
-resolver = "2"
+]
 
 [profile.small]
 inherits = "release"
@@ -15,4 +16,4 @@ opt-level = "z"
 codegen-units = 1
 
 [profile.release]
-debug = true
+lto = true

Makefile

@@ -1,28 +0,0 @@
-default:
-	@echo "Building (Release)...";
-	cargo rustc --release --color=always -p schemsearch-cli -- -C target-feature=+avx2
-
-sql:
-	@echo "Building (Release)...";
-	cargo rustc --release --color=always -p schemsearch-cli --features sql -- -C target-feature=+avx2
-
-debug:
-	@echo "Building (Debug)...";
-	cargo build -p schemsearch-cli
-
-install: default
-	@echo "Installing...";
-	install -Dm755 target/release/schemsearch-cli /usr/bin/schemsearch
-
-uninstall:
-	@echo "Uninstalling...";
-	rm -f /usr/bin/schemsearch
-
-java:
-	@echo "Building Java...";
-	@echo "WARNING: This is WORK IN PROGRESS!";
-	javac SchemSearch.java
-
-clean:
-	@echo "Cleaning...";
-	cargo clean

README.md

@@ -1,15 +1,15 @@
 # schemsearch
-### A *simple* CLI tool to search in Sponge Schematic files
+### A *simple* CLI tool to search in Sponge V2 Schematic files
 
 ---
 
 ## WARNING: This is a work in progress and is really simple right now. It will be improved in the future.
-| Feature                   | Status |
+| Feature                | Status |
-|---------------------------|--------|
+|------------------------|--------|
-| Block search              | ✅      |
+| Block search           | ✅      |
-| Block data less search    | ✅      |
+| Block data less search | ✅      |
-| Tile entities data search | ❌      |
+| Tile entities search   | ❌      |
-| Entities search           | ❌      |
+| Entities search        | ❌      |
 
 ---
 
@@ -41,12 +41,12 @@ schemsearch-cli --help
 ---
 
 ## Roadmap
-A list of features that are planned to be implemented in the future. In order of priority.
 
-- [ ] Use AVX2 for faster search
+- [ ] Tile entities search
-- [ ] Tile entities data search
 - [ ] Entities search
-- [ ] McEdit Schematic support
+- [ ] Better error handling
+- [ ] Web interface
+- [ ] McEdit search
 
 ---
 

schemsearch-cli/Cargo.toml

@@ -1,20 +1,19 @@
 [package]
 name = "schemsearch-cli"
-version = "0.1.7"
+version = "0.1.1"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-schemsearch-common = { path = "../schemsearch-common" }
 schemsearch-lib = { path = "../schemsearch-lib" }
 schemsearch-files = { path = "../schemsearch-files" }
 schemsearch-sql = { path = "../schemsearch-sql", optional = true }
 
 clap = { version = "4.1.8", features = ["cargo"] }
 futures = { version = "0.3", optional = true }
-sqlx = { version = "0.7", features = [ "runtime-async-std-native-tls" , "mysql" ], optional = true }
+sqlx = { version = "0.6", features = [ "runtime-async-std-native-tls" , "mysql" ], optional = true }
 rayon = "1.7.0"
 indicatif = { version = "0.17.3", features = ["rayon"] }
 serde = "1.0.157"

schemsearch-cli/src/json_output.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use schemsearch_common::{Match, SearchBehavior};
+use schemsearch_lib::SearchBehavior;
 
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(tag = "event")]
@@ -12,8 +12,10 @@ pub enum JsonEvent {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct FoundEvent {
     pub name: String,
-    #[serde(flatten, rename = "match")]
+    pub x: u16,
-    pub match_: Match,
+    pub y: u16,
+    pub z: u16,
+    pub percent: f32,
 }
 
 #[derive(Serialize, Deserialize, Debug)]

schemsearch-cli/src/main.rs

@@ -15,44 +15,40 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+mod types;
 mod json_output;
 mod sinks;
-mod stderr;
-mod types;
 
-use crate::sinks::{OutputFormat, OutputSink};
+use std::fmt::Debug;
-use crate::stderr::MaschineStdErr;
+use std::io::Write;
-#[cfg(feature = "sql")]
-use crate::types::SqlSchematicSupplier;
-use crate::types::{PathSchematicSupplier, SchematicSupplier, SchematicSupplierType};
-use clap::error::ErrorKind;
 use clap::{command, Arg, ArgAction, ValueHint};
+use std::path::PathBuf;
+use std::str::FromStr;
+use clap::error::ErrorKind;
+use schemsearch_lib::{search, SearchBehavior};
+use crate::types::{PathSchematicSupplier, SchematicSupplierType};
 #[cfg(feature = "sql")]
 use futures::executor::block_on;
-use indicatif::*;
 use rayon::prelude::*;
 use rayon::ThreadPoolBuilder;
-use schemsearch_common::{Match, SearchBehavior};
-use schemsearch_files::SpongeSchematic;
-use schemsearch_lib::nbt_search::has_invalid_nbt;
-use schemsearch_lib::search::search;
 #[cfg(feature = "sql")]
 use schemsearch_sql::filter::SchematicFilter;
 #[cfg(feature = "sql")]
 use schemsearch_sql::load_all_schematics;
-use std::fmt::Debug;
+#[cfg(feature = "sql")]
-use std::io::Write;
+use crate::types::SqlSchematicSupplier;
-use std::path::PathBuf;
+use indicatif::{ParallelProgressIterator, ProgressStyle};
-use std::str::FromStr;
+use schemsearch_files::Schematic;
+use crate::sinks::{OutputFormat, OutputSink};
 
 fn main() {
     #[allow(unused_mut)]
-        let mut cmd = command!("schemsearch")
+    let mut cmd = command!("schemsearch")
         .arg(
             Arg::new("pattern")
                 .help("The pattern to search for")
+                .required(true)
                 .value_hint(ValueHint::FilePath)
-                .required_unless_present("invalid-nbt")
                 .action(ArgAction::Set),
         )
         .arg(
@@ -69,10 +65,17 @@ fn main() {
                 .action(ArgAction::SetTrue),
         )
         .arg(
-            Arg::new("ignore-block-entities")
+            Arg::new("ignore-tile-entities")
-                .help("Ignores block entities when searching [Not Implemented]")
+                .help("Ignores tile entities when searching [Not Implemented]")
                 .short('b')
-                .long("ignore-block-entities")
+                .long("ignore-tile-entities")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new("ignore-tile-entity-data")
+                .help("Ignores tile entity data when searching [Not Implemented]")
+                .short('B')
+                .long("ignore-tile-entity-data")
                 .action(ArgAction::SetTrue),
         )
         .arg(
@@ -96,16 +99,9 @@ fn main() {
                 .long("air-as-any")
                 .action(ArgAction::SetTrue),
         )
-        .arg(
-            Arg::new("invalid-nbt")
-                .help("Search for Schematics with Invalid or missing NBT data")
-                .short('I')
-                .long("invalid-nbt")
-                .action(ArgAction::SetTrue),
-        )
         .arg(
             Arg::new("output")
-                .help("The output format and path [Format:Path] available formats: text, json, csv; available paths: std, err, (file path)")
+                .help("The output format and path [Format:Path] available formats: text, json, csv; available paths: std, (file path)")
                 .short('o')
                 .long("output")
                 .action(ArgAction::Append)
@@ -143,45 +139,20 @@ fn main() {
         )
         .arg(
             Arg::new("threads")
-                .help("The number of threads to use [0 = all Available Threads]")
+                .help("The number of threads to use [0 = Available Threads]")
                 .short('T')
                 .long("threads")
                 .action(ArgAction::Set)
                 .default_value("0")
                 .value_parser(|s: &str| s.parse::<usize>().map_err(|e| e.to_string())),
         )
-        .arg(
-            Arg::new("machine")
-                .help("Output for machines")
-                .short('m')
-                .long("machine")
-                .action(ArgAction::Set)
-                .default_value("0")
-                .value_parser(|s: &str| s.parse::<u16>().map_err(|e| e.to_string()))
-        )
-        .arg(
-            Arg::new("limit")
-                .help("The maximum number of matches to return [0 = Unlimited]")
-                .short('l')
-                .long("limit")
-                .action(ArgAction::Set)
-                .default_value("50")
-                .value_parser(|s: &str| s.parse::<usize>().map_err(|e| e.to_string())),
-        )
-        .arg(
-            Arg::new("opencl")
-                .help("Use OpenCL Checker")
-                .short('c')
-                .long("opencl")
-                .action(ArgAction::SetTrue),
-        )
         .about("Searches for a pattern in a schematic")
         .bin_name("schemsearch");
 
     #[cfg(feature = "sql")]
     let mut cmd = cmd
         .arg(
-            Arg::new("sql")
+                Arg::new("sql")
                 .help("Use the SteamWar SQL Database")
                 .short('s')
                 .long("sql")
@@ -215,34 +186,24 @@ fn main() {
 
     let search_behavior = SearchBehavior {
         ignore_block_data: matches.get_flag("ignore-data"),
-        ignore_block_entities: matches.get_flag("ignore-block-entities"),
+        ignore_tile_entities: matches.get_flag("ignore-tile-entities"),
+        ignore_tile_entity_data: matches.get_flag("ignore-tile-entity-data"),
         ignore_air: matches.get_flag("ignore-air"),
         air_as_any: matches.get_flag("air-as-any"),
         ignore_entities: matches.get_flag("ignore-entities"),
-        threshold: *matches
+        threshold: *matches.get_one::<f32>("threshold").expect("Couldn't get threshold"),
-            .get_one::<f32>("threshold")
-            .expect("Couldn't get threshold"),
-        invalid_nbt: matches.get_flag("invalid-nbt"),
-        opencl: matches.get_flag("opencl"),
     };
 
-    let pattern = match matches.get_one::<String>("pattern") {
+    let pattern = match Schematic::load(&PathBuf::from(matches.get_one::<String>("pattern").unwrap())) {
-        Some(p) => match SpongeSchematic::load(&PathBuf::from(p)) {
+        Ok(x) => x,
-            Ok(x) => Some(x),
+        Err(e) => {
-            Err(e) => {
+            cmd.error(ErrorKind::Io, format!("Error while loading Pattern: {}", e.to_string())).exit();
-                cmd.error(
+        }
-                    ErrorKind::Io,
-                    format!("Error while loading Pattern: {}", e.to_string()),
-                )
-                .exit();
-            }
-        },
-        None => None,
     };
 
     let mut schematics: Vec<SchematicSupplierType> = Vec::new();
     match matches.get_many::<String>("schematic") {
-        None => {}
+        None => {},
         Some(x) => {
             let paths = x.map(|x| PathBuf::from(x));
             for path in paths {
@@ -253,12 +214,12 @@ fn main() {
                         .filter(|x| x.path().is_file())
                         .filter(|x| x.path().extension().unwrap().to_str().unwrap() == "schem")
                         .for_each(|x| {
-                            schematics.push(SchematicSupplierType::PATH(PathSchematicSupplier {
+                            schematics.push(SchematicSupplierType::PATH(Box::new(PathSchematicSupplier {
                                 path: x.path(),
-                            }))
+                            })))
                         });
                 } else if path.extension().unwrap().to_str().unwrap() == "schem" {
-                    schematics.push(SchematicSupplierType::PATH(PathSchematicSupplier { path }));
+                    schematics.push(SchematicSupplierType::PATH(Box::new(PathSchematicSupplier { path })));
                 }
             }
         }
@@ -274,167 +235,83 @@ fn main() {
             filter = filter.name(x.collect());
         }
         for schem in block_on(load_all_schematics(filter)) {
-            schematics.push(SchematicSupplierType::SQL(SqlSchematicSupplier {
+            schematics.push(SchematicSupplierType::SQL(SqlSchematicSupplier{
-                node: schem,
+                node: schem
             }))
-        }
+        };
     }
 
     if schematics.is_empty() {
-        cmd.error(
+        cmd.error(ErrorKind::MissingRequiredArgument, "No schematics specified").exit();
-            ErrorKind::MissingRequiredArgument,
-            "No schematics specified",
-        )
-        .exit();
     }
 
-    let output: Vec<&(OutputFormat, OutputSink)> = matches
+    let output: Vec<&(OutputFormat, OutputSink)> = matches.get_many::<(OutputFormat, OutputSink)>("output").expect("Error").collect();
-        .get_many::<(OutputFormat, OutputSink)>("output")
+    let mut output: Vec<(OutputFormat, Box<dyn Write>)> = output.into_iter().map(|x| (x.0.clone(), x.1.output())).collect();
-        .expect("Error")
-        .collect();
-    let mut output: Vec<(OutputFormat, Box<dyn Write>)> = output
-        .into_iter()
-        .map(|x| (x.0.clone(), x.1.output()))
-        .collect();
 
     for x in &mut output {
-        write!(
+        write!(x.1, "{}", x.0.start(schematics.len() as u32, &search_behavior, start.elapsed().as_millis())).unwrap();
-            x.1,
-            "{}",
-            x.0.start(
-                schematics.len() as u32,
-                &search_behavior,
-                start.elapsed().as_millis()
-            )
-        )
-        .unwrap();
     }
 
-    ThreadPoolBuilder::new()
+    ThreadPoolBuilder::new().num_threads(*matches.get_one::<usize>("threads").expect("Could not get threads")).build_global().unwrap();
-        .num_threads(
-            *matches
-                .get_one::<usize>("threads")
-                .expect("Could not get threads"),
-        )
-        .build_global()
-        .unwrap();
 
-    let bar = ProgressBar::new(schematics.len() as u64); // "maschine"
+    let matches: Vec<SearchResult> = schematics.par_iter().progress_with_style(ProgressStyle::with_template("[{elapsed}, ETA: {eta}] {wide_bar} {pos}/{len} {per_sec}").unwrap()).map(|schem| {
-    bar.set_style(
+        match schem {
-        ProgressStyle::with_template("[{elapsed}, ETA: {eta}] {wide_bar} {pos}/{len} {per_sec}")
-            .unwrap(),
-    );
-    let term_size = *matches
-        .get_one::<u16>("machine")
-        .expect("Could not get machine");
-    if term_size != 0 {
-        bar.set_draw_target(ProgressDrawTarget::term_like(Box::new(MaschineStdErr {
-            size: term_size,
-        })))
-    }
-
-    let max_matching = *matches
-        .get_one::<usize>("limit")
-        .expect("Could not get max-matching");
-
-    let matches: Vec<SearchResult> = schematics
-        .par_iter()
-        .progress_with(bar)
-        .map(|schem| match schem {
             SchematicSupplierType::PATH(schem) => {
                 let schematic = match load_schem(&schem.path) {
                     Some(x) => x,
-                    None => {
+                    None => return SearchResult {
-                        return SearchResult {
+                        name: schem.get_name(),
-                            name: schem.get_name(),
+                        matches: vec![]
-                            matches: Vec::default(),
-                        }
                     }
                 };
-                search_in_schem(schematic, pattern.as_ref(), search_behavior, schem)
+                SearchResult {
+                    name: schem.get_name(),
+                    matches: search(schematic, &pattern, search_behavior)
+                }
             }
             #[cfg(feature = "sql")]
-            SchematicSupplierType::SQL(schem) => match schem.get_schematic() {
+            SchematicSupplierType::SQL(schem) => {
-                Ok(schematic) => {
+                match schem.get_schematic() {
-                    search_in_schem(schematic, pattern.as_ref(), search_behavior, schem)
+                    Ok(schematic) => {
-                }
+                        SearchResult {
-                Err(e) => {
+                            name: schem.get_name(),
-                    eprintln!(
+                            matches: search(schematic, &pattern, search_behavior)
-                        "Error while loading schematic ({}): {}",
+                        }
-                        schem.get_name(),
+                    }
-                        e.to_string()
+                    Err(e) => {
-                    );
+                        println!("Error while loading schematic ({}): {}", schem.get_name(), e.to_string());
-                    SearchResult {
+                        SearchResult {
-                        name: schem.get_name(),
+                            name: schem.get_name(),
-                        matches: Vec::default(),
+                            matches: vec![]
+                        }
                     }
                 }
-            },
+            }
-        })
+        }
-        .collect();
+    }).collect();
 
-    let mut matches_count = 0;
+    for matching in matches {
-
-    'outer: for matching in matches {
         let schem_name = matching.name;
         let matching = matching.matches;
         for x in matching {
             for out in &mut output {
                 write!(out.1, "{}", out.0.found_match(&schem_name, x)).unwrap();
             }
-            matches_count += 1;
-            if max_matching != 0 && matches_count >= max_matching {
-                break 'outer;
-            }
         }
     }
 
+    let end = std::time::Instant::now();
     for x in &mut output {
-        write!(x.1, "{}", x.0.end(start.elapsed())).unwrap();
+        write!(x.1, "{}", x.0.end(end.duration_since(start).as_millis())).unwrap();
         x.1.flush().unwrap();
     }
 }
 
-fn search_in_schem(
+fn load_schem(schem_path: &PathBuf) -> Option<Schematic> {
-    schematic: SpongeSchematic,
+    match Schematic::load(schem_path) {
-    pattern: Option<&SpongeSchematic>,
-    search_behavior: SearchBehavior,
-    schem: &impl SchematicSupplier,
-) -> SearchResult {
-    if search_behavior.invalid_nbt {
-        if has_invalid_nbt(schematic) {
-            SearchResult {
-                name: schem.get_name(),
-                matches: vec![Match {
-                    x: 0,
-                    y: 0,
-                    z: 0,
-                    percent: 1.0,
-                }],
-            }
-        } else {
-            SearchResult {
-                name: schem.get_name(),
-                matches: vec![],
-            }
-        }
-    } else {
-        SearchResult {
-            name: schem.get_name(),
-            matches: search(schematic, pattern.unwrap(), search_behavior),
-        }
-    }
-}
-
-fn load_schem(schem_path: &PathBuf) -> Option<SpongeSchematic> {
-    match SpongeSchematic::load(schem_path) {
         Ok(x) => Some(x),
         Err(e) => {
-            println!(
+            println!("Error while loading schematic ({}): {}", schem_path.to_str().unwrap(), e.to_string());
-                "Error while loading schematic ({}): {}",
-                schem_path.to_str().unwrap(),
-                e.to_string()
-            );
             None
         }
     }
@@ -443,5 +320,6 @@ fn load_schem(schem_path: &PathBuf) -> Option<SpongeSchematic> {
 #[derive(Debug, Clone)]
 struct SearchResult {
     name: String,
-    matches: Vec<Match>,
+    matches: Vec<(u16, u16, u16, f32)>,
 }
+

schemsearch-cli/src/sinks.rs

@@ -1,16 +1,13 @@
-use crate::json_output::{EndEvent, FoundEvent, InitEvent, JsonEvent};
-use indicatif::HumanDuration;
-use schemsearch_common::{Match, SearchBehavior};
 use std::fs::File;
 use std::io::BufWriter;
-use std::io::Write;
 use std::str::FromStr;
-use std::time::Duration;
+use std::io::Write;
+use schemsearch_lib::SearchBehavior;
+use crate::json_output::{EndEvent, FoundEvent, InitEvent, JsonEvent};
 
 #[derive(Debug, Clone)]
 pub enum OutputSink {
     Stdout,
-    Stderr,
     File(String),
 }
 
@@ -18,7 +15,7 @@ pub enum OutputSink {
 pub enum OutputFormat {
     Text,
     CSV,
-    JSON,
+    JSON
 }
 
 impl FromStr for OutputFormat {
@@ -29,7 +26,7 @@ impl FromStr for OutputFormat {
             "text" => Ok(OutputFormat::Text),
             "csv" => Ok(OutputFormat::CSV),
             "json" => Ok(OutputFormat::JSON),
-            _ => Err(format!("'{}' is not a valid output format", s)),
+            _ => Err(format!("'{}' is not a valid output format", s))
         }
     }
 }
@@ -40,8 +37,7 @@ impl FromStr for OutputSink {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "std" => Ok(OutputSink::Stdout),
-            "err" => Ok(OutputSink::Stderr),
+            _ => Ok(OutputSink::File(s.to_string()))
-            _ => Ok(OutputSink::File(s.to_string())),
         }
     }
 }
@@ -49,61 +45,44 @@ impl FromStr for OutputSink {
 impl OutputSink {
     pub fn output(&self) -> Box<dyn Write> {
         match self {
-            OutputSink::Stdout => Box::new(std::io::stdout()),
+            OutputSink::Stdout => Box::new(std::io::stdout().lock()),
-            OutputSink::Stderr => Box::new(std::io::stderr()),
+            OutputSink::File(path) => Box::new(BufWriter::new(File::create(path).unwrap()))
-            OutputSink::File(path) => Box::new(BufWriter::new(File::create(path).unwrap())),
         }
     }
 }
 
 impl OutputFormat {
-    pub fn found_match(&self, name: &String, pos: Match) -> String {
+    pub fn found_match(&self, name: &String, pos: (u16, u16, u16, f32)) -> String {
         match self {
-            OutputFormat::Text => format!(
+            OutputFormat::Text => format!("Found match in '{}' at x: {}, y: {}, z: {}, % = {}\n", name, pos.0, pos.1, pos.2, pos.3),
-                "Found match in '{}' at x: {}, y: {}, z: {}, % = {}\n",
+            OutputFormat::CSV => format!("{},{},{},{},{}\n", name, pos.0, pos.1, pos.2, pos.3),
-                name, pos.x, pos.y, pos.z, pos.percent
+            OutputFormat::JSON => format!("{}\n", serde_json::to_string(&JsonEvent::Found(FoundEvent {
-            ),
+                name: name.clone(),
-            OutputFormat::CSV => {
+                x: pos.0,
-                format!("{},{},{},{},{}\n", name, pos.x, pos.y, pos.z, pos.percent)
+                y: pos.1,
-            }
+                z: pos.2,
-            OutputFormat::JSON => format!(
+                percent: pos.3,
-                "{}\n",
+            })).unwrap())
-                serde_json::to_string(&JsonEvent::Found(FoundEvent {
-                    name: name.clone(),
-                    match_: pos,
-                }))
-                .unwrap()
-            ),
         }
     }
 
     pub fn start(&self, total: u32, search_behavior: &SearchBehavior, start_time: u128) -> String {
         match self {
             OutputFormat::Text => format!("Starting search in {} schematics\n", total),
-            OutputFormat::CSV => "Name,X,Y,Z,Percent\n".to_owned(),
+            OutputFormat::CSV => format!("Name,X,Y,Z,Percent\n"),
-            OutputFormat::JSON => format!(
+            OutputFormat::JSON => format!("{}\n", serde_json::to_string(&JsonEvent::Init(InitEvent {
-                "{}\n",
+                total,
-                serde_json::to_string(&JsonEvent::Init(InitEvent {
+                search_behavior: search_behavior.clone(),
-                    total,
+                start_time,
-                    search_behavior: search_behavior.clone(),
+            })).unwrap())
-                    start_time,
-                }))
-                .unwrap()
-            ),
         }
     }
 
-    pub fn end(&self, end_time: Duration) -> String {
+    pub fn end(&self, end_time: u128) -> String {
         match self {
-            OutputFormat::Text => format!("Search complete in {:?}\n", end_time),
+            OutputFormat::Text => format!("Search complete in {}s\n", end_time / 1000),
-            OutputFormat::CSV => format!("{:?}\n", end_time),
+            OutputFormat::CSV => format!("{}\n", end_time),
-            OutputFormat::JSON => format!(
+            OutputFormat::JSON => format!("{}\n", serde_json::to_string(&JsonEvent::End(EndEvent{ end_time })).unwrap())
-                "{}\n",
-                serde_json::to_string(&JsonEvent::End(EndEvent {
-                    end_time: end_time.as_millis()
-                }))
-                .unwrap()
-            ),
         }
     }
-}
+}

schemsearch-cli/src/stderr.rs

@@ -1,44 +0,0 @@
-use std::fmt::Debug;
-use std::io::Write;
-use indicatif::TermLike;
-
-#[derive(Debug)]
-pub struct MaschineStdErr { pub(crate) size: u16}
-
-impl TermLike for MaschineStdErr {
-    fn width(&self) -> u16 {
-        self.size
-    }
-
-    fn move_cursor_up(&self, _: usize) -> std::io::Result<()> {
-        Ok(())
-    }
-
-    fn move_cursor_down(&self, _: usize) -> std::io::Result<()> {
-        Ok(())
-    }
-
-    fn move_cursor_right(&self, _: usize) -> std::io::Result<()> {
-        Ok(())
-    }
-
-    fn move_cursor_left(&self, _: usize) -> std::io::Result<()> {
-        Ok(())
-    }
-
-    fn write_line(&self, s: &str) -> std::io::Result<()> {
-        writeln!(std::io::stderr(), "{}", s)
-    }
-
-    fn write_str(&self, s: &str) -> std::io::Result<()> {
-        write!(std::io::stderr(), "{}", s)
-    }
-
-    fn clear_line(&self) -> std::io::Result<()> {
-        Ok(())
-    }
-
-    fn flush(&self) -> std::io::Result<()> {
-        std::io::stderr().flush()
-    }
-}

schemsearch-cli/src/types.rs

@@ -15,32 +15,24 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-#[cfg(feature = "sql")]
-use std::io::Cursor;
 use std::path::PathBuf;
 #[cfg(feature = "sql")]
 use futures::executor::block_on;
 #[cfg(feature = "sql")]
-use schemsearch_files::SpongeSchematic;
-#[cfg(feature = "sql")]
 use schemsearch_sql::{load_schemdata, SchematicNode};
 
 pub enum SchematicSupplierType {
-    PATH(PathSchematicSupplier),
+    PATH(Box<PathSchematicSupplier>),
     #[cfg(feature = "sql")]
     SQL(SqlSchematicSupplier),
 }
 
-pub trait SchematicSupplier {
-    fn get_name(&self) -> String;
-}
-
 pub struct PathSchematicSupplier {
     pub path: PathBuf,
 }
 
-impl SchematicSupplier for PathSchematicSupplier {
+impl PathSchematicSupplier {
-    fn get_name(&self) -> String {
+    pub fn get_name(&self) -> String {
         self.path.file_stem().unwrap().to_str().unwrap().to_string()
     }
 }
@@ -52,17 +44,12 @@ pub struct SqlSchematicSupplier {
 
 #[cfg(feature = "sql")]
 impl SqlSchematicSupplier {
-    pub fn get_schematic(&self) -> Result<SpongeSchematic, String> {
+    pub fn get_schematic(&self) -> Result<Schematic, String> {
-        let mut schemdata = block_on(load_schemdata(self.node.id));
+        let schemdata = block_on(load_schemdata(self.node.id));
-        SpongeSchematic::load_data(&mut Cursor::new(schemdata.as_mut_slice()))
+        Schematic::load_data(schemdata.as_slice())
     }
-}
 
-#[cfg(feature = "sql")]
+    pub fn get_name(&self) -> String {
-impl SchematicSupplier for SqlSchematicSupplier {
-    fn get_name(&self) -> String {
         format!("{} ({})", self.node.name, self.node.id)
     }
 }
-
-

schemsearch-common/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "schemsearch-common"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-serde = { version = "1.0.160", features = ["derive"] }

schemsearch-common/src/lib.rs

@@ -1,56 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
-pub struct SearchBehavior {
-    pub ignore_block_data: bool,
-    pub ignore_block_entities: bool,
-    pub ignore_air: bool,
-    pub air_as_any: bool,
-    pub ignore_entities: bool,
-    pub threshold: f32,
-    pub invalid_nbt: bool,
-    pub opencl: bool,
-}
-
-impl Default for SearchBehavior {
-    fn default() -> Self {
-        SearchBehavior {
-            ignore_block_data: false,
-            ignore_block_entities: false,
-            ignore_air: false,
-            air_as_any: false,
-            ignore_entities: false,
-            threshold: 0.9,
-            invalid_nbt: false,
-            opencl: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize)]
-pub struct Match {
-    pub x: u16,
-    pub y: u16,
-    pub z: u16,
-    pub percent: f32,
-}
-
-#[macro_export]
-macro_rules! time {
-    ($name:ident, $body:block) => {
-        {
-            #[cfg(debug_assertions)]
-            {
-                let start = std::time::Instant::now();
-                let result = $body;
-                let duration = start.elapsed();
-                println!("{} took {:?}", stringify!($name), duration);
-                result
-            }
-            #[cfg(not(debug_assertions))]
-            {
-                $body
-            }
-        }
-    };
-}

schemsearch-faster/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "schemsearch_faster"
+version = "0.1.1"
+edition = "2021"
+license = "AGPL-3.0-or-later"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+schemsearch-lib = { path = "../schemsearch-lib" }
+schemsearch-files = { path = "../schemsearch-files" }
+hematite-nbt = "0.5.2"

schemsearch-faster/src/lib.rs

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2023  Chaoscaot
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use nbt::Map;
+use schemsearch_files::Schematic;
+
+pub fn convert_to_search_space(schem: &Schematic, palette: &Vec<String>) -> Vec<Vec<u8>> {
+    let mut data: Vec<Vec<u8>> = Vec::with_capacity(palette.len());
+    let block_data = &schem.block_data;
+    for name in palette {
+        let mut output: Vec<u8> = Vec::with_capacity(block_data.len());
+        for block in block_data.iter() {
+            if schem.palette.get(name).unwrap_or(&-1) == block {
+                output.push(1);
+            } else {
+                output.push(0);
+            }
+        }
+        data.push(output);
+    }
+    data
+}
+
+pub fn unwrap_palette(palette: &Map<String, i32>) -> Vec<String> {
+    let mut output: Vec<String> = Vec::with_capacity(palette.len());
+    (0..palette.len()).for_each(|_| output.push(String::new()));
+    for (key, id) in palette.iter() {
+        output[*id as usize] = key.clone();
+    }
+    output
+}
+
+#[allow(unused_imports)]
+#[cfg(test)]
+mod tests {
+    use std::path::{Path, PathBuf};
+    use schemsearch_files::Schematic;
+    use crate::{convert_to_search_space, unwrap_palette};
+
+    //#[test]
+    pub fn test() {
+        let schematic = Schematic::load(&PathBuf::from("../tests/Pattern.schem")).unwrap();
+        dbg!(convert_to_search_space(&schematic, &unwrap_palette(&schematic.palette)));
+    }
+
+    //#[test]
+    pub fn test_2() {
+        let schematic = Schematic::load(&PathBuf::from("../tests/Pattern.schem")).unwrap();
+        let schematic2 = Schematic::load(&PathBuf::from("../tests/Random.schem")).unwrap();
+        println!("{:?}", convert_to_search_space(&schematic2, &unwrap_palette(&schematic.palette)));
+    }
+
+    //#[test]
+    pub fn test_big() {
+        let schematic = Schematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
+        let schematic2 = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let _ = convert_to_search_space(&schematic2, &unwrap_palette(&schematic.palette));
+    }
+}

schemsearch-files/Cargo.toml

@@ -1,11 +1,10 @@
 [package]
 name = "schemsearch-files"
-version = "0.1.5"
+version = "0.1.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-flate2 = "1.0.25"
+hematite-nbt = "0.5.2"
-named-binary-tag = "0.6"
+serde = "1.0.152"
-

schemsearch-files/src/lib.rs

@@ -15,176 +15,87 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use std::collections::hash_map::HashMap;
 use std::io::Read;
 use std::path::PathBuf;
-use nbt::{CompoundTag, Tag};
+use nbt::{Map, Value};
+use serde::{Deserialize, Deserializer, Serialize};
 
-#[derive(Clone, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
-pub struct SpongeSchematic {
+pub struct Schematic {
+    #[serde(rename = "Version")]
+    pub version: i32,
+    #[serde(rename = "DataVersion")]
     pub data_version: i32,
-    pub metadata: CompoundTag,
+    #[serde(rename = "Metadata")]
+    pub metadata: Map<String, Value>,
+    #[serde(rename = "Width")]
     pub width: u16,
+    #[serde(rename = "Height")]
     pub height: u16,
+    #[serde(rename = "Length")]
     pub length: u16,
+    #[serde(rename = "Offset")]
     pub offset: [i32; 3],
+    #[serde(rename = "PaletteMax")]
     pub palette_max: i32,
-    pub palette: HashMap<String, i32>,
+    #[serde(rename = "Palette")]
+    pub palette: Map<String, i32>,
+    #[serde(rename = "BlockData", deserialize_with = "read_blockdata")]
     pub block_data: Vec<i32>,
+    #[serde(rename = "BlockEntities")]
     pub block_entities: Vec<BlockEntity>,
+    #[serde(rename = "Entities")]
     pub entities: Option<Vec<Entity>>,
 }
 
-#[derive(Clone, Debug)]
+fn read_blockdata<'de, D>(deserializer: D) -> Result<Vec<i32>, D::Error>
-pub struct BlockContainer {
+    where
-    pub palette: HashMap<String, i32>,
+        D: Deserializer<'de>,
-    pub block_data: Vec<i32>,
+{
-    pub block_entities: Vec<BlockEntity>,
+    let s: Vec<i8> = Deserialize::deserialize(deserializer)?;
+    Ok(read_varint_array(&s))
 }
 
-#[derive(Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BlockEntity {
+    #[serde(rename = "Id")]
     pub id: String,
+    #[serde(rename = "Pos")]
     pub pos: [i32; 3],
+
+    #[serde(flatten)]
+    pub data: Map<String, Value>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct BlockEntityV3 {
-    pub id: String,
-    pub pos: [i32; 3],
-    pub data: HashMap<String, Tag>,
-}
-
-#[derive(Debug, Clone)]
 pub struct Entity {
+    #[serde(rename = "Id")]
     pub id: String,
+    #[serde(rename = "Pos")]
     pub pos: [i32; 3],
+
+    #[serde(flatten)]
+    pub data: Map<String, Value>,
 }
 
-impl SpongeSchematic {
+impl Schematic {
-    pub fn load_data<R>(data: &mut R) -> Result<SpongeSchematic, String> where R: Read {
+    pub fn load_data<R>(data: R) -> Result<Schematic, String> where R: Read {
-        let nbt: CompoundTag = nbt::decode::read_gzip_compound_tag(data).map_err(|e| e.to_string())?;
+        let schematic: Schematic = match nbt::from_gzip_reader(data) {
-        let version = nbt.get_i32("Version").unwrap_or_else(|_| {
+            Ok(schem) => schem,
-            return if nbt.contains_key("Schematic") {
+            Err(e) => return Err(format!("Failed to parse schematic: {}", e))
-                3
-            } else if nbt.contains_key("BlockEntities") {
-                2
-            } else if nbt.contains_key("TileEntities") {
-                1
-            } else {
-                -1
-            };
-        });
-
-        match version {
-            1 => SpongeSchematic::from_nbt_1(nbt),
-            2 => SpongeSchematic::from_nbt_2(nbt),
-            3 => SpongeSchematic::from_nbt_3(nbt.get_compound_tag("Schematic").map_err(|e| e.to_string())?),
-            _ => Err("Invalid schematic: Unknown Version".to_string()),
-        }
-    }
-
-    pub fn load(path: &PathBuf) -> Result<SpongeSchematic, String> {
-        let mut file = std::fs::File::open(path).map_err(|e| e.to_string())?;
-        Self::load_data(&mut file)
-    }
-
-    pub fn from_nbt_1(nbt: CompoundTag) -> Result<Self, String> {
-        Ok(Self {
-            data_version: 0,
-            metadata: nbt.get_compound_tag("Metadata").map_err(|e| e.to_string())?.clone(),
-            width: nbt.get_i16("Width").map_err(|e| e.to_string())? as u16,
-            height: nbt.get_i16("Height").map_err(|e| e.to_string())? as u16,
-            length: nbt.get_i16("Length").map_err(|e| e.to_string())? as u16,
-            offset: read_offset(nbt.get_i32_vec("Offset").map_err(|e| e.to_string())?)?,
-            palette_max: nbt.get_i32("PaletteMax").map_err(|e| e.to_string())?,
-            palette: read_palette(nbt.get_compound_tag("Palette").map_err(|e| e.to_string())?),
-            block_data: read_blocks(nbt.get_i8_vec("BlockData").map_err(|e| e.to_string())?),
-            block_entities: read_tile_entities(nbt.get_compound_tag_vec("TileEntities").unwrap_or_else(|_| vec![]))?,
-            entities: None,
-        })
-    }
-
-    pub fn from_nbt_2(nbt: CompoundTag) -> Result<Self, String> {
-        Ok(Self{
-            data_version: nbt.get_i32("DataVersion").map_err(|e| e.to_string())?,
-            metadata: nbt.get_compound_tag("Metadata").map_err(|e| e.to_string())?.clone(),
-            width: nbt.get_i16("Width").map_err(|e| e.to_string())? as u16,
-            height: nbt.get_i16("Height").map_err(|e| e.to_string())? as u16,
-            length: nbt.get_i16("Length").map_err(|e| e.to_string())? as u16,
-            offset: read_offset(nbt.get_i32_vec("Offset").map_err(|e| e.to_string())?)?,
-            palette_max: nbt.get_i32("PaletteMax").map_err(|e| e.to_string())?,
-            palette: read_palette(nbt.get_compound_tag("Palette").map_err(|e| e.to_string())?),
-            block_data: read_blocks(nbt.get_i8_vec("BlockData").map_err(|e| e.to_string())?),
-            block_entities: read_tile_entities(nbt.get_compound_tag_vec("BlockEntities").unwrap_or_else(|_| vec![]))?,
-            entities: None,
-        })
-    }
-
-    pub fn from_nbt_3(nbt: &CompoundTag) -> Result<Self, String> {
-        let blocks = nbt.get_compound_tag("Blocks").map_err(|e| e.to_string())?;
-        Ok(Self{
-            data_version: nbt.get_i32("DataVersion").map_err(|e| e.to_string())?,
-            metadata: nbt.get_compound_tag("Metadata").map_err(|e| e.to_string())?.clone(),
-            width: nbt.get_i16("Width").map_err(|e| e.to_string())? as u16,
-            height: nbt.get_i16("Height").map_err(|e| e.to_string())? as u16,
-            length: nbt.get_i16("Length").map_err(|e| e.to_string())? as u16,
-            offset: read_offset(nbt.get_i32_vec("Offset").map_err(|e| e.to_string())?)?,
-            palette_max: compute_palette_max(blocks.get_compound_tag("Palette").map_err(|e| e.to_string())?),
-            palette: read_palette(blocks.get_compound_tag("Palette").map_err(|e| e.to_string())?),
-            block_data: read_blocks(blocks.get_i8_vec("Data").map_err(|e| e.to_string())?),
-            block_entities: read_tile_entities(blocks.get_compound_tag_vec("BlockEntities").unwrap_or_else(|_| vec![]))?,
-            entities: None,
-        })
-    }
-
-}
-
-fn read_tile_entities(tag: Vec<&CompoundTag>) -> Result<Vec<BlockEntity>, String> {
-let mut tile_entities = Vec::new();
-    for t in tag {
-        tile_entities.push(BlockEntity {
-            id: t.get_str("Id").map_err(|e| e.to_string())?.to_string(),
-            pos: read_offset(t.get("Pos").map_err(|e| e.to_string())?)?,
-        });
-    }
-    Ok(tile_entities)
-}
-
-#[inline]
-fn read_offset(offset: &Vec<i32>) -> Result<[i32; 3], String> {
-    match offset.len() {
-        3 => Ok([offset[0], offset[1], offset[2]]),
-        _ => Err("Invalid schematic: read_offset wrong length".to_string()),
-    }
-}
-
-#[inline]
-fn read_palette(p: &CompoundTag) -> HashMap<String, i32> {
-    let mut palette = HashMap::new();
-    for (key, value) in p.iter() {
-        match value {
-            Tag::Int(n) => { palette.insert(key.clone(), *n); },
-            _ => {},
         };
+        Ok(schematic)
+    }
+
+    pub fn load(path: &PathBuf) -> Result<Schematic, String> {
+        let file = match std::fs::File::open(path) {
+            Ok(x) => x,
+            Err(_) => return Err(format!("Failed to open file: {}", path.to_str().unwrap()))
+        };
+        Schematic::load_data(file)
     }
-    palette
 }
 
-#[inline]
-fn compute_palette_max(palette: &CompoundTag) -> i32 {
-    palette.iter().map(|(_, v)| v).filter_map(|v| match v {
-        Tag::Int(n) => Some(*n),
-        _ => None,
-    }).max().unwrap_or(0)
-}
-
-#[inline]
-fn read_blocks(blockdata: &Vec<i8>) -> Vec<i32> {
-    read_varint_array(blockdata)
-}
-
-#[inline]
 pub fn read_varint_array(read: &Vec<i8>) -> Vec<i32> {
     let mut data = Vec::new();
     let mut value: i32 = 0;

schemsearch-java/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "schemsearch-java"
+version = "0.1.1"
+edition = "2021"
+license = "AGPL-3.0-or-later"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate_type = ["cdylib"]
+
+[dependencies]
+jni = "0.21.0"
+
+schemsearch-lib = { path = "../schemsearch-lib" }
+schemsearch-files = { path = "../schemsearch-files" }

schemsearch-java/src/lib.rs

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2023  Chaoscaot
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use std::path::PathBuf;
+use jni::JNIEnv;
+
+use jni::objects::{JClass, JString};
+
+use jni::sys::jstring;
+use schemsearch_files::Schematic;
+use schemsearch_lib::{search, SearchBehavior};
+
+#[no_mangle]
+#[allow(unused_variables)]
+pub extern "system" fn Java_SchemSearch_search<'local>(mut env: JNIEnv<'local>,
+    class: JClass<'local>,
+    schematic_path: JString<'local>,
+    pattern_path: JString<'local>) -> jstring {
+    let schematic_path: String = env.get_string(&schematic_path).expect("Couldn't get java string!").into();
+    let pattern_path: String = env.get_string(&pattern_path).expect("Couldn't get java string!").into();
+    let schematic = Schematic::load(&PathBuf::from(&schematic_path)).unwrap();
+    let pattern = Schematic::load(&PathBuf::from(&pattern_path)).unwrap();
+
+    let matches = search(schematic, &pattern, SearchBehavior::default());
+
+    let mut result = String::new();
+    for (x, y, z, p) in matches {
+        result.push_str(&format!("{}, {}, {}, {};", x, y, z, p));
+    }
+    result.remove(result.len() - 1);
+    let output = env.new_string(result).expect("Couldn't create java string!");
+    output.into_raw()
+}

schemsearch-lib/Cargo.toml

@@ -1,15 +1,12 @@
 [package]
 name = "schemsearch-lib"
-version = "0.1.7"
+version = "0.1.1"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-schemsearch-files = { path = "../schemsearch-files" }
+hematite-nbt = "0.5.2"
-schemsearch-common = { path = "../schemsearch-common" }
+serde = "1.0.152"
-schemsearch-ocl-matcher = { path = "../schemsearch-ocl-matcher" }
+schemsearch-files = { path = "../schemsearch-files" }
-named-binary-tag = "0.6"
-libmath = "0.2.1"
-lazy_static = "1.4.0"

schemsearch-lib/src/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/src.iml" filepath="$PROJECT_DIR$/.idea/src.iml" />
-    </modules>
-  </component>
-</project>

schemsearch-lib/src/.idea/src.iml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="CPP_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

schemsearch-lib/src/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-  </component>
-</project>

schemsearch-lib/src/.idea/workspace.xml

@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeSettings">
-    <configurations>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" />
-    </configurations>
-  </component>
-  <component name="ChangeListManager">
-    <list default="true" id="352451bc-b368-403e-b1be-bfdcb573471f" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/../../schemsearch-py/Cargo.toml" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/../../schemsearch-py/pyproject.toml" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/../../schemsearch-py/src/lib.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../../Cargo.toml" beforeDir="false" afterPath="$PROJECT_DIR$/../../Cargo.toml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../../SchemSearch.java" beforeDir="false" afterPath="$PROJECT_DIR$/../../SchemSearch.java" afterDir="false" />
-    </list>
-    <option name="SHOW_DIALOG" value="false" />
-    <option name="HIGHLIGHT_CONFLICTS" value="true" />
-    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
-    <option name="LAST_RESOLUTION" value="IGNORE" />
-  </component>
-  <component name="ClangdSettings">
-    <option name="formatViaClangd" value="false" />
-  </component>
-  <component name="Git.Settings">
-    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$/../.." />
-  </component>
-  <component name="ProjectColorInfo"><![CDATA[{
-  "customColor": "",
-  "associatedIndex": 8
-}]]></component>
-  <component name="ProjectId" id="2gFqSldpa6G5CPOKD9Sjp2GUcRW" />
-  <component name="ProjectViewState">
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showLibraryContents" value="true" />
-  </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.cidr.known.project.marker": "true",
-    "RunOnceActivity.readMode.enableVisualFormatting": "true",
-    "cf.first.check.clang-format": "false",
-    "cidr.known.project.marker": "true",
-    "git-widget-placeholder": "master",
-    "nodejs_package_manager_path": "npm",
-    "vue.rearranger.settings.migration": "true"
-  }
-}]]></component>
-  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
-  <component name="TaskManager">
-    <task active="true" id="Default" summary="Default task">
-      <changelist id="352451bc-b368-403e-b1be-bfdcb573471f" name="Changes" comment="" />
-      <created>1715303674752</created>
-      <option name="number" value="Default" />
-      <option name="presentableId" value="Default" />
-      <updated>1715303674752</updated>
-      <workItem from="1715303675811" duration="8000" />
-    </task>
-    <servers />
-  </component>
-  <component name="TypeScriptGeneratedFilesManager">
-    <option name="version" value="3" />
-  </component>
-</project>

schemsearch-lib/src/blocks.txt

@@ -1,163 +0,0 @@
-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,10 +16,123 @@
  */
 
 pub mod pattern_mapper;
-pub mod search;
-pub mod nbt_search;
 
-use schemsearch_common::SearchBehavior;
+use serde::{Deserialize, Serialize};
+use pattern_mapper::match_palette;
+use schemsearch_files::Schematic;
+use crate::pattern_mapper::match_palette_adapt;
+
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
+pub struct SearchBehavior {
+    pub ignore_block_data: bool,
+    pub ignore_tile_entities: bool,
+    pub ignore_tile_entity_data: bool,
+    pub ignore_air: bool,
+    pub air_as_any: bool,
+    pub ignore_entities: bool,
+    pub threshold: f32,
+}
+
+impl Default for SearchBehavior {
+    fn default() -> Self {
+        SearchBehavior {
+            ignore_block_data: true,
+            ignore_tile_entities: true,
+            ignore_tile_entity_data: false,
+            ignore_entities: true,
+            ignore_air: false,
+            air_as_any: false,
+            threshold: 90.0,
+        }
+    }
+}
+
+pub fn search(
+    schem: Schematic,
+    pattern_schem: &Schematic,
+    search_behavior: SearchBehavior,
+) -> Vec<(u16, u16, u16, f32)> {
+    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 pattern_schem = match_palette(&schem, &pattern_schem, search_behavior.ignore_block_data);
+
+    let mut matches: Vec<(u16, u16, u16, f32)> = Vec::new();
+
+    let pattern_data = pattern_schem.block_data.as_slice();
+
+    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_slice();
+
+    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.width * pattern_schem.height * pattern_schem.length) as f32 + if search_behavior.ignore_tile_entities { 0.0 } else { pattern_schem.block_entities.len() as f32 };
+
+    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;
+
+    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 matching = 0;
+                for j in 0..pattern_height {
+                    for k in 0..pattern_length {
+                        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.get_unchecked(index) };
+                            let pattern_data = unsafe { pattern_data.get_unchecked(pattern_index) };
+                            if *data == *pattern_data || (search_behavior.ignore_air && *data == *air_id) || (search_behavior.air_as_any && *pattern_data == *air_id) {
+                                matching += 1;
+                            }
+                        }
+                    }
+                }
+                if !search_behavior.ignore_tile_entities {
+                    for tile_entity in &pattern_schem.block_entities {
+                        for entry in &schem.block_entities {
+                            if tile_entity.id.as_str() == entry.id.as_str() {
+                                let pos = tile_entity.pos;
+                                let schem_pos = [pos[0] + x as i32, pos[1] + y as i32, pos[2] + z as i32];
+                                if schem_pos == entry.pos {
+                                    if search_behavior.ignore_tile_entity_data {
+                                        matching += 1;
+                                    } else {
+                                        if tile_entity.data == entry.data {
+                                            matching += 1;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                let matching_percent = matching as f32 / pattern_blocks;
+                if matching_percent >= search_behavior.threshold {
+                    matches.push((x as u16, y as u16, z as u16, matching_percent));
+                }
+            }
+        }
+    }
+
+    return matches;
+}
 
 #[inline]
 pub fn normalize_data(data: &str, ignore_data: bool) -> &str {
@@ -30,34 +143,42 @@ pub fn normalize_data(data: &str, ignore_data: bool) -> &str {
     }
 }
 
+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)]
 #[cfg(test)]
 mod tests {
     use std::path::{Path, PathBuf};
-    use schemsearch_files::SpongeSchematic;
+    use schemsearch_files::Schematic;
-    use crate::pattern_mapper::{match_palette, strip_data};
+    use crate::pattern_mapper::strip_data;
-    use crate::search::search;
     use super::*;
 
     #[test]
     fn read_schematic() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
-
         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);
     }
 
     #[test]
     fn test_parse_function() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        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);
     }
 
     #[test]
     fn test_strip_schem() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
         let stripped = strip_data(&schematic);
 
         assert_eq!(stripped.palette.keys().any(|k| k.contains('[')), false);
@@ -65,49 +186,48 @@ mod tests {
 
     #[test]
     fn test_match_palette() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
-        let endstone = SpongeSchematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
+        let endstone = Schematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
 
         let _ = match_palette(&schematic, &endstone, true);
     }
 
     #[test]
     fn test_match_palette_ignore_data() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
-        let endstone = SpongeSchematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
+        let endstone = Schematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
 
         let _ = match_palette(&schematic, &endstone, false);
     }
 
     #[test]
     pub fn test_big_search() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/simple.schem")).unwrap();
-        let endstone = SpongeSchematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
+        let endstone = Schematic::load(&PathBuf::from("../tests/endstone.schem")).unwrap();
 
         let _ = search(schematic, &endstone, SearchBehavior::default());
     }
 
     #[test]
     pub fn test_search() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/Random.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/Random.schem")).unwrap();
-        let pattern = SpongeSchematic::load(&PathBuf::from("../tests/Pattern.schem")).unwrap();
+        let pattern = Schematic::load(&PathBuf::from("../tests/Pattern.schem")).unwrap();
 
         let matches = search(schematic, &pattern, SearchBehavior::default());
 
+        println!("{:?}", matches);
         assert_eq!(matches.len(), 1);
-        assert_eq!(matches[0].x, 1);
+        assert_eq!(matches[0], (1, 0, 3, 1.0));
-        assert_eq!(matches[0].y, 0);
-        assert_eq!(matches[0].z, 3);
-        assert_eq!(matches[0].percent, 1.0);
     }
 
     #[test]
     pub fn test_search_ws() {
-        let schematic = SpongeSchematic::load(&PathBuf::from("../tests/warships/GreyFly-by-Bosslar.schem")).unwrap();
+        let schematic = Schematic::load(&PathBuf::from("../tests/warships/GreyFly-by-Bosslar.schem")).unwrap();
-        let pattern = SpongeSchematic::load(&PathBuf::from("../tests/gray_castle_complex.schem")).unwrap();
+        let pattern = Schematic::load(&PathBuf::from("../tests/gray_castle_complex.schem")).unwrap();
 
         let matches = search(schematic, &pattern, SearchBehavior::default());
 
+        println!("{:?}", matches);
         assert_eq!(matches.len(), 1);
     }
 }

schemsearch-lib/src/nbt_search.rs

@@ -1,110 +0,0 @@
-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(|x| format!("minecraft:{}", x)).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.to_owned())).map(|(_, v)| *v).collect::<HashSet<i32>>();
-
-    for (i, block_entity) in schem.block_data.iter().enumerate() {
-        if nbt_blocks.contains(&*block_entity) {
-            // i = x + z * Width + y * Width * Length
-            let x = i % schem.width as usize;
-            let z = (i / schem.width as usize) % schem.length as usize;
-            let y = i / (schem.width as usize * schem.length as usize);
-            if schem.block_entities.iter().any(|e| !e.pos.eq(&[x as i32, y as i32, z as i32])) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-#[allow(unused_imports)]
-#[cfg(test)]
-mod tests {
-    use nbt::CompoundTag;
-    use schemsearch_files::{BlockEntity, SpongeSchematic};
-    use super::*;
-
-    #[test]
-    fn test_has_invalid_nbt() {
-        let schem = SpongeSchematic {
-            data_version: 1,
-            metadata: CompoundTag::new(),
-            width: 0,
-            height: 0,
-            length: 0,
-            offset: [0, 0, 0],
-            palette_max: 1,
-            palette: vec![("minecraft:chest".to_owned(), 1)].into_iter().collect(),
-            block_data: vec![1],
-            block_entities: vec![],
-            entities: None,
-        };
-
-        assert_eq!(has_invalid_nbt(schem), true);
-    }
-
-    #[test]
-    fn test_has_invalid_nbt_2() {
-        let schem = SpongeSchematic {
-            data_version: 1,
-            metadata: CompoundTag::new(),
-            width: 1,
-            height: 1,
-            length: 1,
-            offset: [0, 0, 0],
-            palette_max: 1,
-            palette: vec![("minecraft:chest".to_owned(), 1)].into_iter().collect(),
-            block_data: vec![1],
-            block_entities: vec![
-                BlockEntity {
-                    id: "minecraft:chest".to_owned(),
-                    pos: [0, 0, 0],
-                }
-            ],
-            entities: None,
-        };
-
-        assert_eq!(has_invalid_nbt(schem), false);
-    }
-
-    #[test]
-    fn test_has_invalid_nbt_3() {
-        let schem = SpongeSchematic {
-            data_version: 1,
-            metadata: CompoundTag::new(),
-            width: 2,
-            height: 1,
-            length: 1,
-            offset: [0, 0, 0],
-            palette_max: 1,
-            palette: vec![("minecraft:chest".to_owned(), 1), ("minecraft:stone".to_owned(), 2)].into_iter().collect(),
-            block_data: vec![1, 2],
-            block_entities: vec![
-                BlockEntity {
-                    id: "minecraft:chest".to_owned(),
-                    pos: [1, 0, 0],
-                }
-            ],
-            entities: None,
-        };
-
-        assert_eq!(has_invalid_nbt(schem), true);
-    }
-}

schemsearch-lib/src/pattern_mapper.rs

@@ -15,12 +15,11 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use std::collections::HashMap;
+use nbt::Map;
-use nbt::CompoundTag;
+use schemsearch_files::Schematic;
-use schemsearch_files::SpongeSchematic;
 use crate::normalize_data;
 
-fn create_reverse_palette(schem: &SpongeSchematic) -> Vec<&str> {
+fn create_reverse_palette(schem: &Schematic) -> Vec<&str> {
     let mut reverse_palette = Vec::with_capacity(schem.palette_max as usize);
     (0..schem.palette_max).for_each(|_| reverse_palette.push(""));
     for (key, value) in schem.palette.iter() {
@@ -29,15 +28,15 @@ fn create_reverse_palette(schem: &SpongeSchematic) -> Vec<&str> {
     reverse_palette
 }
 
-pub fn strip_data(schem: &SpongeSchematic) -> SpongeSchematic {
+pub fn strip_data(schem: &Schematic) -> Schematic {
     let mut data: Vec<i32> = Vec::new();
 
-    let mut palette: HashMap<String, i32> = HashMap::new();
+    let mut palette: Map<String, i32> = Map::new();
     let mut palette_max: i32 = 0;
     let reverse_palette = create_reverse_palette(schem);
 
     for block in schem.block_data.iter() {
-        let block_name = reverse_palette[*block as usize];
+        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(|| {
@@ -48,8 +47,9 @@ pub fn strip_data(schem: &SpongeSchematic) -> SpongeSchematic {
         data.push(*entry);
     }
 
-    SpongeSchematic {
+    Schematic {
-        data_version: 1,
+        version: schem.version,
+        data_version: schem.data_version,
         palette,
         palette_max,
         block_data: data,
@@ -57,17 +57,17 @@ pub fn strip_data(schem: &SpongeSchematic) -> SpongeSchematic {
         height: schem.height,
         length: schem.length,
         width: schem.width,
-        metadata: CompoundTag::new(),
+        metadata: schem.metadata.clone(),
-        offset: [0; 3],
+        offset: schem.offset.clone(),
         entities: None,
     }
 }
 
-pub fn match_palette_adapt(schem: &SpongeSchematic, matching_palette: &HashMap<String, i32>, ignore_data: bool) -> Vec<i32> {
+pub fn match_palette_adapt(schem: &Schematic, matching_palette: &Map<String, i32>, ignore_data: bool) -> Vec<i32> {
-    let mut data = Vec::with_capacity(schem.block_data.len());
+    let mut data: Vec<i32> = Vec::new();
     let reverse_palette = create_reverse_palette(schem);
 
-    for x in schem.block_data.as_slice().iter() {
+    for x in &schem.block_data {
         let blockname = reverse_palette[*x as usize];
         let blockname = if ignore_data { normalize_data(blockname, ignore_data) } else { blockname };
         let block_id = match matching_palette.get(&*blockname) {
@@ -81,10 +81,10 @@ pub fn match_palette_adapt(schem: &SpongeSchematic, matching_palette: &HashMap<S
 }
 
 pub fn match_palette(
-    schem: &SpongeSchematic,
+    schem: &Schematic,
-    pattern: &SpongeSchematic,
+    pattern: &Schematic,
     ignore_data: bool,
-) -> SpongeSchematic {
+) -> Schematic {
     if ignore_data {
         match_palette_internal(&strip_data(schem), &strip_data(pattern), ignore_data)
     } else {
@@ -93,23 +93,24 @@ pub fn match_palette(
 }
 
 fn match_palette_internal(
-    schem: &SpongeSchematic,
+    schem: &Schematic,
-    pattern: &SpongeSchematic,
+    pattern: &Schematic,
     ignore_data: bool,
-) -> SpongeSchematic {
+) -> Schematic {
     let data_pattern: Vec<i32> = match_palette_adapt(&pattern, &schem.palette, ignore_data);
 
-    SpongeSchematic {
+    Schematic {
-        data_version: 0,
+        version: pattern.version.clone(),
+        data_version: pattern.data_version.clone(),
         palette: schem.palette.clone(),
         palette_max: schem.palette_max,
         block_data: data_pattern,
         block_entities: pattern.block_entities.clone(),
-        height: pattern.height,
+        height: pattern.height.clone(),
-        length: pattern.length,
+        length: pattern.length.clone(),
-        width: pattern.width,
+        width: pattern.width.clone(),
-        metadata: CompoundTag::new(),
+        metadata: pattern.metadata.clone(),
-        offset: [0; 3],
+        offset: pattern.offset.clone(),
         entities: None,
     }
 }

schemsearch-lib/src/search.rs

@@ -1,119 +0,0 @@
-use crate::pattern_mapper::{match_palette, match_palette_adapt};
-use math::round::ceil;
-use schemsearch_common::time;
-use schemsearch_common::{Match, SearchBehavior};
-use schemsearch_files::SpongeSchematic;
-use schemsearch_ocl_matcher::ocl_search;
-
-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 = time!(match_palette, {
-        match_palette(&schem, &pattern_schem, search_behavior.ignore_block_data)
-    });
-
-    let mut matches: Vec<Match> = Vec::with_capacity(4);
-
-    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 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;
-
-    if search_behavior.opencl {
-        return time!(ocl_search, {
-            ocl_search(
-                schem_data.as_slice(),
-                [schem_width, schem_height, schem_length],
-                pattern_schem.block_data.as_slice(),
-                [pattern_width, pattern_height, pattern_length],
-                *air_id,
-                search_behavior,
-            )
-            .unwrap()
-        });
-    }
-
-    let schem_data = schem_data.as_ptr();
-
-    let pattern_data = pattern_schem.block_data.as_ptr();
-
-    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;
-}

schemsearch-ocl-matcher/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "schemsearch-ocl-matcher"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-schemsearch-common = { path = "../schemsearch-common" }
-ocl = "0.19.7"
-libmath = "0.2.1"

schemsearch-ocl-matcher/src/kernel.cl

@@ -1,35 +0,0 @@
-// Use 3d_img
-// Weniger Allocs an Buffern
-// Pattern Parallelisieren mit Local Workern?
-// To Match on GPU
-// Weniger Worker, Mehr Parameter!
-// Pattern als Kernel Konstante
-
-__kernel void add(__global int *result, __global uint *schem,
-                  __constant uint *pattern, const int width, const int height,
-                  const int depth, const int p_width, const int p_height,
-                  const int p_depth, const uint air_id, const int ignore_air,
-                  const int air_as_any, const int skipamount) {
-  int x = get_global_id(0);
-  int y = get_global_id(2);
-  int z = get_global_id(1);
-
-  int wrong_blocks = 0;
-  for (int py = 0; py < p_height; py++) {
-    for (int pz = 0; pz < p_depth; pz++) {
-      for (int px = 0; px < p_width; px++) {
-        // if ((ignore_air && schem_block != air_id) || (air_as_any &&
-        // pattern_block != air_id)) {
-        //     continue; // TODO: PROBLEM!
-        // }
-
-        wrong_blocks +=
-            schem[(x + px) + width * ((z + pz) + (y + py) * depth)] !=
-            pattern[px + p_width * (pz + py * p_depth)];
-      }
-    }
-  }
-
-  int idx = x + z * width + y * width * depth;
-  result[idx] = wrong_blocks;
-}

schemsearch-ocl-matcher/src/lib.rs

@@ -1,133 +0,0 @@
-use math::round::ceil;
-use ocl::SpatialDims::Three;
-use ocl::{core, Buffer, CommandQueueProperties, Context, Image, MemFlags, ProQue};
-use schemsearch_common::{time, Match, SearchBehavior};
-use std::sync::OnceLock;
-use std::time;
-
-const KERNEL: &str = include_str!("kernel.cl");
-
-static PRO_QUEU_CELL: OnceLock<ProQue> = OnceLock::new();
-
-pub fn ocl_available() -> bool {
-    core::default_platform().is_ok()
-}
-
-pub fn ocl_search(
-    schem: &[i32],
-    schem_size: [usize; 3],
-    pattern: &[i32],
-    pattern_size: [usize; 3],
-    air_id: i32,
-    search_behavior: SearchBehavior,
-) -> Result<Vec<Match>, String> {
-    search_ocl(
-        schem,
-        schem_size,
-        pattern,
-        pattern_size,
-        air_id,
-        search_behavior,
-    )
-    .map_err(|e| e.to_string())
-}
-
-fn search_ocl(
-    schem: &[i32],
-    schem_size: [usize; 3],
-    pattern: &[i32],
-    pattern_size: [usize; 3],
-    air_id: i32,
-    search_behavior: SearchBehavior,
-) -> ocl::Result<Vec<Match>> {
-    let pattern_width = pattern_size[0];
-    let pattern_height = pattern_size[1];
-    let pattern_length = pattern_size[2];
-
-    let schem_width = schem_size[0];
-    let schem_height = schem_size[1];
-    let schem_length = schem_size[2];
-
-    let pattern_blocks = (pattern_width * pattern_height * pattern_length) as f32;
-
-    let skip_amount = ceil(
-        (pattern_blocks * (1.0 - search_behavior.threshold)) as f64,
-        0,
-    ) as i32;
-
-    let cell = &PRO_QUEU_CELL;
-    let mut pro_que = time!(get_pro_que, {
-        cell.get_or_init(|| ProQue::builder().src(KERNEL).build().unwrap())
-            .clone()
-    });
-
-    pro_que.set_dims(Three(schem_width, schem_length, schem_height));
-
-    let buffer = time!(create_result_buffer, {
-        Buffer::builder()
-            .queue(pro_que.queue().clone())
-            .flags(MemFlags::new().read_write())
-            .fill_val(-1)
-            .len(schem.len())
-            .build()
-    })?;
-
-    let schem_buffer = time!(create_schen_buffer, {
-        create_schem_buffer(schem, &pro_que)
-    })?;
-
-    let pattern_buffer = time!(create_pattern_buffer, {
-        create_schem_buffer(pattern, &pro_que)
-    })?;
-
-    let kernel = time!(create_kernel, {
-        pro_que
-            .kernel_builder("add")
-            .arg(&buffer)
-            .arg(&schem_buffer)
-            .arg(&pattern_buffer)
-            .arg(schem_width as i32)
-            .arg(schem_height as i32)
-            .arg(schem_length as i32)
-            .arg(pattern_width as i32)
-            .arg(pattern_height as i32)
-            .arg(pattern_length as i32)
-            .arg(air_id)
-            .arg(search_behavior.ignore_air as u32)
-            .arg(search_behavior.air_as_any as u32)
-            .arg(skip_amount)
-            .build()
-    })?;
-
-    unsafe {
-        time!(run_kernel, { kernel.enq() })?;
-    }
-
-    let mut vec = vec![0; buffer.len()];
-    time!(read_buffer, {
-        buffer.read(&mut vec).enq()?;
-    });
-
-    Ok(vec
-        .into_iter()
-        .enumerate()
-        .filter(|(_, v)| *v < skip_amount && *v != -1)
-        .map(|(i, v)| Match {
-            x: (i % schem_width) as u16,
-            y: ((i / (schem_width * schem_length)) % schem_height) as u16,
-            z: ((i / schem_width) % schem_length) as u16,
-
-            percent: (pattern_blocks - v as f32) / pattern_blocks,
-        })
-        .collect())
-}
-
-fn create_schem_buffer(pattern: &[i32], pro_que: &ProQue) -> ocl::Result<Buffer<i32>> {
-    Buffer::builder()
-        .queue(pro_que.queue().clone())
-        .flags(MemFlags::new().read_only())
-        .len(pattern.len())
-        // Host Memory Map?
-        .copy_host_slice(pattern)
-        .build()
-}

schemsearch-sql/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "schemsearch-sql"
-version = "0.1.3"
+version = "0.1.1"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-sqlx = { version = "0.7", features = [ "runtime-async-std-native-tls" , "mysql" ] }
+sqlx = { version = "0.6", features = [ "runtime-async-std-native-tls" , "mysql" ] }
 
 schemsearch-lib = { path = "../schemsearch-lib" }
 schemsearch-files = { path = "../schemsearch-files" }