private static ActorEntity GetTargetActorEntityFromSource(long address)
{
var source = MemoryHandler.Instance.GetByteArray(new IntPtr(address), MemoryHandler.Instance.Structures.TargetInfo.Size); // old size: 0x3F40
var entry = ActorEntityHelper.ResolveActorFromBytes(source);
EnsureMapAndZone(entry);
return(entry);
}
/// <summary>
/// </summary>
/// <param name="sender"> </param>
/// <param name="e"> </param>
private void ScanTimerElapsed(object sender, ElapsedEventArgs e)
{
if (_isScanning)
{
return;
}
_isScanning = true;
double refresh = 100;
if (Double.TryParse(Settings.Default.TargetWorkerRefresh.ToString(CultureInfo.InvariantCulture), out refresh))
{
_scanTimer.Interval = refresh;
}
Func <bool> scannerWorker = delegate
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("GAMEMAIN"))
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("CHARMAP"))
{
try
{
uint targetHateStructure;
switch (Settings.Default.GameLanguage)
{
case "Chinese":
targetHateStructure = MemoryHandler.Instance.SigScanner.Locations["CHARMAP"] + 1136;
break;
default:
targetHateStructure = MemoryHandler.Instance.SigScanner.Locations["CHARMAP"] - 120664;
break;
}
var enmityEntries = new List <EnmityEntry>();
var targetEntity = new TargetEntity();
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("TARGET"))
{
var targetAddress = MemoryHandler.Instance.SigScanner.Locations["TARGET"];
var somethingFound = false;
if (targetAddress > 0)
{
//var targetInfo = MemoryHandler.Instance.GetStructure<Structures.Target>(targetAddress);
uint currentTarget;
uint mouseOverTarget;
uint focusTarget;
uint previousTarget;
uint currentTargetID;
var targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, 128);
switch (Settings.Default.GameLanguage)
{
case "Chinese":
currentTarget = BitConverter.ToUInt32(targetInfoSource, 0x0);
mouseOverTarget = BitConverter.ToUInt32(targetInfoSource, 0x18);
focusTarget = BitConverter.ToUInt32(targetInfoSource, 0x48);
previousTarget = BitConverter.ToUInt32(targetInfoSource, 0x54);
currentTargetID = BitConverter.ToUInt32(targetInfoSource, 0x68);
break;
default:
currentTarget = BitConverter.ToUInt32(targetInfoSource, 0x0);
mouseOverTarget = BitConverter.ToUInt32(targetInfoSource, 0xC);
focusTarget = BitConverter.ToUInt32(targetInfoSource, 0x3C);
previousTarget = BitConverter.ToUInt32(targetInfoSource, 0x48);
currentTargetID = BitConverter.ToUInt32(targetInfoSource, 0x5C);
break;
}
if (currentTarget > 0)
{
try
{
var source = MemoryHandler.Instance.GetByteArray(currentTarget, 0x3F40);
var entry = ActorEntityHelper.ResolveActorFromBytes(source);
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
entry.MapIndex = MemoryHandler.Instance.GetUInt32(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
if (entry.IsValid)
{
somethingFound = true;
targetEntity.CurrentTarget = entry;
}
}
catch (Exception ex)
{
}
}
if (mouseOverTarget > 0)
{
try
{
var source = MemoryHandler.Instance.GetByteArray(mouseOverTarget, 0x3F40);
var entry = ActorEntityHelper.ResolveActorFromBytes(source);
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
entry.MapIndex = MemoryHandler.Instance.GetUInt32(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
if (entry.IsValid)
{
somethingFound = true;
targetEntity.MouseOverTarget = entry;
}
}
catch (Exception ex)
{
}
}
if (focusTarget > 0)
{
var source = MemoryHandler.Instance.GetByteArray(focusTarget, 0x3F40);
var entry = ActorEntityHelper.ResolveActorFromBytes(source);
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
entry.MapIndex = MemoryHandler.Instance.GetUInt32(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
if (entry.IsValid)
{
somethingFound = true;
targetEntity.FocusTarget = entry;
}
}
if (previousTarget > 0)
{
try
{
var source = MemoryHandler.Instance.GetByteArray(previousTarget, 0x3F40);
var entry = ActorEntityHelper.ResolveActorFromBytes(source);
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
entry.MapIndex = MemoryHandler.Instance.GetUInt32(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
if (entry.IsValid)
{
somethingFound = true;
targetEntity.PreviousTarget = entry;
}
}
catch (Exception ex)
{
}
}
if (currentTargetID > 0)
{
somethingFound = true;
targetEntity.CurrentTargetID = currentTargetID;
}
}
if (targetEntity.CurrentTargetID > 0)
{
for (uint i = 0; i < 16; i++)
{
var address = targetHateStructure + (i * 72);
var enmityEntry = new EnmityEntry
{
ID = (uint)MemoryHandler.Instance.GetInt32(address),
Enmity = (uint)MemoryHandler.Instance.GetInt32(address, 4)
};
if (enmityEntry.ID <= 0)
{
continue;
}
if (PCWorkerDelegate.GetUniqueNPCEntities()
.Any())
{
if (PCWorkerDelegate.GetUniqueNPCEntities()
.Any(a => a.ID == enmityEntry.ID))
{
enmityEntry.Name = PCWorkerDelegate.GetUniqueNPCEntities()
.First(a => a.ID == enmityEntry.ID)
.Name;
}
}
if (String.IsNullOrWhiteSpace(enmityEntry.Name))
{
if (NPCWorkerDelegate.GetUniqueNPCEntities()
.Any())
{
if (NPCWorkerDelegate.GetUniqueNPCEntities()
.Any(a => a.ID == enmityEntry.ID))
{
enmityEntry.Name = NPCWorkerDelegate.GetUniqueNPCEntities()
.First(a => a.NPCID2 == enmityEntry.ID)
.Name;
}
}
}
if (String.IsNullOrWhiteSpace(enmityEntry.Name))
{
if (MonsterWorkerDelegate.GetUniqueNPCEntities()
.Any())
{
if (MonsterWorkerDelegate.GetUniqueNPCEntities()
.Any(a => a.ID == enmityEntry.ID))
{
enmityEntry.Name = MonsterWorkerDelegate.GetUniqueNPCEntities()
.First(a => a.ID == enmityEntry.ID)
.Name;
}
}
}
enmityEntries.Add(enmityEntry);
}
}
targetEntity.EnmityEntries = enmityEntries;
if (somethingFound)
{
AppContextHelper.Instance.RaiseNewTargetEntity(targetEntity);
}
}
}
catch (Exception ex)
{
}
}
}
_isScanning = false;
return(true);
};
scannerWorker.BeginInvoke(delegate { }, scannerWorker);
}
/// <summary>
/// </summary>
/// <param name="sender"> </param>
/// <param name="e"> </param>
private void ScanTimerElapsed(object sender, ElapsedEventArgs e)
{
if (_isScanning)
{
return;
}
_isScanning = true;
double refresh = 100;
if (Double.TryParse(Settings.Default.MonsterWorkerRefresh.ToString(CultureInfo.InvariantCulture), out refresh))
{
_scanTimer.Interval = refresh;
}
Func <bool> scannerWorker = delegate
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("GAMEMAIN"))
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("CHARMAP"))
{
try
{
#region Ensure Target & Map
uint targetAddress = 0;
uint mapIndex = 0;
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("TARGET"))
{
try
{
targetAddress = MemoryHandler.Instance.SigScanner.Locations["TARGET"];
}
catch (Exception ex)
{
}
}
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
mapIndex = MemoryHandler.Instance.GetUInt32(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
#endregion
var characterAddressMap = MemoryHandler.Instance.GetByteArray(MemoryHandler.Instance.SigScanner.Locations["CHARMAP"], 4000);
var sourceData = new List <byte[]>();
for (var i = 0; i <= 1000; i += 4)
{
var characterAddress = BitConverter.ToUInt32(characterAddressMap, i);
if (characterAddress == 0)
{
continue;
}
sourceData.Add(MemoryHandler.Instance.GetByteArray(characterAddress, 0x3F40));
}
#region ActorEntity Handlers
bool firstTime = true;
var monsterEntries = new List <ActorEntity>();
var pcEntries = new List <ActorEntity>();
for (var i = 0; i < sourceData.Count; i++)
{
try
{
var source = sourceData[i];
//var source = MemoryHandler.Instance.GetByteArray(characterAddress, 0x3F40);
var entry = ActorEntityHelper.ResolveActorFromBytes(source, firstTime);
firstTime = false;
//var actor = MemoryHandler.Instance.GetStructureFromBytes<Structures.NPCEntry>(source);
//var actor = MemoryHandler.Instance.GetStructure<Structures.NPCEntry>(characterAddress);
//var name = MemoryHandler.Instance.GetString(characterAddress, 48);
//var entry = ActorEntityHelper.ResolveActorFromMemory(actor, name);
entry.MapIndex = mapIndex;
if (i == 0)
{
if (targetAddress > 0)
{
var targetInfo = MemoryHandler.Instance.GetStructure <Structures.Target>(targetAddress);
entry.TargetID = (int)targetInfo.CurrentTargetID;
}
}
if (!entry.IsValid)
{
continue;
}
switch (entry.Type)
{
case Actor.Type.Monster:
monsterEntries.Add(entry);
break;
case Actor.Type.PC:
pcEntries.Add(entry);
break;
}
}
catch (Exception ex)
{
}
}
if (pcEntries.Any())
{
AppContextHelper.Instance.RaiseNewPCEntries(pcEntries);
}
if (monsterEntries.Any())
{
AppContextHelper.Instance.RaiseNewMonsterEntries(monsterEntries);
}
#endregion
}
catch (Exception ex)
{
}
}
}
_isScanning = false;
return(true);
};
scannerWorker.BeginInvoke(delegate { }, scannerWorker);
}
/// <summary>
/// </summary>
/// <param name="sender"> </param>
/// <param name="e"> </param>
private void ScanTimerElapsed(object sender, ElapsedEventArgs e)
{
if (_isScanning)
{
return;
}
_isScanning = true;
double refresh = 100;
if (Double.TryParse(Settings.Default.ActorWorkerRefresh.ToString(CultureInfo.InvariantCulture), out refresh))
{
_scanTimer.Interval = refresh;
}
Func <bool> scannerWorker = delegate
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("GAMEMAIN"))
{
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("CHARMAP"))
{
try
{
#region Ensure Target & Map
long targetAddress = 0;
uint mapIndex = 0;
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("TARGET"))
{
try
{
targetAddress = MemoryHandler.Instance.SigScanner.Locations["TARGET"];
}
catch (Exception ex)
{
}
}
if (MemoryHandler.Instance.SigScanner.Locations.ContainsKey("MAP"))
{
try
{
mapIndex = (uint)MemoryHandler.Instance.GetPlatformUInt(MemoryHandler.Instance.SigScanner.Locations["MAP"]);
}
catch (Exception ex)
{
}
}
#endregion
var endianSize = MemoryHandler.Instance.ProcessModel.IsWin64 ? 8 : 4;
const int limit = 1372;
var characterAddressMap = MemoryHandler.Instance.GetByteArray(MemoryHandler.Instance.SigScanner.Locations["CHARMAP"], endianSize * limit);
var uniqueAddresses = new Dictionary <IntPtr, IntPtr>();
for (var i = 0; i < limit; i++)
{
IntPtr characterAddress;
if (MemoryHandler.Instance.ProcessModel.IsWin64)
{
characterAddress = new IntPtr(BitConverter.ToInt64(characterAddressMap, i * endianSize));
}
else
{
characterAddress = new IntPtr(BitConverter.ToInt32(characterAddressMap, i * endianSize));
}
if (characterAddress == IntPtr.Zero)
{
continue;
}
uniqueAddresses[characterAddress] = characterAddress;
}
var sourceData = uniqueAddresses.Select(kvp => MemoryHandler.Instance.GetByteArray((long)kvp.Value, 0x3F40))
.ToList();
#region ActorEntity Handlers
var firstTime = true;
var currentMonsterEntries = MonsterWorkerDelegate.NPCEntities.Keys.ToDictionary(key => key);
var currentNPCEntries = NPCWorkerDelegate.NPCEntities.Keys.ToDictionary(key => key);
var currentPCEntries = PCWorkerDelegate.NPCEntities.Keys.ToDictionary(key => key);
var newMonsterEntries = new List <UInt32>();
var newNPCEntries = new List <UInt32>();
var newPCEntries = new List <UInt32>();
for (var i = 0; i < sourceData.Count; i++)
{
try
{
var source = sourceData[i];
//var source = MemoryHandler.Instance.GetByteArray(characterAddress, 0x3F40);
UInt32 ID;
UInt32 NPCID2;
Actor.Type Type;
switch (Settings.Default.GameLanguage)
{
case "Chinese":
ID = BitConverter.ToUInt32(source, 0x74);
NPCID2 = BitConverter.ToUInt32(source, 0x80);
Type = (Actor.Type)source[0x8A];
break;
default:
ID = BitConverter.ToUInt32(source, 0x74);
NPCID2 = BitConverter.ToUInt32(source, 0x80);
Type = (Actor.Type)source[0x8A];
break;
}
ActorEntity existing = null;
switch (Type)
{
case Actor.Type.Monster:
if (currentMonsterEntries.ContainsKey(ID))
{
currentMonsterEntries.Remove(ID);
existing = MonsterWorkerDelegate.GetNPCEntity(ID);
}
else
{
newMonsterEntries.Add(ID);
}
break;
case Actor.Type.PC:
if (currentPCEntries.ContainsKey(ID))
{
currentPCEntries.Remove(ID);
existing = PCWorkerDelegate.GetNPCEntity(ID);
}
else
{
newPCEntries.Add(ID);
}
break;
case Actor.Type.NPC:
if (currentNPCEntries.ContainsKey(NPCID2))
{
currentNPCEntries.Remove(NPCID2);
existing = NPCWorkerDelegate.GetNPCEntity(NPCID2);
}
else
{
newNPCEntries.Add(NPCID2);
}
break;
default:
if (currentNPCEntries.ContainsKey(ID))
{
currentNPCEntries.Remove(ID);
existing = NPCWorkerDelegate.GetNPCEntity(ID);
}
else
{
newNPCEntries.Add(ID);
}
break;
}
var entry = ActorEntityHelper.ResolveActorFromBytes(source, firstTime, existing);
firstTime = false;
//var actor = MemoryHandler.Instance.GetStructureFromBytes<Structures.NPCEntry>(source);
//var actor = MemoryHandler.Instance.GetStructure<Structures.NPCEntry>(characterAddress);
//var name = MemoryHandler.Instance.GetString(characterAddress, 48);
//var entry = ActorEntityHelper.ResolveActorFromMemory(actor, name);
entry.MapIndex = mapIndex;
if (i == 0)
{
var name = Settings.Default.CharacterName;
if (name != entry.Name || String.IsNullOrWhiteSpace(name))
{
Settings.Default.CharacterName = entry.Name;
}
if (targetAddress > 0)
{
uint currentTargetID;
var targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, 128);
switch (Settings.Default.GameLanguage)
{
case "Chinese":
currentTargetID = BitConverter.ToUInt32(targetInfoSource, 0x68);
break;
default:
currentTargetID = BitConverter.ToUInt32(targetInfoSource, 0x68);
break;
}
entry.TargetID = (int)currentTargetID;
}
}
if (!entry.IsValid)
{
newMonsterEntries.Remove(entry.ID);
newMonsterEntries.Remove(entry.NPCID2);
newNPCEntries.Remove(entry.ID);
newNPCEntries.Remove(entry.NPCID2);
newPCEntries.Remove(entry.ID);
newPCEntries.Remove(entry.NPCID2);
continue;
}
if (existing != null)
{
continue;
}
switch (entry.Type)
{
case Actor.Type.Monster:
MonsterWorkerDelegate.EnsureNPCEntity(entry.ID, entry);
break;
case Actor.Type.PC:
PCWorkerDelegate.EnsureNPCEntity(entry.ID, entry);
break;
case Actor.Type.NPC:
NPCWorkerDelegate.EnsureNPCEntity(entry.NPCID2, entry);
break;
default:
NPCWorkerDelegate.EnsureNPCEntity(entry.ID, entry);
break;
}
}
catch (Exception ex)
{
}
}
if (!ReferencesSet)
{
ReferencesSet = true;
AppContextHelper.Instance.RaiseNewMonsterEntries(MonsterWorkerDelegate.NPCEntities);
AppContextHelper.Instance.RaiseNewNPCEntries(NPCWorkerDelegate.NPCEntities);
AppContextHelper.Instance.RaiseNewPCEntries(PCWorkerDelegate.NPCEntities);
}
if (newMonsterEntries.Any())
{
AppContextHelper.Instance.RaiseNewMonsterAddedEntries(newMonsterEntries);
}
if (newNPCEntries.Any())
{
AppContextHelper.Instance.RaiseNewNPCAddedEntries(newNPCEntries);
}
if (newPCEntries.Any())
{
AppContextHelper.Instance.RaiseNewPCAddedEntries(newPCEntries);
}
if (currentMonsterEntries.Any())
{
AppContextHelper.Instance.RaiseNewMonsterRemovedEntries(currentMonsterEntries.Keys.ToList());
foreach (var key in currentMonsterEntries.Keys)
{
MonsterWorkerDelegate.RemoveNPCEntity(key);
}
}
if (currentNPCEntries.Any())
{
AppContextHelper.Instance.RaiseNewNPCRemovedEntries(currentNPCEntries.Keys.ToList());
foreach (var key in currentNPCEntries.Keys)
{
NPCWorkerDelegate.RemoveNPCEntity(key);
}
}
if (currentPCEntries.Any())
{
AppContextHelper.Instance.RaiseNewPCRemovedEntries(currentPCEntries.Keys.ToList());
foreach (var key in currentPCEntries.Keys)
{
PCWorkerDelegate.RemoveNPCEntity(key);
}
}
#endregion
}
catch (Exception ex)
{
}
}
}
_isScanning = false;
return(true);
};
scannerWorker.BeginInvoke(delegate { }, scannerWorker);
}
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);
}
