Implemented Lesser Ghoul efficiency tracker

Author: brandrewsss

src/analysis/retail/deathknight/unholy/CombatLogParser.ts

@@ -14,6 +14,7 @@ import RunicPowerTracker from './modules/core/RunicPowerTracker';
 import VirulentPlagueEfficiency from './modules/spells/VirulentPlagueEfficiency';
 import SoulReaper from '../shared/talents/SoulReaper';
 import CommanderOfTheDead from './modules/talents/CommanderOfTheDead';
+import LesserGhoul from './modules/features/LesserGhoul';
 import RunicPowerGraph from './modules/core/RunicPowerGraph';
 import RuneGraph from './modules/core/RuneGraph';
 import Guide from './modules/Guide';
@@ -30,6 +31,7 @@ class CombatLogParser extends CoreCombatLogParser {
     // Features
     virulentPlagueEfficiency: VirulentPlagueEfficiency,
     suddenDoom: SuddenDoom,
+    lesserGhoul: LesserGhoul,
     unholyRuneForge: UnholyRuneForgeChecker,
 
     // Talents

src/analysis/retail/deathknight/unholy/modules/Buffs.tsx

@@ -22,6 +22,11 @@ class Buffs extends CoreAuras {
         timelineHighlight: false,
       },
       { spellId: SPELLS.SUDDEN_DOOM_BUFF.id, timelineHighlight: true },
+      {
+        spellId: SPELLS.LESSER_GHOUL_BUFF.id,
+        triggeredBySpellId: SPELLS.FESTERING_STRIKE.id,
+        timelineHighlight: true,
+      },
       {
         spellId: SPELLS.ESSENCE_OF_THE_BLOOD_QUEEN_BUFF.id,
         enabled: combatant.hasTalent(TALENTS.GIFT_OF_THE_SANLAYN_TALENT),

src/analysis/retail/deathknight/unholy/modules/features/LesserGhoul.tsx

@@ -0,0 +1,118 @@
+import SPELLS from 'common/SPELLS';
+import Analyzer, { Options, SELECTED_PLAYER } from 'parser/core/Analyzer';
+import Events, {
+  ApplyBuffEvent,
+  ApplyBuffStackEvent,
+  RemoveBuffEvent,
+  RemoveBuffStackEvent,
+} from 'parser/core/Events';
+import { formatPercentage } from 'common/format';
+import BoringSpellValueText from 'parser/ui/BoringSpellValueText';
+import Statistic from 'parser/ui/Statistic';
+import { STATISTIC_ORDER } from 'parser/ui/StatisticBox';
+
+const BUFF_DURATION_MS = 30000;
+const EXPIRE_BUFFER_MS = 100;
+
+class LesserGhoul extends Analyzer {
+  stacksGained = 0;
+  stacksConsumed = 0;
+
+  private currentStacks = 0;
+  private buffAppliedAt: number | null = null;
+
+  constructor(options: Options) {
+    super(options);
+
+    this.addEventListener(
+      Events.applybuff.by(SELECTED_PLAYER).spell(SPELLS.LESSER_GHOUL_BUFF),
+      this.onApplyBuff,
+    );
+    this.addEventListener(
+      Events.applybuffstack.by(SELECTED_PLAYER).spell(SPELLS.LESSER_GHOUL_BUFF),
+      this.onApplyBuffStack,
+    );
+    this.addEventListener(
+      Events.removebuffstack.by(SELECTED_PLAYER).spell(SPELLS.LESSER_GHOUL_BUFF),
+      this.onRemoveBuffStack,
+    );
+    this.addEventListener(
+      Events.removebuff.by(SELECTED_PLAYER).spell(SPELLS.LESSER_GHOUL_BUFF),
+      this.onRemoveBuff,
+    );
+  }
+
+  onApplyBuff(event: ApplyBuffEvent) {
+    this.stacksGained += 1;
+    this.currentStacks = 1;
+    this.buffAppliedAt = event.timestamp;
+  }
+
+  onApplyBuffStack(event: ApplyBuffStackEvent) {
+    const newStacks = event.stack;
+    const gained = newStacks - this.currentStacks;
+    this.stacksGained += gained;
+    this.currentStacks = newStacks;
+    this.buffAppliedAt = event.timestamp;
+  }
+
+  onRemoveBuffStack(event: RemoveBuffStackEvent) {
+    const newStacks = event.stack;
+    const consumed = this.currentStacks - newStacks;
+    this.stacksConsumed += consumed;
+    this.currentStacks = newStacks;
+  }
+
+  onRemoveBuff(event: RemoveBuffEvent) {
+    if (this.currentStacks === 0) {
+      return;
+    }
+
+    /* The last stack fires removebuff instead of removebuffstack, so we use
+    timing to tell apart a Scourge Strike consumption from a natural expiry. */
+    const expectedExpireAt = (this.buffAppliedAt ?? event.timestamp) + BUFF_DURATION_MS;
+    const isExpiration =
+      event.timestamp >= expectedExpireAt - EXPIRE_BUFFER_MS &&
+      event.timestamp <= expectedExpireAt + EXPIRE_BUFFER_MS;
+
+    if (!isExpiration) {
+      this.stacksConsumed += 1;
+    }
+
+    this.currentStacks = 0;
+    this.buffAppliedAt = null;
+  }
+
+  get stacksExpired() {
+    return this.stacksGained - this.stacksConsumed;
+  }
+
+  get efficiency() {
+    return this.stacksGained > 0 ? this.stacksConsumed / this.stacksGained : 1;
+  }
+
+  statistic() {
+    return (
+      <Statistic
+        position={STATISTIC_ORDER.CORE(13)}
+        size="flexible"
+        tooltip={
+          <>
+            <div>
+              You consumed {this.stacksConsumed} out of {this.stacksGained} Lesser Ghoul stacks.
+            </div>
+            <div>{this.stacksExpired} stacks expired without being used.</div>
+          </>
+        }
+      >
+        <BoringSpellValueText spell={SPELLS.LESSER_GHOUL_BUFF}>
+          <>
+            {formatPercentage(this.efficiency)} % <small>stack efficiency</small>
+          </>
+        </BoringSpellValueText>
+      </Statistic>
+    );
+  }
+}
+
+export default LesserGhoul;

src/common/SPELLS/deathknight.ts

@@ -374,6 +374,12 @@ const spells = {
     name: 'Lesser Ghoul',
     icon: 'spell_deathknight_festering_strike',
   },
+  // Tracks active Lesser Ghoul count
+  LESSER_GHOUL_ACTIVE: {
+    id: 1242998,
+    name: 'Lesser Ghoul',
+    icon: 'inv_ghoulnorthrend',
+  },
 
   DREAD_PLAGUE: {
     id: 1240996,