public new void Update()
{
string filterName = ActorFilter.Text;
ActorList.BeginUpdate();
ActorList.DataSource = null;
List <ActorMenuItem> menuItems = new List <ActorMenuItem>();
if (Reader.CanGetActors())
{
ActorResult res = Reader.GetActors();
foreach (ActorItem item in res.CurrentPCs.Values)
{
if (!ExcludeActors.Contains(item.ID))
{
if (!string.IsNullOrEmpty(filterName))
{
if (!item.Name.ToLower().Contains(filterName.ToLower()))
{
continue;
}
}
menuItems.Add(new ActorMenuItem {
name = item.Name,
id = (int)item.ID,
});
}
}
}
ActorList.DataSource = menuItems;
ActorList.EndUpdate();
ActorList.Refresh();
}
private void SyncWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
SyncData data = (e.Result as SyncData);
StringBuilder debugDump = new StringBuilder();
if (Sharlayan.MemoryHandler.Instance.IsAttached)
{
if (Sharlayan.Reader.CanGetActors())
{
ActorResult actors = Sharlayan.Reader.GetActors();
foreach (KeyValuePair <uint, long> kvp in data.idTimestamp)
{
if (actors.CurrentPCs.ContainsKey(kvp.Key))
{
ActorItem item = actors.CurrentPCs[kvp.Key];
debugDump.AppendLine(string.Format("{0} MS {1}", item.Name, kvp.Value));
}
}
}
}
onMemoryCheck.Invoke(this, false);
//MessageBox.Show(this.Parent, debugDump.ToString());
Console.WriteLine(debugDump.ToString());
}
static void Main(string[] args)
{
FFProcess process = new FFProcess(FFProcess.DX11_DEFAULT_NAME, true);
DiscordPresence presence = new DiscordPresence(DISCORD_CLIENT_ID);
bool shutdown = false;
new Thread(x => {
while (!shutdown)
{
if (Console.ReadKey(true).Key == ConsoleKey.Escape)
{
shutdown = true;
Console.WriteLine("Stopping application...");
}
}
}).Start();
Console.WriteLine("Press ESC to stop");
do
{
while (Scanner.Instance.IsScanning)
{
Thread.Sleep(1000);
Console.WriteLine("Scanning...");
}
CurrentPlayer currentPlayer = Reader.GetCurrentPlayer().CurrentPlayer;
ActorItem player = null /*ActorItem.CurrentUser*/;
if (player == null)
{
ActorResult aResult = Reader.GetActors();
KeyValuePair <uint, ActorItem> playerKeyValue = aResult.CurrentPCs.ToList().Find(x => x.Value.Name == currentPlayer.Name);
ActorItem playerItem = playerKeyValue.Value;
player = playerItem;
}
if (player != null)
{
presence.playerName = player.Name;
presence.lvl = player.Level.ToString();
presence.job = player.Job.ToString();
uint mapID = player.MapTerritory;
MapItem zone = ZoneLookup.GetZoneInfo(mapID);
presence.place = zone.Name.English;
presence.UpdatePresence();
}
Thread.Sleep(5000);
} while (!shutdown);
presence.Deinitialize();
}
public void Update(Dictionary <uint, ActorItemBase> actors = null)
{
if (actors == null)
{
if (Reader.CanGetActors())
{
ActorResult res = Reader.GetActors();
actors = res.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase);
}
}
}
public List <ActorItem> GetActorItems(List <uint> keys)
{
if (Reader.CanGetActors())
{
ActorResult res = Reader.GetActors();
if (res != null && res.CurrentPCs.Count > 0)
{
List <ActorItem> actors = res.CurrentPCs.Where(t => keys.Contains(t.Key)).Select(t => t.Value).ToList();
return(actors);
}
}
return(new List <ActorItem>());
}
private async Task<IActorResult> Handler(IMessage message)
{
var request = message.GetPayload<RequestWeatherHighlightsMessage>();
var totalCount = request.Cities.Count();
var response = new ActorResult(request
.Cities
.Select(city => Message.Create(new RequestCityWeatherMessage
{
CityName = city,
TotalCityCount = totalCount
})).ToArray());
return response;
}
private void ScanTimerElapsed(object sender, ElapsedEventArgs e)
{
if (this._isScanning)
{
return;
}
// this._scanTimer.Interval = Settings.Default.ActorWorkerTiming;
this._isScanning = true;
ActorResult result = this._memoryHandler.Reader.GetActors();
EventHost.Instance.RaiseNewMonsterActorItemsEvent(this._memoryHandler, result.CurrentMonsters);
EventHost.Instance.RaiseNewNPCActorItemsEvent(this._memoryHandler, result.CurrentNPCs);
EventHost.Instance.RaiseNewPCActorItemsEvent(this._memoryHandler, result.CurrentPCs);
if (result.NewMonsters.Any())
{
EventHost.Instance.RaiseMonsterActorItemsAddedEvent(this._memoryHandler, result.NewMonsters);
}
if (result.NewNPCs.Any())
{
EventHost.Instance.RaiseNPCActorItemsAddedEvent(this._memoryHandler, result.NewNPCs);
}
if (result.NewPCs.Any())
{
EventHost.Instance.RaisePCActorItemsAddedEvent(this._memoryHandler, result.NewPCs);
}
if (result.RemovedMonsters.Any())
{
EventHost.Instance.RaiseMonsterActorItemsRemovedEvent(this._memoryHandler, result.RemovedMonsters);
}
if (result.RemovedNPCs.Any())
{
EventHost.Instance.RaiseNPCActorItemsRemovedEvent(this._memoryHandler, result.RemovedNPCs);
}
if (result.RemovedPCs.Any())
{
EventHost.Instance.RaisePCActorItemsRemovedEvent(this._memoryHandler, result.RemovedPCs);
}
this._isScanning = false;
}
private void Reset()
{
hasScanned = false;
isLoggedIn = false;
logItems.Clear();
completeLog.Clear();
_previousArrayIndex = 0;
_previousOffset = 0;
currentPlayer = new CurrentPlayerResult();
party = new PartyResult();
actors = new ActorResult();
performance = new PerformanceResult();
}
public void UpdateMemory()
{
if (Sharlayan.MemoryHandler.Instance.IsAttached)
{
if (Sharlayan.Reader.CanGetActors() && Sharlayan.Reader.CanGetPerformance())
{
List <string> performerNames = GetPerformerNames();
int pid = -1;
PerformanceResult perfs = Sharlayan.Reader.GetPerformance();
ActorResult ares = Sharlayan.Reader.GetActors();
if (ares != null)
{
foreach (ActorItem actor in ares.CurrentPCs.Values.ToList())
{
if (performerNames.Contains(actor.Name))
{
uint perfId = actor.PerformanceID / 2;
if (perfId >= 0 && perfId < 99 && perfs.Performances.ContainsKey(perfId))
{
PerformanceItem item = perfs.Performances[perfId];
BmpLocalPerformer perf = this.FindPerformer(actor.Name);
if (perf != null)
{
perf.PerformanceUp = item.IsReady();
perf.performanceId = perfId;
perf.actorId = actor.ID;
}
}
}
}
}
}
}
}
public static async Task <ActorResult> GetActors()
{
var result = new ActorResult();
if (!CanGetActors() || !MemoryHandler.Instance.IsAttached)
{
return(result);
}
try {
IntPtr targetAddress = IntPtr.Zero;
var endianSize = MemoryHandler.Instance.ProcessModel.IsWin64
? 8
: 4;
var sourceSize = MemoryHandler.Instance.Structures.ActorItem.SourceSize;
var limit = MemoryHandler.Instance.Structures.ActorItem.EntityCount;
byte[] characterAddressMap = MemoryHandler.Instance.GetByteArray(Scanner.Instance.Locations[Signatures.CharacterMapKey], endianSize * limit);
Dictionary <IntPtr, IntPtr> uniqueAddresses = new Dictionary <IntPtr, IntPtr>();
IntPtr firstAddress = IntPtr.Zero;
DateTime now = DateTime.Now;
TimeSpan staleActorRemovalTime = TimeSpan.FromSeconds(0.25);
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;
}
foreach (KeyValuePair <uint, ActorItem> kvp in MonsterWorkerDelegate.ActorItems)
{
result.RemovedMonsters.TryAdd(kvp.Key, kvp.Value.Clone());
}
foreach (KeyValuePair <uint, ActorItem> kvp in NPCWorkerDelegate.ActorItems)
{
result.RemovedNPCs.TryAdd(kvp.Key, kvp.Value.Clone());
}
foreach (KeyValuePair <uint, ActorItem> kvp in PCWorkerDelegate.ActorItems)
{
result.RemovedPCs.TryAdd(kvp.Key, kvp.Value.Clone());
}
foreach (KeyValuePair <IntPtr, IntPtr> kvp in uniqueAddresses)
{
try {
var characterAddress = new IntPtr(kvp.Value.ToInt64());
byte[] source = MemoryHandler.Instance.GetByteArray(characterAddress, sourceSize);
// var source = MemoryHandler.Instance.GetByteArray(characterAddress, 0x3F40);
var ID = BitConverter.TryToUInt32(source, MemoryHandler.Instance.Structures.ActorItem.ID);
var NPCID2 = BitConverter.TryToUInt32(source, MemoryHandler.Instance.Structures.ActorItem.NPCID2);
var Type = (Actor.Type)source[MemoryHandler.Instance.Structures.ActorItem.Type];
ActorItem existing = null;
var newEntry = false;
switch (Type)
{
case Actor.Type.Monster:
if (result.RemovedMonsters.ContainsKey(ID))
{
result.RemovedMonsters.TryRemove(ID, out ActorItem removedMonster);
existing = MonsterWorkerDelegate.GetActorItem(ID);
}
else
{
newEntry = true;
}
break;
case Actor.Type.PC:
if (result.RemovedPCs.ContainsKey(ID))
{
result.RemovedPCs.TryRemove(ID, out ActorItem removedPC);
existing = 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 = NPCWorkerDelegate.GetActorItem(NPCID2);
}
else
{
newEntry = true;
}
break;
default:
if (result.RemovedNPCs.ContainsKey(ID))
{
result.RemovedNPCs.TryRemove(ID, out ActorItem removedNPC);
existing = NPCWorkerDelegate.GetActorItem(ID);
}
else
{
newEntry = true;
}
break;
}
var isFirstEntry = kvp.Value.ToInt64() == firstAddress.ToInt64();
ActorItem entry = await ActorItemResolver.ResolveActorFromBytes(source, isFirstEntry, existing);
if (entry != null && entry.IsValid)
{
if (expiringActors.ContainsKey(ID))
{
expiringActors.Remove(ID);
}
}
if (entry.Type == Actor.Type.EventObject)
{
var(EventObjectTypeID, EventObjectType) = GetEventObjectType(targetAddress);
entry.EventObjectTypeID = EventObjectTypeID;
entry.EventObjectType = EventObjectType;
}
EnsureMapAndZone(entry);
if (isFirstEntry)
{
if (targetAddress.ToInt64() > 0)
{
byte[] targetInfoSource = MemoryHandler.Instance.GetByteArray(targetAddress, 128);
entry.TargetID = (int)BitConverter.TryToUInt32(targetInfoSource, MemoryHandler.Instance.Structures.ActorItem.ID);
}
}
// it doesn't matter what this is set to; it won't be used in code below
ActorItem removed;
if (!entry.IsValid)
{
result.NewMonsters.TryRemove(entry.ID, out removed);
result.NewMonsters.TryRemove(entry.NPCID2, out removed);
result.NewNPCs.TryRemove(entry.ID, out removed);
result.NewNPCs.TryRemove(entry.NPCID2, out removed);
result.NewPCs.TryRemove(entry.ID, out removed);
result.NewPCs.TryRemove(entry.NPCID2, out removed);
continue;
}
if (existing != null)
{
continue;
}
if (newEntry)
{
switch (entry.Type)
{
case Actor.Type.Monster:
MonsterWorkerDelegate.EnsureActorItem(entry.ID, entry);
result.NewMonsters.TryAdd(entry.ID, entry.Clone());
break;
case Actor.Type.PC:
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:
NPCWorkerDelegate.EnsureActorItem(entry.NPCID2, entry);
result.NewNPCs.TryAdd(entry.NPCID2, entry.Clone());
break;
default:
NPCWorkerDelegate.EnsureActorItem(entry.ID, entry);
result.NewNPCs.TryAdd(entry.ID, entry.Clone());
break;
}
}
}
catch (Exception ex) {
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
}
try {
// add the "removed" actors to the expiring list
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedMonsters)
{
if (!expiringActors.ContainsKey(kvp.Key))
{
expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedNPCs)
{
if (!expiringActors.ContainsKey(kvp.Key))
{
expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
foreach (KeyValuePair <uint, ActorItem> kvp in result.RemovedPCs)
{
if (!expiringActors.ContainsKey(kvp.Key))
{
expiringActors[kvp.Key] = now + staleActorRemovalTime;
}
}
// check expiring list for stale actors
foreach (var kvp in expiringActors.ToList())
{
if (now > kvp.Value)
{
// Stale actor. Remove it.
MonsterWorkerDelegate.RemoveActorItem(kvp.Key);
NPCWorkerDelegate.RemoveActorItem(kvp.Key);
PCWorkerDelegate.RemoveActorItem(kvp.Key);
expiringActors.Remove(kvp.Key);
}
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) {
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
MemoryHandler.Instance.ScanCount++;
}
catch (Exception ex) {
MemoryHandler.Instance.RaiseException(Logger, ex, true);
}
return(result);
}
/// <summary>
/// </summary>
/// <param name="sender"> </param>
/// <param name="e"> </param>
private void ScanTimerElapsed(object sender, ElapsedEventArgs e)
{
if (this._isScanning)
{
return;
}
this._isScanning = true;
double refresh = 100;
if (double.TryParse(Settings.Default.ActorWorkerRefresh.ToString(CultureInfo.InvariantCulture), out refresh))
{
this._scanTimer.Interval = refresh;
}
Func <bool> scanner = delegate {
ActorResult readResult = Reader.GetActors();
if (!this.MonsterReferencesSet && readResult.CurrentMonsters.Any())
{
this.MonsterReferencesSet = true;
AppContextHelper.Instance.RaiseMonsterItemsUpdated(readResult.CurrentMonsters);
}
if (!this.NPCReferencesSet && readResult.CurrentNPCs.Any())
{
this.NPCReferencesSet = true;
AppContextHelper.Instance.RaiseNPCItemsUpdated(readResult.CurrentNPCs);
}
if (!this.PCReferencesSet && readResult.CurrentPCs.Any())
{
this.PCReferencesSet = true;
AppContextHelper.Instance.RaisePCItemsUpdated(readResult.CurrentPCs);
}
if (this.MonsterReferencesSet && this.NPCReferencesSet && this.PCReferencesSet)
{
this.ReferencesSet = true;
}
if (readResult.NewMonsters.Any())
{
AppContextHelper.Instance.RaiseMonsterItemsAdded(readResult.NewMonsters);
}
if (readResult.NewNPCs.Any())
{
AppContextHelper.Instance.RaiseNPCItemsAdded(readResult.NewNPCs);
}
if (readResult.NewPCs.Any())
{
AppContextHelper.Instance.RaisePCItemsAdded(readResult.NewPCs);
}
if (readResult.RemovedMonsters.Any())
{
AppContextHelper.Instance.RaiseMonsterItemsRemoved(readResult.RemovedMonsters);
}
if (readResult.RemovedNPCs.Any())
{
AppContextHelper.Instance.RaiseNPCItemsRemoved(readResult.RemovedNPCs);
}
if (readResult.RemovedPCs.Any())
{
AppContextHelper.Instance.RaisePCItemsRemoved(readResult.RemovedPCs);
}
this._isScanning = false;
return(true);
};
scanner.BeginInvoke(delegate { }, scanner);
}
public bool Refresh()
{
if (ffxivProcess != null)
{
ffxivProcess.Refresh();
if (ffxivProcess.HasExited)
{
OnProcessLost?.Invoke(this, EventArgs.Empty);
ffxivProcess = null;
hasLost = true;
Reset();
Console.WriteLine("Exited game");
}
if (IsScanning() && !hasScanned)
{
Console.WriteLine("Scanning...");
while (IsScanning())
{
Thread.Sleep(100);
}
Console.WriteLine("Finished scanning");
OnProcessReady?.Invoke(this, ffxivProcess);
hasScanned = true;
}
}
if ((ffxivProcess == null) && hasLost)
{
OnProcessSeek?.Invoke(this, EventArgs.Empty);
hasLost = false;
return(false);
}
if (Reader.CanGetCharacterId())
{
string id = Reader.GetCharacterId();
if (!string.IsNullOrEmpty(id))
{
if (string.IsNullOrEmpty(CharacterID) ||
(!string.IsNullOrEmpty(CharacterID) && !CharacterID.Equals(id)))
{
CharacterID = id;
}
}
}
if (Reader.CanGetPlayerInfo())
{
CurrentPlayerResult res = Reader.GetCurrentPlayer();
if (res.CurrentPlayer.Job != currentPlayer.CurrentPlayer.Job)
{
if (currentPlayer.CurrentPlayer.Job == Sharlayan.Core.Enums.Actor.Job.Unknown)
{
// Logged in
OnCurrentPlayerLogin?.Invoke(this, res);
isLoggedIn = true;
}
else if (res.CurrentPlayer.Job == Sharlayan.Core.Enums.Actor.Job.Unknown)
{
// Logged out
OnCurrentPlayerLogout?.Invoke(this, currentPlayer);
isLoggedIn = false;
Reset();
}
else
{
OnCurrentPlayerJobChange?.Invoke(this, currentPlayer);
}
}
currentPlayer = res;
}
if (!isLoggedIn)
{
return(false);
}
if (Reader.CanGetPartyMembers())
{
PartyResult party2 = Reader.GetPartyMembers();
if (party2.NewPartyMembers.Count > 0 ||
party2.RemovedPartyMembers.Count > 0)
{
// Something changed
party = party2;
OnPartyChanged?.Invoke(this, party2);
}
int pcount = party.PartyMembers.Count;
int pcount2 = party2.PartyMembers.Count;
if (!(party is PartyResult) || (party is PartyResult && (pcount != pcount2)))
{
party = party2;
OnPartyChanged?.Invoke(this, party2);
}
}
if (Reader.CanGetPerformance())
{
List <uint> changedIds = new List <uint>();
PerformanceResult perf = Reader.GetPerformance();
if (!perf.Performances.IsEmpty && !performance.Performances.IsEmpty)
{
foreach (KeyValuePair <uint, PerformanceItem> pp in perf.Performances)
{
if (pp.Value.Status != performance.Performances[pp.Key].Status)
{
changedIds.Add(pp.Key);
}
}
}
if (changedIds.Count > 0)
{
List <uint> actorIds = new List <uint>();
if (Reader.CanGetActors())
{
foreach (ActorItem actor in Reader.GetActors().CurrentPCs.Values)
{
if (changedIds.Contains(actor.PerformanceID / 2))
{
actorIds.Add(actor.ID);
}
}
}
if (actorIds.Count > 0)
{
OnPerformanceChanged?.Invoke(this, actorIds);
}
}
//Update
performance = perf;
bool r = perf.Performances[0].IsReady();
if (r != performanceReady)
{
performanceReady = r;
OnPerformanceReadyChanged?.Invoke(this, performanceReady);
}
}
logItems.Clear();
if (Reader.CanGetChatLog())
{
ChatLogResult readResult = Reader.GetChatLog(_previousArrayIndex, _previousOffset);
_previousArrayIndex = readResult.PreviousArrayIndex;
_previousOffset = readResult.PreviousOffset;
foreach (ChatLogItem item in readResult.ChatLogItems)
{
logItems.Push(item);
completeLog.Add(item);
OnChatReceived?.Invoke(this, item);
}
}
if (Reader.CanGetActors())
{
int jobsum0 = 0;
if (actors != null)
{
jobsum0 = actors.CurrentPCs.Sum(e => (int)e.Value.Job);
}
ActorResult actorRes = Reader.GetActors();
if (actors != null)
{
if (actorRes.CurrentPCs.Count != actors.CurrentPCs.Count)
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
int jobsum1 = actorRes.CurrentPCs.Sum(e => (int)e.Value.Job);
if (jobsum0 != jobsum1)
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
}
else
{
actors = actorRes;
OnPcChanged?.Invoke(this, actorRes.CurrentPCs.ToDictionary(k => k.Key, k => k.Value as ActorItemBase));
}
}
return(true);
}
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);
}
/// <summary>
/// Get all npcs around the player in memory
/// </summary>
/// <returns></returns>
public static List <ActorItem> GetNpcsAroundPlayer()
{
ActorResult readResult = Reader.GetActors();
return(readResult.CurrentNPCs.Select(e => e.Value).ToList());
}
// Start memory poll sync
private void SyncWorker_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = (sender as BackgroundWorker);
List <uint> actorIds = (e.Argument as List <uint>);
SyncData data = new SyncData();
Dictionary <uint, uint> performanceToActor = new Dictionary <uint, uint>();
if (Sharlayan.MemoryHandler.Instance.IsAttached)
{
if (Sharlayan.Reader.CanGetPartyMembers() && Sharlayan.Reader.CanGetActors())
{
ActorResult actors = Sharlayan.Reader.GetActors();
foreach (ActorItem actor in actors.CurrentPCs.Values.ToList())
{
if (actorIds.Contains(actor.ID))
{
performanceToActor[actor.PerformanceID / 2] = actor.ID;
}
}
}
}
if (e.Cancel)
{
return;
}
PerformanceResult performanceCache = null;
List <uint> perfKeys = performanceToActor.Keys.ToList();
Stopwatch msCounter = Stopwatch.StartNew();
DateTime now = DateTime.Now;
while (!worker.CancellationPending)
{
if (e.Cancel)
{
return;
}
if (Sharlayan.MemoryHandler.Instance.IsAttached)
{
if (Sharlayan.Reader.CanGetPerformance())
{
performanceCache = Sharlayan.Reader.GetPerformance();
foreach (uint pid in perfKeys)
{
if (performanceToActor.ContainsKey(pid))
{
// Check it
if (performanceCache.Performances[pid].Animation > 0)
{
uint aid = performanceToActor[pid];
//data.idTimestamp[aid] = msCounter.ElapsedMilliseconds;
data.idTimestamp[aid] = (long)((DateTime.Now - now).TotalMilliseconds);
performanceToActor.Remove(pid);
}
}
}
if (perfKeys.Count != performanceToActor.Keys.Count)
{
perfKeys = performanceToActor.Keys.ToList();
}
if (performanceToActor.Keys.Count == 0)
{
break;
}
}
}
}
e.Result = data;
}
