public ulong GetUInt64(IntPtr address, long offset = 0)
{
var value = new byte[8];
Peek(new IntPtr(address.ToInt64() + offset), value);
return(BitConverter.TryToUInt32(value, 0));
}
public short GetInt16(IntPtr address, long offset = 0)
{
var value = new byte[2];
Peek(new IntPtr(address.ToInt64() + offset), value);
return(BitConverter.TryToInt16(value, 0));
}
public long GetPlatformUIntFromBytes(byte[] source, int index = 0)
{
if (ProcessModel.IsWin64)
{
return((long)BitConverter.TryToUInt64(source, index));
}
return(BitConverter.TryToUInt32(source, index));
}
public IntPtr ReadPointer(IntPtr address, long offset = 0)
{
if (ProcessModel.IsWin64)
{
var win64 = new byte[8];
Peek(new IntPtr(address.ToInt64() + offset), win64);
return(new IntPtr(BitConverter.TryToInt64(win64, 0)));
}
var win32 = new byte[4];
Peek(new IntPtr(address.ToInt64() + offset), win32);
return(IntPtr.Add(IntPtr.Zero, BitConverter.TryToInt32(win32, 0)));
}
public static TargetReadResult GetTargetInfo()
{
var result = new TargetReadResult();
if (!CanGetTargetInfo() || !MemoryHandler.Instance.IsAttached)
{
return(result);
}
try
{
var targetAddress = (IntPtr)Scanner.Instance.Locations[Signatures.TargetKey];
if (targetAddress.ToInt64() > 0)
{
var targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, MemoryHandler.Instance.Structures.TargetInfo.SourceSize);
var currentTarget = MemoryHandler.Instance.GetPlatformIntFromBytes(targetInfoSource, MemoryHandler.Instance.Structures.TargetInfo.Current);
var mouseOverTarget = MemoryHandler.Instance.GetPlatformIntFromBytes(targetInfoSource, MemoryHandler.Instance.Structures.TargetInfo.MouseOver);
var focusTarget = MemoryHandler.Instance.GetPlatformIntFromBytes(targetInfoSource, MemoryHandler.Instance.Structures.TargetInfo.Focus);
var previousTarget = MemoryHandler.Instance.GetPlatformIntFromBytes(targetInfoSource, MemoryHandler.Instance.Structures.TargetInfo.Previous);
var currentTargetID = BitConverter.TryToUInt32(targetInfoSource, MemoryHandler.Instance.Structures.TargetInfo.CurrentID);
if (currentTarget > 0)
{
try
{
var entry = GetTargetActorEntityFromSource(currentTarget);
currentTargetID = entry.ID;
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetEntity.CurrentTarget = entry;
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
if (mouseOverTarget > 0)
{
try
{
var entry = GetTargetActorEntityFromSource(mouseOverTarget);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetEntity.MouseOverTarget = entry;
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
if (focusTarget > 0)
{
try
{
var entry = GetTargetActorEntityFromSource(focusTarget);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetEntity.FocusTarget = entry;
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
if (previousTarget > 0)
{
try
{
var entry = GetTargetActorEntityFromSource(previousTarget);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetEntity.PreviousTarget = entry;
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
if (currentTargetID > 0)
{
result.TargetsFound = true;
result.TargetEntity.CurrentTargetID = currentTargetID;
}
}
if (result.TargetEntity.CurrentTargetID > 0)
{
var enmityEntries = new List <EnmityEntry>();
try
{
if (CanGetEnmityEntities())
{
var enmityCount = MemoryHandler.Instance.GetInt16(Scanner.Instance.Locations[Signatures.EnmityCountKey]);
var enmityStructure = (IntPtr)Scanner.Instance.Locations[Signatures.EnmityMapKey];
if (enmityCount > 0 && enmityCount < 16 && enmityStructure.ToInt64() > 0)
{
for (uint i = 0; i < enmityCount; i++)
{
try
{
var address = new IntPtr(enmityStructure.ToInt64() + i * 72);
var enmityEntry = new EnmityEntry
{
ID = (uint)MemoryHandler.Instance.GetPlatformInt(address, MemoryHandler.Instance.Structures.EnmityEntry.ID),
Name = MemoryHandler.Instance.GetString(address + MemoryHandler.Instance.Structures.EnmityEntry.Name),
Enmity = MemoryHandler.Instance.GetUInt32(address + MemoryHandler.Instance.Structures.EnmityEntry.Enmity)
};
if (enmityEntry.ID <= 0)
{
continue;
}
if (string.IsNullOrWhiteSpace(enmityEntry.Name))
{
var pc = PCWorkerDelegate.GetEntity(enmityEntry.ID);
var npc = NPCWorkerDelegate.GetEntity(enmityEntry.ID);
var monster = MonsterWorkerDelegate.GetEntity(enmityEntry.ID);
try
{
enmityEntry.Name = (pc ?? npc).Name ?? monster.Name;
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
enmityEntries.Add(enmityEntry);
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
}
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
result.TargetEntity.EnmityEntries = enmityEntries;
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
return(result);
}
public static ActorReadResult GetActors()
{
var result = new ActorReadResult();
if (!Scanner.Instance.Locations.ContainsKey("CHARMAP"))
{
return(result);
}
try
{
#region Ensure Target
var targetAddress = IntPtr.Zero;
#endregion
var endianSize = MemoryHandler.Instance.ProcessModel.IsWin64 ? 8 : 4;
var limit = MemoryHandler.Instance.Structures.ActorInfo.Size;
var characterAddressMap = MemoryHandler.Instance.GetByteArray(Scanner.Instance.Locations["CHARMAP"], endianSize * limit);
var uniqueAddresses = new Dictionary <IntPtr, IntPtr>();
var firstAddress = IntPtr.Zero;
var firstTime = true;
for (var i = 0; i < limit; i++)
{
IntPtr characterAddress;
if (MemoryHandler.Instance.ProcessModel.IsWin64)
{
characterAddress = new IntPtr(BitConverter.TryToInt64(characterAddressMap, i * endianSize));
}
else
{
characterAddress = new IntPtr(BitConverter.TryToInt32(characterAddressMap, i * endianSize));
}
if (characterAddress == IntPtr.Zero)
{
continue;
}
if (firstTime)
{
firstAddress = characterAddress;
firstTime = false;
}
uniqueAddresses[characterAddress] = characterAddress;
}
#region ActorEntity Handlers
result.RemovedMonster = MonsterWorkerDelegate.EntitiesDictionary.Keys.ToDictionary(key => key);
result.RemovedNPC = NPCWorkerDelegate.EntitiesDictionary.Keys.ToDictionary(key => key);
result.RemovedPC = PCWorkerDelegate.EntitiesDictionary.Keys.ToDictionary(key => key);
foreach (var kvp in uniqueAddresses)
{
try
{
var source = MemoryHandler.Instance.GetByteArray(new IntPtr(kvp.Value.ToInt64()), 0x23F0);
//var source = MemoryHandler.Instance.GetByteArray(characterAddress, 0x3F40);
var ID = BitConverter.TryToUInt32(source, MemoryHandler.Instance.Structures.ActorEntity.ID);
var NPCID2 = BitConverter.TryToUInt32(source, MemoryHandler.Instance.Structures.ActorEntity.NPCID2);
var Type = (Actor.Type)source[MemoryHandler.Instance.Structures.ActorEntity.Type];
ActorEntity existing = null;
var newEntry = false;
switch (Type)
{
case Actor.Type.Monster:
if (result.RemovedMonster.ContainsKey(ID))
{
result.RemovedMonster.Remove(ID);
existing = MonsterWorkerDelegate.GetEntity(ID);
}
else
{
result.NewMonster.Add(ID);
newEntry = true;
}
break;
case Actor.Type.PC:
if (result.RemovedPC.ContainsKey(ID))
{
result.RemovedPC.Remove(ID);
existing = PCWorkerDelegate.GetEntity(ID);
}
else
{
result.NewPC.Add(ID);
newEntry = true;
}
break;
case Actor.Type.NPC:
case Actor.Type.Aetheryte:
case Actor.Type.EObj:
if (result.RemovedNPC.ContainsKey(NPCID2))
{
result.RemovedNPC.Remove(NPCID2);
existing = NPCWorkerDelegate.GetEntity(NPCID2);
}
else
{
result.NewNPC.Add(NPCID2);
newEntry = true;
}
break;
default:
if (result.RemovedNPC.ContainsKey(ID))
{
result.RemovedNPC.Remove(ID);
existing = NPCWorkerDelegate.GetEntity(ID);
}
else
{
result.NewNPC.Add(ID);
newEntry = true;
}
break;
}
var isFirstEntry = kvp.Value.ToInt64() == firstAddress.ToInt64();
var entry = ActorEntityHelper.ResolveActorFromBytes(source, isFirstEntry, existing);
#region Ensure Map & Zone
EnsureMapAndZone(entry);
#endregion
if (isFirstEntry)
{
if (targetAddress.ToInt64() > 0)
{
var targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, 128);
entry.TargetID = (int)BitConverter.TryToUInt32(targetInfoSource, MemoryHandler.Instance.Structures.ActorEntity.ID);
}
}
if (!entry.IsValid)
{
result.NewMonster.Remove(entry.ID);
result.NewMonster.Remove(entry.NPCID2);
result.NewNPC.Remove(entry.ID);
result.NewNPC.Remove(entry.NPCID2);
result.NewPC.Remove(entry.ID);
result.NewPC.Remove(entry.NPCID2);
continue;
}
if (existing != null)
{
continue;
}
if (newEntry)
{
switch (entry.Type)
{
case Actor.Type.Monster:
MonsterWorkerDelegate.EnsureEntity(entry.ID, entry);
break;
case Actor.Type.PC:
PCWorkerDelegate.EnsureEntity(entry.ID, entry);
break;
case Actor.Type.Aetheryte:
case Actor.Type.EObj:
case Actor.Type.NPC:
NPCWorkerDelegate.EnsureEntity(entry.NPCID2, entry);
break;
default:
NPCWorkerDelegate.EnsureEntity(entry.ID, entry);
break;
}
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
try
{
// REMOVE OLD MONSTERS FROM LIVE CURRENT DICTIONARY
foreach (var kvp in result.RemovedMonster)
{
MonsterWorkerDelegate.RemoveEntity(kvp.Key);
}
// REMOVE OLD NPC'S FROM LIVE CURRENT DICTIONARY
foreach (var kvp in result.RemovedNPC)
{
NPCWorkerDelegate.RemoveEntity(kvp.Key);
}
// REMOVE OLD PC'S FROM LIVE CURRENT DICTIONARY
foreach (var kvp in result.RemovedPC)
{
PCWorkerDelegate.RemoveEntity(kvp.Key);
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
MemoryHandler.Instance.ScanCount++;
#endregion
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
return(result);
}
public static PartyInfoReadResult GetPartyMembers()
{
var result = new PartyInfoReadResult();
if (!CanGetPartyMembers() || !MemoryHandler.Instance.IsAttached)
{
return(result);
}
var PartyInfoMap = (IntPtr)Scanner.Instance.Locations[Signatures.PartyMapKey];
var PartyCountMap = Scanner.Instance.Locations[Signatures.PartyCountKey];
try
{
var partyCount = MemoryHandler.Instance.GetByte(PartyCountMap);
if (partyCount > 1 && partyCount < 9)
{
for (uint i = 0; i < partyCount; i++)
{
var size = (uint)MemoryHandler.Instance.Structures.PartyInfo.Size;
var address = PartyInfoMap.ToInt64() + i * size;
var source = MemoryHandler.Instance.GetByteArray(new IntPtr(address), (int)size);
var ID = BitConverter.TryToUInt32(source, MemoryHandler.Instance.Structures.PartyEntity.ID);
ActorEntity existing = null;
if (result.RemovedParty.ContainsKey(ID))
{
result.RemovedParty.Remove(ID);
if (MonsterWorkerDelegate.EntitiesDictionary.ContainsKey(ID))
{
existing = MonsterWorkerDelegate.GetEntity(ID);
}
if (PCWorkerDelegate.EntitiesDictionary.ContainsKey(ID))
{
existing = PCWorkerDelegate.GetEntity(ID);
}
}
else
{
result.NewParty.Add(ID);
}
var entry = PartyEntityHelper.ResolvePartyMemberFromBytes(source, existing);
if (!entry.IsValid)
{
continue;
}
if (existing != null)
{
continue;
}
PartyInfoWorkerDelegate.EnsureEntity(entry.ID, entry);
}
}
else if (partyCount == 0 || partyCount == 1)
{
var entry = PartyEntityHelper.ResolvePartyMemberFromBytes(new byte[0], PCWorkerDelegate.CurrentUser);
if (entry.IsValid)
{
var exists = false;
if (result.RemovedParty.ContainsKey(entry.ID))
{
result.RemovedParty.Remove(entry.ID);
exists = true;
}
else
{
result.NewParty.Add(entry.ID);
}
if (!exists)
{
PartyInfoWorkerDelegate.EnsureEntity(entry.ID, entry);
}
}
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
try
{
// REMOVE OLD PARTY MEMBERS FROM LIVE CURRENT DICTIONARY
foreach (var kvp in result.RemovedParty)
{
PartyInfoWorkerDelegate.RemoveEntity(kvp.Key);
}
}
catch (Exception ex)
{
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
return(result);
}
