private static Dictionary <ushort, string> GetSystemMessages(ModuleSnapshot snapshot, string pattern, int patternOffset)
{
Dictionary <ushort, string> result = new Dictionary <ushort, string>();
IntPtr funcAddress = new IntPtr(snapshot.FindPattern(pattern, 0, 0, false, false));
GetMessageNameFunc func = funcAddress.ToDelegate <GetMessageNameFunc>();
uint count = LocalMemory.Read <uint>(funcAddress + patternOffset);
for (ushort i = 0; i < count; i++)
{
result.Add(i, Marshal.PtrToStringUni(func(i)));
}
return(result);
}
/// <summary>
/// Read an object of the specified struct from the current process.
/// </summary>
/// <typeparam name="T">The type of the struct.</typeparam>
/// <param name="address">The address to read from.</param>
/// <param name="result">The resulting object.</param>
/// <returns>Whether or not the read succeeded.</returns>
public static bool Read <T>(IntPtr address, out T result) where T : struct
{
if (!ReadBytes(address, SizeCache <T> .Size, out var buffer))
{
result = default;
return(false);
}
using var mem = new LocalMemory(buffer.Length);
mem.Write(buffer);
result = mem.Read <T>();
return(true);
}
/// <summary>
/// Marshals data from an unmanaged block of memory to a managed object.
/// </summary>
/// <param name="addr">The address to read from.</param>
/// <param name="type">The type to create.</param>
/// <returns>The read object, or null, if it could not be read.</returns>
public static object?PtrToStructure(IntPtr addr, Type type)
{
var size = Marshal.SizeOf(type);
if (!ReadBytes(addr, size, out var buffer))
{
return(null);
}
var mem = new LocalMemory(size);
mem.Write(buffer);
return(mem.Read(type));
}
/// <summary>
/// Write an array of structs to the current process.
/// </summary>
/// <typeparam name="T">The type of the structs.</typeparam>
/// <param name="address">The address to write to.</param>
/// <param name="objArray">The array to write.</param>
/// <returns>Whether or not the write succeeded.</returns>
public static bool Write <T>(IntPtr address, T[] objArray) where T : struct
{
if (objArray == null || objArray.Length == 0)
{
return(true);
}
var size = SizeCache <T> .Size;
using var mem = new LocalMemory(objArray.Length * size);
for (var i = 0; i < objArray.Length; i++)
{
mem.Write(objArray[i], i * size);
}
return(WriteBytes(address, mem.Read()));
}
/// <summary>
/// Read an array of objects of the specified struct from the current process.
/// </summary>
/// <typeparam name="T">The type of the struct.</typeparam>
/// <param name="address">The address to read from.</param>
/// <param name="count">The length of the array.</param>
/// <returns>An array of the read objects, or null if any entry of the array failed to read.</returns>
public static T[]? Read <T>(IntPtr address, int count) where T : struct
{
var size = SizeOf <T>();
if (!ReadBytes(address, count * size, out var buffer))
{
return(null);
}
var result = new T[count];
using var mem = new LocalMemory(buffer.Length);
mem.Write(buffer);
for (var i = 0; i < result.Length; i++)
{
result[i] = mem.Read <T>(i * size);
}
return(result);
}
/// <summary>
/// Write a struct to the current process.
/// </summary>
/// <typeparam name="T">The type of the struct.</typeparam>
/// <param name="address">The address to write to.</param>
/// <param name="obj">The object to write.</param>
/// <returns>Whether or not the write succeeded.</returns>
public static bool Write <T>(IntPtr address, T obj) where T : struct
{
using var mem = new LocalMemory(SizeCache <T> .Size);
mem.Write(obj);
return(WriteBytes(address, mem.Read()));
}
private static uint GetVersion(ModuleSnapshot snapshot, string pattern, int patternOffset) => LocalMemory.Read <uint>((IntPtr)snapshot.FindPattern(pattern, patternOffset, 0, true, false));