Merge pull request #493 from tosuapp/non-zero-mask-optional

KotRikD · web-flow · commit 53b7081b4093 · 2025-10-16T11:57:40.000+03:00
fix: optional non-zero mask check
diff --git a/packages/tosu/src/instances/index.ts b/packages/tosu/src/instances/index.ts
@@ -115,7 +115,13 @@ export abstract class AbstractInstance {
             const scanPatterns = this.memory.getScanPatterns();
 
             const results = this.process.scanBatch(
-                Object.values(scanPatterns).map((x) => x.pattern)
+                Object.values(scanPatterns).map((x) => {
+                    return {
+                        value: x.pattern,
+                        nonZeroMask:
+                            x.nonZeroMask === undefined ? false : x.nonZeroMask
+                    };
+                })
             );
 
             const patternsEntries = Object.entries(scanPatterns);
diff --git a/packages/tosu/src/memory/lazer.ts b/packages/tosu/src/memory/lazer.ts
@@ -381,7 +381,8 @@ export class LazerMemory extends AbstractMemory<LazerPatternData> {
         scalingContainerTargetDrawSize: {
             pattern:
                 '00 00 80 44 00 00 40 44 00 00 00 00 ?? ?? ?? ?? 00 00 00 00',
-            offset: 0
+            offset: 0,
+            nonZeroMask: true
         }
     };
 
diff --git a/packages/tosu/src/memory/types.ts b/packages/tosu/src/memory/types.ts
@@ -12,6 +12,7 @@ export type ScanPatterns = {
     [k in keyof any]: {
         pattern: string;
         offset?: number;
+        nonZeroMask?: boolean;
         isTourneyOnly?: boolean;
     };
 };
diff --git a/packages/tsprocess/lib/functions.cc b/packages/tsprocess/lib/functions.cc
@@ -149,22 +149,23 @@ Napi::Value read_double(const Napi::CallbackInfo &args) {
 
 Napi::Value scan_sync(const Napi::CallbackInfo &args) {
   Napi::Env env = args.Env();
-  if (args.Length() < 3) {
+  if (args.Length() < 4) {
     Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
     return env.Null();
   }
 
   auto handle = reinterpret_cast<void *>(args[0].As<Napi::Number>().Int64Value());
   auto signature_buffer = args[1].As<Napi::Uint8Array>();
   auto mask_buffer = args[2].As<Napi::Uint8Array>();
+  auto non_zero_mask = args[3].As<Napi::Boolean>().Value();
 
   auto signature = std::vector<uint8_t>(signature_buffer.ByteLength());
   memcpy(signature.data(), signature_buffer.Data(), signature_buffer.ByteLength());
 
   auto mask = std::vector<uint8_t>(mask_buffer.ByteLength());
   memcpy(mask.data(), mask_buffer.Data(), mask_buffer.ByteLength());
 
-  auto result = memory::find_pattern(handle, signature, mask);
+  auto result = memory::find_pattern(handle, signature, mask, non_zero_mask);
 
   if (!result) {
     Napi::TypeError::New(env, "Couldn't find signature").ThrowAsJavaScriptException();
@@ -193,10 +194,12 @@ Napi::Value batch_scan(const Napi::CallbackInfo &args) {
     auto iter_obj = pattern_array.Get(i).As<Napi::Object>();
     auto signature = iter_obj.Get("signature").As<Napi::Uint8Array>();
     auto mask = iter_obj.Get("mask").As<Napi::Uint8Array>();
+    auto non_zero_mask = iter_obj.Get("nonZeroMask").As<Napi::Boolean>().Value();
 
     pattern.index = i;
     pattern.signature = std::span<uint8_t>(reinterpret_cast<uint8_t *>(signature.Data()), signature.ByteLength());
     pattern.mask = std::span<uint8_t>(reinterpret_cast<uint8_t *>(mask.Data()), mask.ByteLength());
+    pattern.non_zero_mask = non_zero_mask;
     pattern.found = false;
 
     patterns.push_back(pattern);
@@ -249,7 +252,7 @@ static bool scanning = false;
 
 Napi::Value scan(const Napi::CallbackInfo &args) {
   Napi::Env env = args.Env();
-  if (args.Length() < 4) {
+  if (args.Length() < 5) {
     Napi::TypeError::New(env, "Wrong number of arguments").ThrowAsJavaScriptException();
     return env.Null();
   }
@@ -258,6 +261,8 @@ Napi::Value scan(const Napi::CallbackInfo &args) {
   auto signature = args[1].As<Napi::Uint8Array>();
   auto mask = args[2].As<Napi::Uint8Array>();
   auto callback = Napi::ThreadSafeFunction::New(args.Env(), args[3].As<Napi::Function>(), "tsfn", 0, 1);
+  auto non_zero_mask = args[4].As<Napi::Boolean>().Value();
+
   auto signature_data = signature.Data();
   auto signature_length = signature.ByteLength();
   auto mask_data = mask.Data();
@@ -267,14 +272,14 @@ Napi::Value scan(const Napi::CallbackInfo &args) {
     scanning = true;
 
     std::thread(
-      [handle, signature_data, signature_length, mask_data, mask_length](Napi::ThreadSafeFunction tsfn) {
+      [handle, signature_data, signature_length, mask_data, mask_length, non_zero_mask](Napi::ThreadSafeFunction tsfn) {
         auto signature = std::vector<uint8_t>(signature_length);
         memcpy(signature.data(), signature_data, signature_length);
 
         auto mask = std::vector<uint8_t>(mask_length);
         memcpy(mask.data(), mask_data, mask_length);
 
-        const auto result = memory::find_pattern(handle, signature, mask);
+        const auto result = memory::find_pattern(handle, signature, mask, non_zero_mask);
         scanning = false;
         tsfn.BlockingCall([result, tsfn](Napi::Env env, Napi::Function jsCallback) {
           jsCallback.Call({Napi::Number::From(env, result)});
diff --git a/packages/tsprocess/lib/memory/memory.h b/packages/tsprocess/lib/memory/memory.h
@@ -17,6 +17,7 @@ struct Pattern {
   int index;
   std::span<uint8_t> signature;
   std::span<uint8_t> mask;
+  bool non_zero_mask;
   bool found;
 };
 
@@ -49,14 +50,26 @@ std::tuple<T, bool> read(void *process, uintptr_t address) {
   return std::make_tuple(data, success);
 }
 
-inline bool scan(std::vector<uint8_t> buffer, std::span<uint8_t> signature, std::span<uint8_t> mask, size_t &offset) {
+inline bool scan(
+  std::vector<uint8_t> buffer,
+  std::span<uint8_t> signature,
+  std::span<uint8_t> mask,
+  size_t &offset,
+  bool non_zero_mask
+) {
   offset = 0;
 
   for (size_t i = 0; i + signature.size() <= buffer.size(); ++i) {
     bool found = true;
     for (size_t j = 0; j < signature.size(); ++j) {
-      if ((buffer[i + j] == signature[j] && mask[j] == 1) || (mask[j] == 0 && buffer[i + j] != 0)) {
-        continue;
+      if (non_zero_mask) {
+        if ((buffer[i + j] == signature[j] && mask[j] == 1) || (mask[j] == 0 && buffer[i + j] != 0)) {
+          continue;
+        }
+      } else {
+        if (buffer[i + j] == signature[j] || mask[j] == 0) {
+          continue;
+        }
       }
 
       found = false;
@@ -74,14 +87,26 @@ inline bool scan(std::vector<uint8_t> buffer, std::span<uint8_t> signature, std:
   return false;
 }
 
-inline bool scan(std::vector<uint8_t> buffer, std::vector<uint8_t> signature, std::vector<uint8_t> mask, size_t &offset) {
+inline bool scan(
+  std::vector<uint8_t> buffer,
+  std::vector<uint8_t> signature,
+  std::vector<uint8_t> mask,
+  size_t &offset,
+  bool non_zero_mask
+) {
   offset = 0;
 
   for (size_t i = 0; i + signature.size() <= buffer.size(); ++i) {
     auto found = true;
     for (size_t j = 0; j < signature.size(); ++j) {
-      if ((buffer[i + j] == signature[j] && mask[j] == 1) || (mask[j] == 0 && buffer[i + j] != 0)) {
-        continue;
+      if (non_zero_mask) {
+        if ((buffer[i + j] == signature[j] && mask[j] == 1) || (mask[j] == 0 && buffer[i + j] != 0)) {
+          continue;
+        }
+      } else {
+        if (buffer[i + j] == signature[j] || mask[j] == 0) {
+          continue;
+        }
       }
 
       found = false;
@@ -99,7 +124,8 @@ inline bool scan(std::vector<uint8_t> buffer, std::vector<uint8_t> signature, st
   return false;
 }
 
-inline uintptr_t find_pattern(void *process, const std::vector<uint8_t> signature, const std::vector<uint8_t> mask) {
+inline uintptr_t
+find_pattern(void *process, const std::vector<uint8_t> signature, const std::vector<uint8_t> mask, bool non_zero_mask) {
   const auto regions = query_regions(process);
 
   for (auto &region : regions) {
@@ -109,7 +135,7 @@ inline uintptr_t find_pattern(void *process, const std::vector<uint8_t> signatur
     }
 
     size_t offset;
-    if (!scan(buffer, signature, mask, offset)) {
+    if (!scan(buffer, signature, mask, offset, non_zero_mask)) {
       continue;
     }
 
@@ -136,7 +162,7 @@ inline std::vector<PatternResult> batch_find_pattern(void *process, std::vector<
       }
 
       size_t offset;
-      if (!scan(buffer, pattern.signature, pattern.mask, offset)) {
+      if (!scan(buffer, pattern.signature, pattern.mask, offset, pattern.non_zero_mask)) {
         continue;
       }
 
diff --git a/packages/tsprocess/src/process.ts b/packages/tsprocess/src/process.ts
@@ -13,6 +13,12 @@ export interface ProcessInfo {
 export interface Pattern {
     signature: Buffer;
     mask: Buffer;
+    nonZeroMask: boolean;
+}
+
+export interface Signature {
+    value: string;
+    nonZeroMask: boolean;
 }
 
 export interface PatternResult {
@@ -212,7 +218,7 @@ export class Process {
             'hex'
         );
 
-        return { signature, mask };
+        return { signature, mask, nonZeroMask: false };
     }
 
     readBuffer(address: number, size: number): Buffer {
@@ -224,23 +230,34 @@ export class Process {
         );
     }
 
-    scanSync(pattern: string): number {
+    scanSync(pattern: string, nonZeroMask: boolean = false): number {
         const result = Process.buildPattern(pattern);
 
         return ProcessUtils.scanSync(
             this.handle,
             result.signature,
-            result.mask
+            result.mask,
+            nonZeroMask
         );
     }
 
-    scan(pattern: string, callback: (address: number) => void): void {
+    scan(
+        pattern: string,
+        callback: (address: number) => void,
+        nonZeroMask: boolean = false
+    ): void {
         const result = Process.buildPattern(pattern);
 
-        ProcessUtils.scan(this.handle, result.signature, result.mask, callback);
+        ProcessUtils.scan(
+            this.handle,
+            result.signature,
+            result.mask,
+            callback,
+            nonZeroMask
+        );
     }
 
-    scanAsync(pattern: string): Promise<number> {
+    scanAsync(pattern: string, nonZeroMask: boolean = false): Promise<number> {
         const result = Process.buildPattern(pattern);
 
         return new Promise((resolve, reject) => {
@@ -249,23 +266,25 @@ export class Process {
                     this.handle,
                     result.signature,
                     result.mask,
-                    resolve
+                    resolve,
+                    nonZeroMask
                 );
             } catch (e) {
                 reject(e);
             }
         });
     }
 
-    scanBatch(signatures: string[]): PatternResult[] {
+    scanBatch(signatures: Signature[]): PatternResult[] {
         const patterns: Pattern[] = [];
 
         for (const signature of signatures) {
-            const result = Process.buildPattern(signature);
+            const result = Process.buildPattern(signature.value);
 
             patterns.push({
                 signature: result.signature,
-                mask: result.mask
+                mask: result.mask,
+                nonZeroMask: signature.nonZeroMask
             });
         }
 

Original file line number	Diff line number	Diff line change
`@@ -381,7 +381,8 @@ export class LazerMemory extends AbstractMemory<LazerPatternData> {`
`381`	`381`	`scalingContainerTargetDrawSize: {`
`382`	`382`	`pattern:`
`383`	`383`	`'00 00 80 44 00 00 40 44 00 00 00 00 ?? ?? ?? ?? 00 00 00 00',`
`384`		`- offset: 0`
	`384`	`+ offset: 0,`
	`385`	`+ nonZeroMask: true`
`385`	`386`	`}`
`386`	`387`	`};`
`387`	`388`