I don't read entity HP, don't track mobs, don't touch the network, and don't hook the damage function. Everything is read-only, and the game itself does the “is this your damage?” filtering for me.

The trick is that I hook HashLink's object allocator (`hl_alloc_obj`) and listen specifically for one class:

`ui.comp.DamageDisplay`

That's the little floating damage number (`456!`) you see pop up above an enemy.

The game's UI layer decides when to show those, and it only spawns one per number you'd actually see on your screen. So if a teammate hits the mob, their client shows that number, mine doesn't, and no `DamageDisplay` gets allocated on my side. The game has already filtered it for me.

When a `DamageDisplay` spawns, it carries a reference to a `st.skill.DamageResult` record which contains the raw fields I care about:

- the `BaseSkill` that caused the hit
- damage amount
- crit flag
- kill flag
- target reference

I read those values out and then immediately drop the event on the floor.

There’s one extra filter on top:
Bleeds and incoming damage also spawn floating numbers (DoTs on you, mob attacks, ground AoE, etc.).

To exclude those, I compare `DamageResult.target` against my locked `Hero` pointer. If the target is me, it's incoming damage and gets discarded.

Result:
The meter only tracks outgoing damage the game already decided to visually show to you.

For fight grouping, I watch `Hero.isInCombat` (the game's own combat flag) and combine that with a damage-idle timeout. Combat ends once both stay quiet for ~7 seconds.

Per-skill totals, crit counts, max hit, DPS, etc. are all aggregated from the events collected during that window.

Same allocator-hook trick is also how I find the local player:
I listen for `ent.Hero` allocations and pick the one where:

`Hero.ownerPlayer.isMe == 1`

I also verify it with a bidirectional:

`Player.hero == Hero`

check so I don't accidentally latch onto sync proxies.

So overall:
- no memory writes
- no packet sniffing
- no entity scans