private ActorItem GetCurrentPlayerEntity()
{
ActorItem result = null;
if (!this.CanGetCurrentUser() || !this._memoryHandler.IsAttached)
{
return(result);
}
IntPtr targetAddress = IntPtr.Zero;
int limit = this._memoryHandler.Structures.ActorItem.EntityCount;
int sourceSize = this._memoryHandler.Structures.ActorItem.SourceSize;
byte[] characterAddressMap = this._memoryHandler.BufferPool.Rent(8);
byte[] sourceMap = this._memoryHandler.BufferPool.Rent(sourceSize);
byte[] targetInfoMap = this._memoryHandler.BufferPool.Rent(128);
try {
this._memoryHandler.GetByteArray(this._memoryHandler.Scanner.Locations[Signatures.CHARMAP_KEY], characterAddressMap);
IntPtr characterAddress = new IntPtr(SharlayanBitConverter.TryToInt64(characterAddressMap, 0));
if (characterAddress != IntPtr.Zero)
{
this._memoryHandler.GetByteArray(characterAddress, sourceMap);
result = this._actorItemResolver.ResolveActorFromBytes(sourceMap, true);
(uint mapID, uint mapIndex, uint mapTerritory) = this.GetMapInfo();
result.MapID = mapID;
result.MapIndex = mapIndex;
result.MapTerritory = mapTerritory;
if (targetAddress.ToInt64() > 0)
{
this._memoryHandler.GetByteArray(targetAddress, targetInfoMap);
result.TargetID = (int)SharlayanBitConverter.TryToUInt32(targetInfoMap, this._memoryHandler.Structures.ActorItem.ID);
}
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
finally {
this._memoryHandler.BufferPool.Return(characterAddressMap);
this._memoryHandler.BufferPool.Return(sourceMap);
this._memoryHandler.BufferPool.Return(targetInfoMap);
}
return(result);
}
public TargetResult GetTargetInfo()
{
TargetResult result = new TargetResult();
if (!this.CanGetTargetInfo() || !this._memoryHandler.IsAttached)
{
return(result);
}
byte[] targetInfoMap = this._memoryHandler.BufferPool.Rent(this._memoryHandler.Structures.TargetInfo.SourceSize);
try {
IntPtr targetAddress = (IntPtr)this._memoryHandler.Scanner.Locations[Signatures.TARGET_KEY];
if (targetAddress.ToInt64() > 0)
{
this._memoryHandler.GetByteArray(targetAddress, targetInfoMap);
long currentTargetAddress = this._memoryHandler.GetInt64FromBytes(targetInfoMap, this._memoryHandler.Structures.TargetInfo.Current);
long mouseOverTargetAddress = this._memoryHandler.GetInt64FromBytes(targetInfoMap, this._memoryHandler.Structures.TargetInfo.MouseOver);
long focusTargetAddress = this._memoryHandler.GetInt64FromBytes(targetInfoMap, this._memoryHandler.Structures.TargetInfo.Focus);
long previousTargetAddress = this._memoryHandler.GetInt64FromBytes(targetInfoMap, this._memoryHandler.Structures.TargetInfo.Previous);
uint currentTargetID = SharlayanBitConverter.TryToUInt32(targetInfoMap, this._memoryHandler.Structures.TargetInfo.CurrentID);
if (currentTargetAddress > 0)
{
try {
ActorItem entry = this.GetTargetActorItemFromSource(currentTargetAddress);
currentTargetID = entry.ID;
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetInfo.CurrentTarget = entry;
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
if (mouseOverTargetAddress > 0)
{
try {
ActorItem entry = this.GetTargetActorItemFromSource(mouseOverTargetAddress);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetInfo.MouseOverTarget = entry;
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
if (focusTargetAddress > 0)
{
try {
ActorItem entry = this.GetTargetActorItemFromSource(focusTargetAddress);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetInfo.FocusTarget = entry;
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
if (previousTargetAddress > 0)
{
try {
ActorItem entry = this.GetTargetActorItemFromSource(previousTargetAddress);
if (entry.IsValid)
{
result.TargetsFound = true;
result.TargetInfo.PreviousTarget = entry;
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
if (currentTargetID > 0)
{
result.TargetsFound = true;
result.TargetInfo.CurrentTargetID = currentTargetID;
}
}
if (result.TargetInfo.CurrentTargetID > 0)
{
try {
if (this.CanGetEnmityEntities())
{
short enmityCount = this._memoryHandler.GetInt16(this._memoryHandler.Scanner.Locations[Signatures.ENMITY_COUNT_KEY]);
IntPtr enmityStructure = (IntPtr)this._memoryHandler.Scanner.Locations[Signatures.ENMITYMAP_KEY];
if (enmityCount > 0 && enmityCount < 16 && enmityStructure.ToInt64() > 0)
{
int enmitySourceSize = this._memoryHandler.Structures.EnmityItem.SourceSize;
for (uint i = 0; i < enmityCount; i++)
{
try {
IntPtr address = new IntPtr(enmityStructure.ToInt64() + i * enmitySourceSize);
EnmityItem enmityEntry = new EnmityItem {
ID = this._memoryHandler.GetUInt32(address, this._memoryHandler.Structures.EnmityItem.ID),
// Name = this._memoryHandler.GetString(address + this._memoryHandler.Structures.EnmityItem.Name),
Enmity = this._memoryHandler.GetUInt32(address + this._memoryHandler.Structures.EnmityItem.Enmity),
};
if (enmityEntry.ID <= 0)
{
continue;
}
if (string.IsNullOrWhiteSpace(enmityEntry.Name))
{
ActorItem pc = this._pcWorkerDelegate.GetActorItem(enmityEntry.ID);
ActorItem npc = this._npcWorkerDelegate.GetActorItem(enmityEntry.ID);
ActorItem monster = this._monsterWorkerDelegate.GetActorItem(enmityEntry.ID);
try {
enmityEntry.Name = (pc ?? npc).Name ?? monster.Name;
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
result.TargetInfo.EnmityItems.Add(enmityEntry);
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
}
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
finally {
this._memoryHandler.BufferPool.Return(targetInfoMap);
}
return(result);
}
public PartyResult GetPartyMembers()
{
PartyResult result = new PartyResult();
if (!this.CanGetPartyMembers() || !this._memoryHandler.IsAttached)
{
return(result);
}
IntPtr partInfoAddress = (IntPtr)this._memoryHandler.Scanner.Locations[Signatures.PARTYMAP_KEY];
IntPtr partyCountyAddress = this._memoryHandler.Scanner.Locations[Signatures.PARTYCOUNT_KEY];
foreach (KeyValuePair <uint, PartyMember> kvp in this._partyWorkerDelegate.PartyMembers)
{
result.RemovedPartyMembers.TryAdd(kvp.Key, kvp.Value.Clone());
}
try {
byte partyCount = this._memoryHandler.GetByte(partyCountyAddress);
int sourceSize = this._memoryHandler.Structures.PartyMember.SourceSize;
byte[] partyMemberMap = this._memoryHandler.BufferPool.Rent(sourceSize);
try {
if (partyCount > 1 && partyCount < 9)
{
for (uint i = 0; i < partyCount; i++)
{
long address = partInfoAddress.ToInt64() + i * (uint)sourceSize;
this._memoryHandler.GetByteArray(new IntPtr(address), partyMemberMap);
uint ID = SharlayanBitConverter.TryToUInt32(partyMemberMap, this._memoryHandler.Structures.PartyMember.ID);
ActorItem existing = null;
bool newEntry = false;
if (result.RemovedPartyMembers.ContainsKey(ID))
{
result.RemovedPartyMembers.TryRemove(ID, out PartyMember removedPartyMember);
if (this._monsterWorkerDelegate.ActorItems.ContainsKey(ID))
{
existing = this._monsterWorkerDelegate.GetActorItem(ID);
}
if (this._pcWorkerDelegate.ActorItems.ContainsKey(ID))
{
existing = this._pcWorkerDelegate.GetActorItem(ID);
}
}
else
{
newEntry = true;
}
PartyMember entry = this._partyMemberResolver.ResolvePartyMemberFromBytes(partyMemberMap, existing);
if (!entry.IsValid)
{
continue;
}
if (existing != null)
{
continue;
}
if (newEntry)
{
this._partyWorkerDelegate.EnsurePartyMember(entry.ID, entry);
result.NewPartyMembers.TryAdd(entry.ID, entry.Clone());
}
}
}
if (partyCount <= 1 && this._pcWorkerDelegate.CurrentUser != null)
{
PartyMember entry = this._partyMemberResolver.ResolvePartyMemberFromBytes(Array.Empty <byte>(), this._pcWorkerDelegate.CurrentUser);
if (result.RemovedPartyMembers.ContainsKey(entry.ID))
{
result.RemovedPartyMembers.TryRemove(entry.ID, out PartyMember removedPartyMember);
}
this._partyWorkerDelegate.EnsurePartyMember(entry.ID, entry);
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
finally {
this._memoryHandler.BufferPool.Return(partyMemberMap);
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
try {
// REMOVE OLD PARTY MEMBERS FROM LIVE CURRENT DICTIONARY
foreach (KeyValuePair <uint, PartyMember> kvp in result.RemovedPartyMembers)
{
this._partyWorkerDelegate.RemovePartyMember(kvp.Key);
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
result.PartyMembers = this._partyWorkerDelegate.PartyMembers;
return(result);
}
public IntPtr ReadPointer(IntPtr address, long offset = 0)
{
byte[] win64 = new byte[8];
this.Peek(new IntPtr(address.ToInt64() + offset), win64);
return(new IntPtr(SharlayanBitConverter.TryToInt64(win64, 0)));
}
public ulong GetUInt64FromBytes(byte[] source, int index = 0)
{
return(SharlayanBitConverter.TryToUInt64(source, index));
}
public ulong GetUInt64(IntPtr address, long offset = 0)
{
byte[] value = new byte[8];
this.Peek(new IntPtr(address.ToInt64() + offset), value);
return(SharlayanBitConverter.TryToUInt32(value, 0));
}
public short GetInt16(IntPtr address, long offset = 0)
{
byte[] value = new byte[2];
this.Peek(new IntPtr(address.ToInt64() + offset), value);
return(SharlayanBitConverter.TryToInt16(value, 0));
}
public ActorResult GetActors()
{
ActorResult result = new ActorResult();
if (!this.CanGetActors() || !this._memoryHandler.IsAttached)
{
return(result);
}
IntPtr targetAddress = IntPtr.Zero;
int limit = this._memoryHandler.Structures.ActorItem.EntityCount;
int sourceSize = this._memoryHandler.Structures.ActorItem.SourceSize;
byte[] characterAddressMap = this._memoryHandler.BufferPool.Rent(8 * limit);
byte[] sourceMap = this._memoryHandler.BufferPool.Rent(sourceSize);
byte[] targetInfoMap = this._memoryHandler.BufferPool.Rent(128);
try {
this._memoryHandler.GetByteArray(this._memoryHandler.Scanner.Locations[Signatures.CHARMAP_KEY], characterAddressMap);
IntPtr firstAddress = IntPtr.Zero;
DateTime now = DateTime.Now;
TimeSpan staleActorRemovalTime = TimeSpan.FromSeconds(0.25);
bool firstTime = true;
for (int i = 0; i < limit; i++)
{
IntPtr characterAddress = new IntPtr(SharlayanBitConverter.TryToInt64(characterAddressMap, i * 8));
if (characterAddress == IntPtr.Zero)
{
continue;
}
if (firstTime)
{
firstAddress = characterAddress;
firstTime = false;
}
this._uniqueCharacterAddresses[characterAddress] = characterAddress;
}
foreach (KeyValuePair <uint, ActorItem> kvp in this._monsterWorkerDelegate.ActorItems)
{
result.RemovedMonsters.TryAdd(kvp.Key, kvp.Value.Clone());
}
foreach (KeyValuePair <uint, ActorItem> kvp in this._npcWorkerDelegate.ActorItems)
{
result.RemovedNPCs.TryAdd(kvp.Key, kvp.Value.Clone());
}
foreach (KeyValuePair <uint, ActorItem> kvp in this._pcWorkerDelegate.ActorItems)
{
result.RemovedPCs.TryAdd(kvp.Key, kvp.Value.Clone());
}
(uint mapID, uint mapIndex, uint mapTerritory) = this.GetMapInfo();
foreach (KeyValuePair <IntPtr, IntPtr> kvp in this._uniqueCharacterAddresses)
{
try {
IntPtr characterAddress = new IntPtr(kvp.Value.ToInt64());
this._memoryHandler.GetByteArray(characterAddress, sourceMap);
uint ID = SharlayanBitConverter.TryToUInt32(sourceMap, this._memoryHandler.Structures.ActorItem.ID);
uint NPCID2 = SharlayanBitConverter.TryToUInt32(sourceMap, this._memoryHandler.Structures.ActorItem.NPCID2);
Actor.Type Type = (Actor.Type)sourceMap[this._memoryHandler.Structures.ActorItem.Type];
ActorItem existing = null;
bool newEntry = false;
switch (Type)
{
case Actor.Type.Monster:
if (result.RemovedMonsters.ContainsKey(ID))
{
result.RemovedMonsters.TryRemove(ID, out ActorItem removedMonster);
existing = this._monsterWorkerDelegate.GetActorItem(ID);
}
else
{
newEntry = true;
}
break;
case Actor.Type.PC:
if (result.RemovedPCs.ContainsKey(ID))
{
result.RemovedPCs.TryRemove(ID, out ActorItem removedPC);
existing = this._pcWorkerDelegate.GetActorItem(ID);
}
else
{
newEntry = true;
}
break;
case Actor.Type.NPC:
case Actor.Type.Aetheryte:
case Actor.Type.EventObject:
if (result.RemovedNPCs.ContainsKey(NPCID2))
{
result.RemovedNPCs.TryRemove(NPCID2, out ActorItem removedNPC);
existing = this._npcWorkerDelegate.GetActorItem(NPCID2);
}
else
{
newEntry = true;
}
break;
default:
if (result.RemovedNPCs.ContainsKey(ID))
{
result.RemovedNPCs.TryRemove(ID, out ActorItem removedNPC);
existing = this._npcWorkerDelegate.GetActorItem(ID);
}
else
{
newEntry = true;
}
break;
}
bool isFirstEntry = kvp.Value.ToInt64() == firstAddress.ToInt64();
ActorItem entry = this._actorItemResolver.ResolveActorFromBytes(sourceMap, isFirstEntry, existing);
if (entry != null && entry.IsValid)
{
if (this._expiringActors.ContainsKey(ID))
{
this._expiringActors.TryRemove(ID, out DateTime removedDateTime);
}
}
if (entry.Type == Actor.Type.EventObject)
{
(ushort EventObjectTypeID, Actor.EventObjectType EventObjectType) = this.GetEventObjectType(targetAddress);
entry.EventObjectTypeID = EventObjectTypeID;
entry.EventObjectType = EventObjectType;
}
entry.MapID = mapID;
entry.MapIndex = mapIndex;
entry.MapTerritory = mapTerritory;
if (isFirstEntry)
{
if (targetAddress.ToInt64() > 0)
{
this._memoryHandler.GetByteArray(targetAddress, targetInfoMap);
entry.TargetID = (int)SharlayanBitConverter.TryToUInt32(targetInfoMap, this._memoryHandler.Structures.ActorItem.ID);
}
}
if (!entry.IsValid)
{
result.NewMonsters.TryRemove(entry.ID, out ActorItem _);
result.NewMonsters.TryRemove(entry.NPCID2, out ActorItem _);
result.NewNPCs.TryRemove(entry.ID, out ActorItem _);
result.NewNPCs.TryRemove(entry.NPCID2, out ActorItem _);
result.NewPCs.TryRemove(entry.ID, out ActorItem _);
result.NewPCs.TryRemove(entry.NPCID2, out ActorItem _);
continue;
}
if (existing != null)
{
continue;
}
if (newEntry)
{
switch (entry.Type)
{
case Actor.Type.Monster:
this._monsterWorkerDelegate.EnsureActorItem(entry.ID, entry);
result.NewMonsters.TryAdd(entry.ID, entry.Clone());
break;
case Actor.Type.PC:
this._pcWorkerDelegate.EnsureActorItem(entry.ID, entry);
result.NewPCs.TryAdd(entry.ID, entry.Clone());
break;
case Actor.Type.Aetheryte:
case Actor.Type.EventObject:
case Actor.Type.NPC:
this._npcWorkerDelegate.EnsureActorItem(entry.NPCID2, entry);
result.NewNPCs.TryAdd(entry.NPCID2, entry.Clone());
break;
default:
this._npcWorkerDelegate.EnsureActorItem(entry.ID, entry);
result.NewNPCs.TryAdd(entry.ID, entry.Clone());
break;
}
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
}
try {
// add the "removed" actors to the expiring list
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedMonsters)
{
if (!this._expiringActors.ContainsKey(kvp.Key))
{
this._expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedNPCs)
{
if (!this._expiringActors.ContainsKey(kvp.Key))
{
this._expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedPCs)
{
if (!this._expiringActors.ContainsKey(kvp.Key))
{
this._expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
// check expiring list for stale actors
foreach (KeyValuePair <uint, DateTime> kvp in this._expiringActors)
{
if (now > kvp.Value)
{
// Stale actor. Remove it.
this._monsterWorkerDelegate.RemoveActorItem(kvp.Key);
this._npcWorkerDelegate.RemoveActorItem(kvp.Key);
this._pcWorkerDelegate.RemoveActorItem(kvp.Key);
this._expiringActors.TryRemove(kvp.Key, out DateTime removedDateTime);
}
else
{
// Not stale enough yet. We're not actually removing it.
result.RemovedMonsters.TryRemove(kvp.Key, out ActorItem _);
result.RemovedNPCs.TryRemove(kvp.Key, out ActorItem _);
result.RemovedPCs.TryRemove(kvp.Key, out ActorItem _);
}
}
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
this._memoryHandler.ScanCount++;
}
catch (Exception ex) {
this._memoryHandler.RaiseException(Logger, ex);
}
finally {
this._memoryHandler.BufferPool.Return(characterAddressMap);
this._memoryHandler.BufferPool.Return(sourceMap);
this._memoryHandler.BufferPool.Return(targetInfoMap);
}
result.CurrentMonsters = this._monsterWorkerDelegate.ActorItems;
result.CurrentNPCs = this._npcWorkerDelegate.ActorItems;
result.CurrentPCs = this._pcWorkerDelegate.ActorItems;
this._uniqueCharacterAddresses.Clear();
return(result);
}
