Added IComplexScanComparer.

Implemented RegexStringMemoryComparer.
Implemented ComplexScannerWorker.

Author: KN4CK3R

ReClass.NET/MemoryScanner/Comparer/IComplexScanComparer.cs

@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+
+namespace ReClassNET.MemoryScanner.Comparer
+{
+	public interface IComplexScanComparer : IScanComparer
+	{
+		/// <summary>
+		/// Compares all data to the current <see cref="IScanComparer.CompareType"/>.
+		/// </summary>
+		/// <param name="data">The byte array to be compared.</param>
+		/// <param name="size">The index into the byte array.</param>
+		/// <returns>List of matches.</returns>
+		IEnumerable<ScanResult> Compare(byte[] data, int size);
+
+		/// <summary>
+		/// Compares all data to the current <see cref="IScanComparer.CompareType"/>.
+		/// The previous results may be used.
+		/// </summary>
+		/// <param name="data">The byte array to be compared.</param>
+		/// <param name="size">The index into the byte array.</param>
+		/// <param name="previous">Scan result to be compared.</param>
+		/// <param name="result">[out] The scan result if the <see cref="IScanComparer.CompareType"/> matched.</param>
+		/// <returns>True if matched.</returns>
+		bool CompareWithPrevious(byte[] data, int size, ScanResult previous, out ScanResult result);
+	}
+}

ReClass.NET/MemoryScanner/Comparer/RegexStringMemoryComparer.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace ReClassNET.MemoryScanner.Comparer
+{
+	public class RegexStringMemoryComparer : IComplexScanComparer
+	{
+		public ScanCompareType CompareType => ScanCompareType.Equal;
+
+		public Regex Pattern { get; }
+
+		public Encoding Encoding { get; }
+
+		public RegexStringMemoryComparer(string pattern, Encoding encoding)
+		{
+			Pattern = new Regex(pattern, RegexOptions.Singleline | RegexOptions.Compiled);
+
+			Encoding = encoding;
+		}
+
+		public IEnumerable<ScanResult> Compare(byte[] data, int size)
+		{
+			var buffer = Encoding.GetString(data, 0, size);
+			var bufferArray = buffer.ToCharArray();
+
+			var lastIndex = 0;
+			var lastOffset = 0;
+
+			var match = Pattern.Match(buffer);
+			while (match.Success)
+			{
+				var byteOffset = Encoding.GetByteCount(bufferArray, lastIndex, match.Index) + lastOffset;
+
+				lastIndex = match.Index;
+				lastOffset = byteOffset;
+
+				yield return new RegexStringScanResult(match.Value, Encoding)
+				{
+					Address = (IntPtr)byteOffset
+				};
+
+				match = match.NextMatch();
+			}
+		}
+
+		public bool CompareWithPrevious(byte[] data, int size, ScanResult previous, out ScanResult result)
+		{
+			result = null;
+
+			var byteOffset = previous.Address.ToInt32();
+			if (byteOffset >= size)
+			{
+				return false;
+			}
+
+			var buffer = Encoding.GetString(data, byteOffset, size - byteOffset);
+
+			var match = Pattern.Match(buffer);
+			if (!match.Success)
+			{
+				return false;
+			}
+
+			result = new RegexStringScanResult(match.Value, Encoding)
+			{
+				Address = (IntPtr)byteOffset
+			};
+
+			return true;
+		}
+	}
+}

ReClass.NET/MemoryScanner/ComplexScannerWorker.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Threading;
+using ReClassNET.MemoryScanner.Comparer;
+
+namespace ReClassNET.MemoryScanner
+{
+	internal class ComplexScannerWorker : IScannerWorker
+	{
+		private readonly ScanSettings settings;
+		private readonly IComplexScanComparer comparer;
+
+		public ComplexScannerWorker(ScanSettings settings, IComplexScanComparer comparer)
+		{
+			this.settings = settings;
+			this.comparer = comparer;
+		}
+
+		public IList<ScanResult> Search(byte[] data, int count, CancellationToken ct)
+		{
+			var results = new List<ScanResult>();
+
+			foreach (var result in comparer.Compare(data, count))
+			{
+				results.Add(result);
+
+				if (ct.IsCancellationRequested)
+				{
+					break;
+				}
+			}
+
+			return results;
+		}
+
+		public IList<ScanResult> Search(byte[] data, int count, IEnumerable<ScanResult> previousResults, CancellationToken ct)
+		{
+			var results = new List<ScanResult>();
+
+			foreach (var previousResult in previousResults)
+			{
+				if (ct.IsCancellationRequested)
+				{
+					break;
+				}
+
+				if (comparer.CompareWithPrevious(data, count, previousResult, out var result))
+				{
+					result.Address = previousResult.Address;
+
+					results.Add(result);
+				}
+			}
+
+			return results;
+		}
+	}
+}

ReClass.NET/MemoryScanner/ScanResult.cs

@@ -295,4 +295,18 @@ public override int GetHashCode()
 			return Address.GetHashCode() * 19 + Value.GetHashCode() * 19 + Encoding.GetHashCode();
 		}
 	}
+
+	public class RegexStringScanResult : StringScanResult
+	{
+		public RegexStringScanResult(string value, Encoding encoding)
+			: base(value, encoding)
+		{
+
+		}
+
+		public override ScanResult Clone()
+		{
+			return new RegexStringScanResult(Value, Encoding) { Address = Address };
+		}
+	}
 }

ReClass.NET/MemoryScanner/Scanner.cs

@@ -406,6 +406,9 @@ private static IScannerWorker CreateWorker(ScanSettings settings, IScanComparer
 			{
 				return new SimpleScannerWorker(settings, simpleScanComparer);
 			}
+			if (comparer is IComplexScanComparer complexScanComparer)
+			{
+				return new ComplexScannerWorker(settings, complexScanComparer);
 			}
 
 			throw new Exception();

ReClass.NET/ReClass.NET.csproj

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
@@ -242,12 +242,15 @@
     <Compile Include="MemoryScanner\Comparer\ByteMemoryComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\DoubleMemoryComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\FloatMemoryComparer.cs" />
+    <Compile Include="MemoryScanner\Comparer\IComplexScanComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\IScanComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\IntegerMemoryComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\ISimpleScanComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\LongMemoryComparer.cs" />
+    <Compile Include="MemoryScanner\Comparer\RegexStringMemoryComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\ShortMemoryComparer.cs" />
     <Compile Include="MemoryScanner\Comparer\StringMemoryComparer.cs" />
+    <Compile Include="MemoryScanner\ComplexScannerWorker.cs" />
     <Compile Include="MemoryScanner\InputCorrelatedScanner.cs" />
     <Compile Include="MemoryScanner\IScannerWorker.cs" />
     <Compile Include="MemoryScanner\MemoryRecord.cs" />