public void InitializeEnmityEventSource()
        {
            this.memory = new EnmityMemory(logger);

            RegisterEventTypes(new List <string> {
                EnmityTargetDataEvent, EnmityAggroListEvent,
            });
        }
示例#2
0
        protected override void Update()
        {
            try
            {
#if TRACE
                var stopwatch = new Stopwatch();
                stopwatch.Start();
#endif

                if (memory == null)
                {
                    foreach (var candidate in memoryCandidates)
                    {
                        if (candidate.IsValid())
                        {
                            memory           = candidate;
                            memoryCandidates = null;
                            break;
                        }
                    }
                }

                if (memory == null || !memory.IsValid())
                {
                    if (memoryValid)
                    {
                        timer.Change(MEMORY_SCAN_INTERVAL, MEMORY_SCAN_INTERVAL);
                        memoryValid = false;
                    }

                    return;
                }
                else if (!memoryValid)
                {
                    // Increase the update interval now that we found our memory
                    timer.Change(this.Config.EnmityIntervalMs, this.Config.EnmityIntervalMs);
                    memoryValid = true;
                }

                // Handle optional "end encounter of combat" logic.
                bool inGameCombat = memory.GetInCombat();
                if (inGameCombat != lastInGameCombat)
                {
                    logger.Log(LogLevel.Debug, inGameCombat ? "Entered combat" : "Left combat");
                }

                // If we've transitioned to being out of combat, start a delayed task to end the ACT encounter.
                if (Config.EndEncounterOutOfCombat && lastInGameCombat && !inGameCombat)
                {
                    endEncounterToken = new CancellationTokenSource();
                    Task.Run(async delegate
                    {
                        await Task.Delay(endEncounterOutOfCombatDelayMs, endEncounterToken.Token);
                        ActGlobals.oFormActMain.Invoke((Action)(() =>
                        {
                            ActGlobals.oFormActMain.EndCombat(true);
                        }));
                    });
                }
                // If combat starts again, cancel any outstanding tasks to stop the ACT encounter.
                // If the task has already run, this will not do anything.
                if (inGameCombat && endEncounterToken != null)
                {
                    endEncounterToken.Cancel();
                    endEncounterToken = null;
                }
                if (lastInGameCombat != inGameCombat)
                {
                    CombatStatusChanged?.Invoke(this, new CombatStatusChangedArgs(inGameCombat));
                }
                lastInGameCombat = inGameCombat;

                if (HasSubscriber(InCombatEvent))
                {
                    bool inACTCombat = Advanced_Combat_Tracker.ActGlobals.oFormActMain.InCombat;
                    if (sentCombatData == null || sentCombatData.inACTCombat != inACTCombat || sentCombatData.inGameCombat != inGameCombat)
                    {
                        if (sentCombatData == null)
                        {
                            sentCombatData = new InCombatDataObject();
                        }
                        sentCombatData.inACTCombat  = inACTCombat;
                        sentCombatData.inGameCombat = inGameCombat;
                        this.DispatchAndCacheEvent(JObject.FromObject(sentCombatData));
                    }
                }

                bool targetData        = HasSubscriber(EnmityTargetDataEvent);
                bool aggroList         = HasSubscriber(EnmityAggroListEvent);
                bool targetableEnemies = HasSubscriber(TargetableEnemiesEvent);
                if (!targetData && !aggroList && !targetableEnemies)
                {
                    return;
                }

                var combatants = memory.GetCombatantList();

                if (targetData)
                {
                    // See CreateTargetData() below
                    this.DispatchEvent(CreateTargetData(combatants));
                }
                if (aggroList)
                {
                    this.DispatchEvent(CreateAggroList(combatants));
                }
                if (targetableEnemies)
                {
                    this.DispatchEvent(CreateTargetableEnemyList(combatants));
                }
#if TRACE
                Log(LogLevel.Trace, "UpdateEnmity: {0}ms", stopwatch.ElapsedMilliseconds);
#endif
            }
            catch (Exception ex)
            {
                Log(LogLevel.Error, "UpdateEnmity: {0}", ex.ToString());
            }
        }
示例#3
0
        protected override void Update()
        {
            try
            {
#if TRACE
                var stopwatch = new Stopwatch();
                stopwatch.Start();
#endif

                if (memory == null)
                {
                    foreach (var candidate in memoryCandidates)
                    {
                        if (candidate.IsValid())
                        {
                            memory           = candidate;
                            memoryCandidates = null;
                            break;
                        }
                    }
                }

                if (memory == null || !memory.IsValid())
                {
                    if (memoryValid)
                    {
                        timer.Change(MEMORY_SCAN_INTERVAL, MEMORY_SCAN_INTERVAL);
                        memoryValid = false;
                    }

                    return;
                }
                else if (!memoryValid)
                {
                    // Increase the update interval now that we found our memory
                    timer.Change(this.Config.EnmityIntervalMs, this.Config.EnmityIntervalMs);
                    memoryValid = true;
                }

                bool targetData = HasSubscriber(EnmityTargetDataEvent);
                bool aggroList  = HasSubscriber(EnmityAggroListEvent);
                if (!targetData && !aggroList)
                {
                    return;
                }

                var combatants = memory.GetCombatantList();

                if (targetData)
                {
                    // See CreateTargetData() below
                    this.DispatchEvent(CreateTargetData(combatants));
                }
                if (aggroList)
                {
                    this.DispatchEvent(CreateAggroList(combatants));
                }

#if TRACE
                Log(LogLevel.Trace, "UpdateEnmity: {0}ms", stopwatch.ElapsedMilliseconds);
#endif
            }
            catch (Exception ex)
            {
                Log(LogLevel.Error, "UpdateEnmity: {0}", ex.ToString());
            }
        }