internal void Initialize(int pid)
{
SelectPointerAddresses(GameHashes.DetectVersion(Process.GetProcessesByName("re7").FirstOrDefault().MainModule.FileName));
memoryAccess = new ProcessMemoryHandler(pid);
if (ProcessRunning)
{
connected = true;
BaseAddress = NativeWrappers.GetProcessBaseAddress(pid, PInvoke.ListModules.LIST_MODULES_64BIT).ToInt64(); // Bypass .NET's managed solution for getting this and attempt to get this info ourselves via PInvoke since some users are getting 299 PARTIAL COPY when they seemingly shouldn't.
PointerMrEverythingCount = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + mrEverythingCount), 0x78L, 0x1F0L);
PointerDA = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + difficultyAdjustment));
PointerMapName = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + mapName), 0x700L);
PointerHP = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + hitPoints), 0xA0L, 0xD0L, 0x70L);
//PointerHP = new MultilevelPointer(memoryAccess, BaseAddress + hitPoints, 0xA0L, 0xD0L, 0x70L);
PointerEnemyEntryCount = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + enemyHitPoints), 0x190L, 0x70L);
GenerateEnemyEntries();
PointerBagCount = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + bagCount));
PointerInventoryCount = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + itemCount), 0x60L);
PointerInventorySlotSelected = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + selectedSlot), 0x240L, 0x58L, 0x228L);
PointerItemNames = new MultilevelPointer[32];
PointerItemInfo = new MultilevelPointer[32];
}
}
/// <summary>
///
/// </summary>
/// <param name="proc"></param>
public GameMemory(int pid)
{
memoryAccess = new ProcessMemory.ProcessMemory(pid);
BaseAddress = NativeWrappers.GetProcessBaseAddress(pid, ProcessMemory.PInvoke.ListModules.LIST_MODULES_64BIT).ToInt64(); // Bypass .NET's managed solution for getting this and attempt to get this info ourselves via PInvoke since some users are getting 299 PARTIAL COPY when they seemingly shouldn't. This is built as x64 only and RE3 is x64 only to my knowledge.
SelectPointerAddresses();
// Setup the pointers.
PointerIGT = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressIGT, 0x60L); // *
PointerRank = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressRank); // *
PointerPlayerHP = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressHP, 0x50L, 0x20L); // *
PointerPlayerPoison = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressPoison, 0x50L, 0x20L, 0xF8L);
PointerEnemyEntryCount = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressEnemy, 0x30L); // *
GenerateEnemyEntries();
PointerInventoryEntries = new MultilevelPointer[20];
for (long i = 0; i < PointerInventoryEntries.Length; ++i)
{
PointerInventoryEntries[i] = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressInventory, 0x50L, 0x98L, 0x10L, 0x20L + (i * 0x08L), 0x18L); // *
}
// Initialize variables to default values.
PlayerCurrentHealth = 0;
PlayerMaxHealth = 0;
PlayerPoisoned = false;
PlayerInventory = new InventoryEntry[20];
EnemyHealth = new EnemyHP[32];
IGTRunningTimer = 0L;
IGTCutsceneTimer = 0L;
IGTMenuTimer = 0L;
IGTPausedTimer = 0L;
Rank = 0;
RankScore = 0f;
}
private void GenerateEnemyEntries()
{
EnemyTableCount = PointerEnemyEntryCount.DerefInt(0x820); // Get the size of the enemy pointer table. This seems to double (4, 8, 16, 32, ...) but never decreases, even after a new game is started.
if (PointerEnemyEntries == null || PointerEnemyEntries.Length != EnemyTableCount) // Enter if the pointer table is null (first run) or the size does not match.
{
long position;
if (EnemyTableCount > 0)
{
PointerEnemyEntries = new MultilevelPointer[EnemyTableCount]; // Create a new enemy pointer table array with the detected size.
}
else
{
PointerEnemyEntries = new MultilevelPointer[EnemyTableCount];
}
// Loop through and create all of the pointers for the table.
for (long i = 0; i < PointerEnemyEntries.Length; ++i)
{
position = 0x0L + (i * 0x08L);
PointerEnemyEntries[i] = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + enemyHitPoints), 0x58L, 0xB0L, 0x70L, 0x20L, position, 0x70L);
}
}
}
internal void Initialize(int pid)
{
memoryAccess = new ProcessMemory.ProcessMemory(pid);
if (ProcessRunning)
{
BaseAddress = NativeWrappers.GetProcessBaseAddress(pid, PInvoke.ListModules.LIST_MODULES_64BIT).ToInt64(); // Bypass .NET's managed solution for getting this and attempt to get this info ourselves via PInvoke since some users are getting 299 PARTIAL COPY when they seemingly shouldn't.
PointerPlayerHP = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressHP, 0xC0L, 0x48L, 0x98L, 0x78L);
}
}
/// <summary>
/// Dereferences a 4-byte signed integer via the PointerEnemyEntryCount pointer to detect how large the enemy pointer table is and then create the pointer table entries if required.
/// </summary>
private void GenerateEnemyEntries()
{
EnemyTableCount = PointerEnemyEntryCount.DerefInt(0x1CL); // Get the size of the enemy pointer table. This seems to double (4, 8, 16, 32, ...) but never decreases, even after a new game is started.
if (PointerEnemyEntries == null || PointerEnemyEntries.Length != EnemyTableCount) // Enter if the pointer table is null (first run) or the size does not match.
{
PointerEnemyEntries = new MultilevelPointer[EnemyTableCount]; // Create a new enemy pointer table array with the detected size.
for (long i = 0; i < PointerEnemyEntries.Length; ++i) // Loop through and create all of the pointers for the table.
{
PointerEnemyEntries[i] = new MultilevelPointer(memoryAccess, BaseAddress + pointerAddressEnemy, 0x30L, 0x20L + (i * 0x08L), 0x300L);
}
}
}
private void GetItems()
{
if (gameMemoryValues.PlayerInventoryCount != 0)
{
for (var i = 0; i < gameMemoryValues.PlayerInventoryCount; i++)
{
long position = (0x30L + (0x8L * i));
PointerItemNames[i] = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + itemCount), 0x60L, 0x20L, position, 0x28L, 0x80L);
PointerItemInfo[i] = new MultilevelPointer(memoryAccess, (IntPtr)(BaseAddress + itemCount), 0x60L, 0x20L, position, 0x28L);
}
UpdateItems();
}
}
internal void Initialize(Process process)
{
if (process == null)
{
return; // Do not continue if this is null.
}
SelectPointerAddresses();
int pid = GetProcessId(process).Value;
memoryAccess = new ProcessMemory.ProcessMemory(pid);
if (ProcessRunning)
{
BaseAddress = NativeWrappers.GetProcessBaseAddress(pid, PInvoke.ListModules.LIST_MODULES_64BIT).ToInt64(); // Bypass .NET's managed solution for getting this and attempt to get this info ourselves via PInvoke since some users are getting 299 PARTIAL COPY when they seemingly shouldn't.
PointerSecretAreas = new MultilevelPointer(memoryAccess, BaseAddress + PointerAddressSecretAreas, 0x148L, 0x8L, 0x50L, 0x3E0L, 0x10L);
}
}
/// <summary>
/// Dereferences a 4-byte signed integer via the PointerEnemyEntryCount pointer to detect how large the enemy pointer table is and then create the pointer table entries if required.
/// </summary>
private unsafe void GenerateEnemyEntries()
{
bool success;
fixed(int *p = &EnemyTableCount)
success = PointerEnemyCount.TryDerefInt(0x1C, p);
PointerEnemyEntries = new MultilevelPointer[MAX_ENTITIES]; // Create a new enemy pointer table array with the detected size.
// Skip the first 28 bytes and read the rest as a byte array
// This can be done because the pointers are stored sequentially in an array
byte[] entityPtrByteArr = PointerEnemyEntryList.DerefByteArray(0x28, MAX_ENTITIES * sizeof(IntPtr));
// Do a block copy to convert the byte array to an IntPtr array
IntPtr[] entityPtrArr = new IntPtr[MAX_ENTITIES];
Buffer.BlockCopy(entityPtrByteArr, 0, entityPtrArr, 0, entityPtrByteArr.Length);
// The pointers we read are already the address of the entity, so make sure we add the first offset here
for (int i = 0; i < PointerEnemyEntries.Length; ++i) // Loop through and create all of the pointers for the table.
{
PointerEnemyEntries[i] = new MultilevelPointer(memoryAccess, IntPtr.Add(entityPtrArr[i], 0x228), 0x18L, 0x48L, 0x48L);
}
}
private unsafe void GenerateItemEntries()
{
bool success;
fixed(int *p = &InventoryTableCount)
success = PointerInventoryCount.TryDerefInt(0x1C, p);
PointerInventoryEntries = new MultilevelPointer[MAX_ITEMS];
PointerInventoryEntriesCustom = new MultilevelPointer[MAX_ITEMS];
// Skip the first 28 bytes and read the rest as a byte array
// This can be done because the pointers are stored sequentially in an array
byte[] inventoryEntriesPtrByteArr = PointerInventoryEntryList.DerefByteArray(0x20, MAX_ITEMS * sizeof(IntPtr));
// Do a block copy to convert the byte array to an IntPtr array
IntPtr[] inventoryEntriesPtrArr = new IntPtr[MAX_ITEMS];
Buffer.BlockCopy(inventoryEntriesPtrByteArr, 0, inventoryEntriesPtrArr, 0, inventoryEntriesPtrByteArr.Length);
for (int i = 0; i < PointerInventoryEntries.Length; ++i)
{
PointerInventoryEntries[i] = new MultilevelPointer(memoryAccess, IntPtr.Add(inventoryEntriesPtrArr[i], 0x58));
PointerInventoryEntriesCustom[i] = new MultilevelPointer(memoryAccess, IntPtr.Add(inventoryEntriesPtrArr[i], 0x58), 0x90);
}
}
internal unsafe void Initialize(Process process, ILogger logger)
{
this.logger = logger;
if (process == null)
{
return; // Do not continue if this is null.
}
if (!SelectPointerAddresses(GameHashes.DetectVersion(process.MainModule.FileName)))
{
return; // Unknown version.
}
int pid = GetProcessId(process).Value;
memoryAccess = new ProcessMemoryHandler(pid);
if (ProcessRunning)
{
BaseAddress = NativeWrappers.GetProcessBaseAddress(pid, PInvoke.ListModules.LIST_MODULES_64BIT); // Bypass .NET's managed solution for getting this and attempt to get this info ourselves via PInvoke since some users are getting 299 PARTIAL COPY when they seemingly shouldn't.
// Setup the pointers.
//PointerPlayerHP = new MultilevelPointer(memoryAccess, IntPtr.Add(BaseAddress, pointerAddressHP), 0x58L, 0x18L, 0x18L, 0x78L, 0x68L, 0x48L);
//PointerCurrentView = new MultilevelPointer(memoryAccess, IntPtr.Add(BaseAddress, pointerCurrentView), 0x58L);
PointerEventActionType = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerPropsManager),
0x58L,
0x68L,
0x68L,
0xD0L,
0x38L,
0x50L
);
PointerIsMotionPlay = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerPropsManager),
0x58L,
0x68L,
0x68L,
0xD0L,
0x38L
);
PointerEventActionTask = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerEventActionTask),
0x58L,
0x60L,
0x40L,
0x80L,
0x10L,
0x10L,
0x20L,
0x28L
);
PointerPlayerStatus = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerPropsManager),
0x58L,
0x68L,
0x68L
);
PointerPlayerHP = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerPropsManager),
0x58L,
0x68L,
0x68L,
0xD0L,
0x68L,
0x48L
);
PointerPlayerPosition = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerPropsManager),
0x58L,
0x68L,
0x68L,
0xD0L,
0x78L,
0x50L
);
PointerRankManager = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerRankManager)
);
try
{
PointerInventory = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerInventory),
0x60L,
0x18L,
0x10L
);
//Enemies
PointerEnemyEntryList = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerAddressEnemies),
0x58L,
0x10L
);
PointerEnemyCount = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerAddressEnemies),
0x58L,
0x10L
);
GenerateEnemyEntries();
//Items
PointerInventoryCount = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerInventory),
0x60L,
0x18L,
0x10L
);
PointerInventoryEntryList = new MultilevelPointer(
memoryAccess,
IntPtr.Add(BaseAddress, pointerAddressItems),
0x78L,
0x70L
);
GenerateItemEntries();
}
catch
{
// May fail in main menu
}
}
}
