Copy

#pragma once
#include "pattern.hpp"
#include "range.hpp"
#include "signature.hpp"

#include 

namespace memory
{
	template
	struct batch
	{
		std::array<signature, N> m_entries;

		constexpr batch(std::array<signature, N> entries)
		{
			m_entries = entries;
		}
	};

	template
	struct batch_and_hash
	{
		batch m_batch;
		uint32_t m_hash;
	};

	struct signature_hasher
	{
		static inline constexpr uint32_t FNV_PRIME_32  = 16777619u;
		static inline constexpr uint32_t FNV_OFFSET_32 = 2166136261u;

		static inline constexpr uint32_t fnv1a_32(const char* str, uint32_t hash = FNV_OFFSET_32) noexcept
		{
			return (str[0] == '\0') ? hash : fnv1a_32(&str[1], (hash ^ static_cast(str[0])) * FNV_PRIME_32);
		}

		template
		static inline constexpr uint32_t compute_hash(uint32_t hash)
		{
			hash = fnv1a_32(sig.m_ida, hash);

			return hash;
		}

		template
		static inline constexpr uint32_t add(uint32_t hash = FNV_OFFSET_32)
		{
			hash = compute_hash(hash);

			if constexpr (sizeof...(rest_sigs) > 0)
			{
				hash = add(hash);
			}

			return hash;
		}
	};

	template
	static inline constexpr auto make_batch(uint32_t hash = signature_hasher::FNV_OFFSET_32)
	{
		constexpr std::array<signature, sizeof...(args)> a1 = {args...};

		constexpr memory::batch<a1.size()> h(a1);

		return batch_and_hash<a1.size()>{h, signature_hasher::add()};
	}

	struct batch_runner
	{
		inline static std::mutex s_entry_mutex;
		inline static std::vector<std::future> g_futures;

		template
		inline static bool run(const memory::batch batch, range region)
		{
			for (auto& entry : batch.m_entries)
			{
				g_futures.emplace_back(std::async(&scan_pattern_and_execute_callback, region, entry));
			}

			bool found_all_patterns = true;
			for (auto& future : g_futures)
			{
				future.wait();

				if (!future.get())
					found_all_patterns = false;
			}

			g_futures.clear();

			return found_all_patterns;
		}

		inline static bool scan_pattern_and_execute_callback(range region, signature entry)
		{
			if (auto result = region.scan(entry.m_ida); result.has_value())
			{
				if (entry.m_on_signature_found)
				{
					std::lock_guard lock(s_entry_mutex); // Acquire a lock on the mutex to synchronize access.

					std::invoke(std::move(entry.m_on_signature_found), result.value());
					LOG(INFO) << "Found '" << entry.m_name << "' GTA5.exe+"
					          << HEX_TO_UPPER(result.value().as() - region.begin().as());

					return true;
				}
			}

			LOG(WARNING) << "Failed to find '" << entry.m_name << "'.";

			return false;
		}
	};
}
#include "pattern.hpp" #include "../common.hpp" namespace memory { std::optional to_hex(char const c) { switch (c) { case '0': return static_cast(0x0); case '1': return static_cast(0x1); case '2': return static_cast(0x2); case '3': return static_cast(0x3); case '4': return static_cast(0x4); case '5': return static_cast(0x5); case '6': return static_cast(0x6); case '7': return static_cast(0x7); case '8': return static_cast(0x8); case '9': return static_cast(0x9); case 'a': return static_cast(0xa); case 'b': return static_cast(0xb); case 'c': return static_cast(0xc); case 'd': return static_cast(0xd); case 'e': return static_cast(0xe); case 'f': return static_cast(0xf); case 'A': return static_cast(0xA); case 'B': return static_cast(0xB); case 'C': return static_cast(0xC); case 'D': return static_cast(0xD); case 'E': return static_cast(0xE); case 'F': return static_cast(0xF); default: return std::nullopt; } } pattern::pattern(std::string_view ida_sig) { const auto size_minus_one = ida_sig.size() - 1; m_bytes.reserve(size_minus_one / 2); for (size_t i = 0; i != size_minus_one; ++i) { if (ida_sig[i] == ' ') continue; if (ida_sig[i] != '?') { auto c1 = to_hex(ida_sig[i]); auto c2 = to_hex(ida_sig[i + 1]); if (c1 && c2) { m_bytes.emplace_back(static_cast((*c1 * 0x10) + *c2)); } } else { m_bytes.push_back({}); } } } }