// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU General Public License as published by the Free Software Foundation, either // version 3 of the License, or (at your option) any later version. // // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the GNU General Public License for more details. // // You should have received a copy of the GNU General Public License along with // ClassicAPI. If not, see . // The combat log messages — 4.3.4's CombatLog::Handle* parsers and the // UnitCombatLog* builders they call, read from 1.12's bodies of the same // messages through Net::PacketDispatch (no hook on the handlers, which // nampower detours). // // 1.12's bodies (each handler disassembled; benilla-re objectlayer/ // playercombat, unitcombat): // 0x14a ATTACKERSTATEUPDATE hit info, packed attacker, packed victim, // total damage, u8 n, n × {school, float, // damage, absorbed, resisted}, victim state, // u32, melee spell, blocked // 0x250 SPELLNONMELEEDAMAGELOG packed target, packed caster, spell, // damage, u8 school, absorbed, resisted, // u8 periodic, u8, blocked, hit flags, u8 debug // 0x150 SPELLHEALLOG packed target, packed caster, spell, amount, // u8 critical // 0x151 SPELLENERGIZELOG packed target, packed caster, spell, power, // amount // 0x24e PERIODICAURALOG packed target, packed caster, spell, count, // count × {aura type, values by type} // 0x24f SPELLDAMAGESHIELD shield owner, victim (u64), damage, school // 0x1fc ENVIRONMENTALDAMAGELOG victim (u64), u8 type, damage, absorbed, // resisted // 0x260 PROCRESIST caster, target (u64), spell, u8 debug (two // floats follow when it is set) // 0x263 SPELLORDAMAGE_IMMUNE caster, target (u64), spell, u8 debug // What 1.12 does not send is filled as 4.3.4 fills "none": healing absorbed // 0, no periodic critical. Overkill and overhealing, which 1.12 does not send // either, are computed from the target's health (see Predicted). Schools are // indexes here and masks in the event. A damage shield names no spell: the // owner's one damage-shield aura of the damage's school names it, else its // spell prefix is spellId 0 with the damage school. // // Spell misses do not come from here: they reach the log from three places // (the SPELL_GO miss list, a missile's arrival, SPELLLOGMISS), all through // one function — see combatlog/Miss.cpp. #include "combatlog/Entry.h" #include "Game.h" #include "Offsets.h" #include "aura/Data.h" #include "net/PacketDispatch.h" #include "object/Resolve.h" #include "time/Clock.h" #include namespace CombatLog::Packets { namespace { using Net::CDataStore; using Net::Read; using Net::ReadPackedGuid; constexpr uint32_t SMSG_SPELLHEALLOG = 0x150; constexpr uint32_t SMSG_SPELLENERGIZELOG = 0x151; constexpr uint32_t SMSG_ATTACKERSTATEUPDATE = 0x14a; constexpr uint32_t SMSG_ENVIRONMENTALDAMAGELOG = 0x1fc; constexpr uint32_t SMSG_PROCRESIST = 0x260; constexpr uint32_t SMSG_PERIODICAURALOG = 0x24e; constexpr uint32_t SMSG_SPELLDAMAGESHIELD = 0x24f; constexpr uint32_t SMSG_SPELLNONMELEEDAMAGELOG = 0x250; constexpr uint32_t SMSG_SPELLORDAMAGE_IMMUNE = 0x263; // 1.12 melee hit info (the swing line's own tests, 0x00629B60 / 0x00629D30). constexpr uint32_t HITINFO_LEFTSWING = 0x4; constexpr uint32_t HITINFO_MISS = 0x10; constexpr uint32_t HITINFO_ABSORB = 0x20; constexpr uint32_t HITINFO_RESIST = 0x40; constexpr uint32_t HITINFO_CRITICAL = 0x80; constexpr uint32_t HITINFO_GLANCING = 0x4000; constexpr uint32_t HITINFO_CRUSHING = 0x8000; // SPELLNONMELEEDAMAGELOG hit flags (0x005E85E0). constexpr uint32_t SPELL_HIT_CRITICAL = 0x2; constexpr uint32_t SPELL_HIT_SPLIT = 0x8; enum VictimState : uint32_t { VICTIMSTATE_NORMAL = 1, VICTIMSTATE_DODGE = 2, VICTIMSTATE_PARRY = 3, VICTIMSTATE_BLOCKS = 5, VICTIMSTATE_EVADES = 6, VICTIMSTATE_IMMUNE = 7, VICTIMSTATE_DEFLECTS = 8, }; // The aura a damage shield is (SpellAuraNames 15). constexpr int AURA_DAMAGE_SHIELD = 15; // Periodic aura types (SpellAuraNames) the log reads. constexpr uint32_t AURA_PERIODIC_DAMAGE = 3; constexpr uint32_t AURA_PERIODIC_HEAL = 8; constexpr uint32_t AURA_OBS_MOD_HEALTH = 20; constexpr uint32_t AURA_OBS_MOD_MANA = 21; constexpr uint32_t AURA_PERIODIC_ENERGIZE = 24; constexpr uint32_t AURA_PERIODIC_MANA_LEECH = 64; constexpr uint32_t AURA_PERIODIC_DAMAGE_PERCENT = 89; constexpr int kMaxDamageParts = 5; bool Overrun(const CDataStore *p) { return p->m_read > p->m_size; } void *Unit(uint64_t guid) { return Object::ByGuid(Offsets::TYPEMASK_UNIT, guid); } bool PlayerControlled(const void *unit) { const auto *fields = Game::Read(unit, Offsets::OFF_UNIT_DESCRIPTOR); return fields != nullptr && (Game::Read(fields, Offsets::OFF_UNIT_FIELD_FLAGS) & Offsets::UNIT_FLAG_PLAYER_CONTROLLED) != 0; } // 4.3.4's ModifyPredictedHealth, for the overkill and overhealing 1.12 does // not send. The server sends each damage and heal message from the handler // that deals it, and the unit's health in the update that ends the tick, so // a message's target still shows the health before it (verified live: a // target at 148, 113, 91, 63, 37, 10 of 194 under Fireballs of 34, 22, 27, // 26, 27, then the kill at 10 with a 26). Overkill is the damage past that // health and overhealing the heal past the missing health — the server's own // arithmetic, one tick early. A tick's second message on a unit must count // its first, so the messages since the health field was last read are kept // as a delta; a changed field is a fresh snapshot that already counts them. struct Predicted { uint64_t guid = 0; int health = 0; // the field's value the delta was taken against int delta = 0; // the messages since, as a change of health uint32_t stampMs = 0; }; constexpr int kPredictedMax = 16; constexpr uint32_t kPredictedStaleMs = 2000; Predicted g_predicted[kPredictedMax]; // A server that hides health sends a percentage with this maximum (tortoise- // wow Object::BuildValuesUpdate with ShowHealthValues off — the stock setting, // for every unit outside the player's group; Turtle shows real values). Its // damage would read as overkill, so such a unit gets none. constexpr int kHiddenMaxHealth = 100; Predicted &PredictedFor(uint64_t guid, int health, uint32_t now) { Predicted *oldest = &g_predicted[0]; for (Predicted &p : g_predicted) { if (p.guid == guid) { if (p.health != health || Time::Clock::Elapsed(p.stampMs, now) > kPredictedStaleMs) { p.health = health; p.delta = 0; } p.stampMs = now; return p; } if (p.guid == 0 || static_cast(p.stampMs - oldest->stampMs) < 0) oldest = &p; } *oldest = {guid, health, 0, now}; return *oldest; } // The target's health as the tick's earlier messages leave it, and its // maximum. False for a unit out of view or one whose health is hidden. bool PredictedHealth(uint64_t guid, int *health, int *max, Predicted **entry) { const void *unit = Unit(guid); const auto *fields = unit != nullptr ? Game::Read(unit, Offsets::OFF_UNIT_DESCRIPTOR) : nullptr; if (fields == nullptr) return false; *max = Game::Read(fields, Offsets::OFF_UNIT_FIELD_MAXHEALTH); if (*max == kHiddenMaxHealth) return false; const int current = Game::Read(fields, Offsets::OFF_UNIT_FIELD_HEALTH); *entry = &PredictedFor(guid, current, Time::Clock::NowMs()); *health = current + (*entry)->delta; return true; } // The damage past the target's health, counting the damage for the tick's // later messages. int Overkill(uint64_t dest, int damage) { int health, max; Predicted *p; if (damage <= 0 || !PredictedHealth(dest, &health, &max, &p)) return 0; const int overkill = damage > health ? damage - health : 0; p->delta -= damage - overkill; return overkill; } // The heal past the health the target is missing, counting the heal for the // tick's later messages. int Overhealing(uint64_t dest, int amount) { int health, max; Predicted *p; if (amount <= 0 || !PredictedHealth(dest, &health, &max, &p)) return 0; const int missing = max > health ? max - health : 0; const int overhealing = amount > missing ? amount - missing : 0; p->delta += amount - overhealing; return overhealing; } // SendDamageEvent. void SendDamage(uint64_t source, uint64_t dest, int event, const uint8_t *spell, int damage, uint32_t schoolMask, int resisted, int blocked, int absorbed, bool critical, bool glancing, bool crushing, bool offHand) { Entry e = Begin(source, dest, event, spell); e.info |= INFO_DAMAGE; e.v[1] = damage; e.v[2] = Overkill(dest, damage); e.v[3] = static_cast(schoolMask); e.v[4] = absorbed; e.v[5] = resisted; e.v[6] = blocked; e.critical = critical; e.glancing = glancing; e.crushing = crushing; e.offHand = offHand; Queue(e); } void SendMiss(uint64_t source, uint64_t dest, int event, const uint8_t *spell, int missType, int amount, bool offHand) { Entry e = Begin(source, dest, event, spell); SetMissInfo(e, missType, amount, offHand); Queue(e); } // UnitCombatLogSpellDamage. void SpellDamage(uint64_t source, uint64_t dest, const uint8_t *spell, int damage, uint32_t school, int absorbed, int resisted, int blocked, bool critical, bool periodic) { if (Hidden(spell)) return; if (damage != 0) { const int event = periodic ? SPELL_PERIODIC_DAMAGE : (Ranged(spell) ? RANGE_DAMAGE : SPELL_DAMAGE); SendDamage(source, dest, event, spell, damage, SchoolMask(school), resisted, blocked, absorbed, critical, false, false, false); return; } const int event = periodic ? SPELL_PERIODIC_MISSED : (Ranged(spell) ? RANGE_MISSED : SPELL_MISSED); if (absorbed != 0) SendMiss(source, dest, event, spell, MISS_ABSORB, absorbed, false); else if (blocked != 0) SendMiss(source, dest, event, spell, MISS_BLOCK, blocked, false); else if (resisted != 0) SendMiss(source, dest, event, spell, MISS_RESIST, resisted, false); } // UnitCombatLogHeal. void Heal(uint64_t caster, uint64_t target, const uint8_t *spell, int amount, bool critical, bool periodic) { if (amount == 0 || Hidden(spell)) return; Entry e = Begin(caster, target, periodic ? SPELL_PERIODIC_HEAL : SPELL_HEAL, spell); e.info |= INFO_HEAL; e.v[0] = amount; e.v[1] = Overhealing(target, amount); e.v[2] = 0; // absorbed: 1.12 has no healing absorbs e.critical = critical; Queue(e); } // UnitCombatLogEnergize + SendEnergizeEvent. void Energize(uint64_t caster, uint64_t target, const uint8_t *spell, int powerType, int amount, bool periodic) { if (amount == 0 || Hidden(spell)) return; Entry e = Begin(caster, target, periodic ? SPELL_PERIODIC_ENERGIZE : SPELL_ENERGIZE, spell); e.info |= INFO_ENERGIZE; e.v[0] = DisplayAmount(amount, powerType); e.v[1] = powerType; e.v[2] = -1; // alternate power: none in 1.12 Queue(e); } // The periodic mana leech's AddPowerDrainEntry. void Drain(uint64_t caster, uint64_t target, const uint8_t *spell, int powerType, int amount, float multiplier) { if (amount == 0 || Hidden(spell)) return; const int extra = static_cast(static_cast(amount) * multiplier); PowerDrain(caster, target, extra != 0 ? SPELL_PERIODIC_LEECH : SPELL_PERIODIC_DRAIN, spell, amount, powerType, extra); } // SMSG_ATTACKERSTATEUPDATE → UnitCombatLog(ATTACKROUNDINFO). void AttackerState(CDataStore *p) { const uint32_t hitInfo = Read(p); const uint64_t attacker = ReadPackedGuid(p); const uint64_t victim = ReadPackedGuid(p); const int damage = Read(p); const int parts = Read(p); uint32_t school = 0; int absorbed = 0; int resisted = 0; for (int i = 0; i < parts; ++i) { const uint32_t partSchool = Read(p); Read(p); Read(p); // the part's damage; the total is above absorbed += Read(p); resisted += Read(p); if (i == 0) school = partSchool; } uint32_t state = Read(p); Read(p); const uint32_t meleeSpell = Read(p); const int blocked = Read(p); if (Overrun(p) || parts > kMaxDamageParts) return; // ReadAttackerState (0x00625E20): a swing with no damage and a blocked // amount on a victim the client knows is a block. void *victimUnit = Unit(victim); if (victimUnit != nullptr && damage == 0 && blocked != 0) state = VICTIMSTATE_BLOCKS; // ShouldShowFeedback, and who 4.3.4's SMSG_ATTACKER_STATE_UPDATE logs // for: a known attacker, or a player-controlled victim. if (meleeSpell != 0 && state != VICTIMSTATE_NORMAL) return; if (Unit(attacker) == nullptr && (victimUnit == nullptr || !PlayerControlled(victimUnit))) return; const bool offHand = (hitInfo & HITINFO_LEFTSWING) != 0; if ((state == VICTIMSTATE_NORMAL || state == VICTIMSTATE_BLOCKS) && damage != 0) { SendDamage(attacker, victim, SWING_DAMAGE, nullptr, damage, SchoolMask(school), resisted, blocked, absorbed, (hitInfo & HITINFO_CRITICAL) != 0, (hitInfo & HITINFO_GLANCING) != 0, (hitInfo & HITINFO_CRUSHING) != 0, offHand); return; } if (hitInfo & HITINFO_MISS) { SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_MISS, 0, offHand); return; } if (hitInfo & HITINFO_ABSORB) { SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_ABSORB, absorbed, offHand); return; } if (hitInfo & HITINFO_RESIST) { SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_RESIST, resisted, offHand); return; } switch (state) { case VICTIMSTATE_DODGE: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_DODGE, 0, offHand); break; case VICTIMSTATE_PARRY: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_PARRY, 0, offHand); break; case VICTIMSTATE_BLOCKS: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_BLOCK, blocked, offHand); break; case VICTIMSTATE_EVADES: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_EVADE, 0, offHand); break; case VICTIMSTATE_IMMUNE: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_IMMUNE, 0, offHand); break; case VICTIMSTATE_DEFLECTS: SendMiss(attacker, victim, SWING_MISSED, nullptr, MISS_DEFLECT, 0, offHand); break; default: break; } } // SMSG_SPELLNONMELEEDAMAGELOG → HandleSpellNonMeleeDamageLog. void NonMeleeDamage(CDataStore *p) { const uint64_t target = ReadPackedGuid(p); const uint64_t caster = ReadPackedGuid(p); const int spellId = Read(p); const int damage = Read(p); const uint32_t school = Read(p); const int absorbed = Read(p); const int resisted = Read(p); const bool periodic = Read(p) != 0; Read(p); const int blocked = Read(p); const uint32_t hitFlags = Read(p); if (Overrun(p)) return; const uint8_t *spell = SpellRecord(spellId); const bool critical = (hitFlags & SPELL_HIT_CRITICAL) != 0; if (hitFlags & SPELL_HIT_SPLIT) { // UnitCombatLogSplitDamage. if (!Hidden(spell)) SendDamage(caster, target, DAMAGE_SPLIT, spell, damage, SchoolMask(school), resisted, blocked, absorbed, critical, false, false, false); return; } SpellDamage(caster, target, spell, damage, school, absorbed, resisted, blocked, critical, periodic); } // SMSG_SPELLHEALLOG → HandleSpellHealLog. void HealLog(CDataStore *p) { const uint64_t target = ReadPackedGuid(p); const uint64_t caster = ReadPackedGuid(p); const int spellId = Read(p); const int amount = Read(p); const bool critical = Read(p) != 0; if (Overrun(p)) return; Heal(caster, target, SpellRecord(spellId), amount, critical, false); } // SMSG_SPELLENERGIZELOG → HandleSpellLogEnergizeLog. void EnergizeLog(CDataStore *p) { const uint64_t target = ReadPackedGuid(p); const uint64_t caster = ReadPackedGuid(p); const int spellId = Read(p); const int powerType = Read(p); const int amount = Read(p); if (Overrun(p)) return; Energize(caster, target, SpellRecord(spellId), powerType, amount, false); } // SMSG_PERIODICAURALOG → HandlePeriodicAuraLog. void PeriodicAuraLog(CDataStore *p) { const uint64_t target = ReadPackedGuid(p); const uint64_t caster = ReadPackedGuid(p); const int spellId = Read(p); const uint32_t count = Read(p); const uint8_t *spell = SpellRecord(spellId); if (Overrun(p) || spell == nullptr || Unit(target) == nullptr) return; for (uint32_t i = 0; i < count; ++i) { const uint32_t auraType = Read(p); switch (auraType) { case AURA_PERIODIC_DAMAGE: case AURA_PERIODIC_DAMAGE_PERCENT: { const int damage = Read(p); const uint32_t school = Read(p); const int absorbed = Read(p); const int resisted = Read(p); if (Overrun(p)) return; SpellDamage(caster, target, spell, damage, school, absorbed, resisted, 0, false, true); break; } case AURA_PERIODIC_HEAL: case AURA_OBS_MOD_HEALTH: { const int amount = Read(p); if (Overrun(p)) return; Heal(caster, target, spell, amount, false, true); break; } case AURA_OBS_MOD_MANA: case AURA_PERIODIC_ENERGIZE: { const int powerType = Read(p); const int amount = Read(p); if (Overrun(p)) return; Energize(caster, target, spell, powerType, amount, true); break; } case AURA_PERIODIC_MANA_LEECH: { const int powerType = Read(p); const int amount = Read(p); const float multiplier = Read(p); if (Overrun(p)) return; Drain(caster, target, spell, powerType, amount, multiplier); break; } default: return; // an unknown type ends the message, as in both clients } } } // The shield that dealt the damage: the one damage-shield aura of `school` // among the owner's aura slots (Thorns, Fire Shield, Retribution Aura; // Lightning Shield is a proc and arrives through the non-melee log). An owner // out of view, or two shields of one school on one owner, name none. The // shield is still on the owner: the message comes before any aura update. const uint8_t *ShieldSpell(uint64_t owner, uint32_t school) { const auto *unit = static_cast(Unit(owner)); if (unit == nullptr) return nullptr; const uint8_t *found = nullptr; for (int slot = 0; slot < Offsets::UNIT_AURA_TOTAL; ++slot) { const uint32_t spellId = Aura::Data::ReadSpellID(unit, slot); if (spellId == 0) continue; const uint8_t *spell = SpellRecord(static_cast(spellId)); if (spell == nullptr || Game::Read(spell, Offsets::OFF_SPELL_RECORD_SCHOOL) != school || !HasAuraEffect(spell, AURA_DAMAGE_SHIELD)) continue; if (found != nullptr && found != spell) return nullptr; found = spell; } return found; } // SMSG_SPELLDAMAGESHIELD → UnitCombatLogDamageShield. void DamageShield(CDataStore *p) { const uint64_t owner = Read(p); const uint64_t victim = Read(p); const int damage = Read(p); const uint32_t school = Read(p); if (Overrun(p)) return; const uint8_t *spell = ShieldSpell(owner, school); Entry e = Begin(owner, victim, DAMAGE_SHIELD, Hidden(spell) ? nullptr : spell); e.spellPrefix = true; e.spellSchool = SchoolMask(school); e.info |= INFO_DAMAGE; e.v[1] = damage; e.v[2] = Overkill(victim, damage); e.v[3] = static_cast(SchoolMask(school)); Queue(e); } // SMSG_ENVIRONMENTALDAMAGELOG → CGUnit_C::HandleEnvironmentDamage → // UnitCombatLog(guid, type, damage, absorbed, resisted). void EnvironmentalDamage(CDataStore *p) { // s_environmentalDamageSchools: physical ×3, fire, nature, fire. static constexpr uint32_t kSchools[] = {0, 0, 0, 2, 3, 2}; const uint64_t victim = Read(p); const uint32_t type = Read(p); const int damage = Read(p); const int absorbed = Read(p); const int resisted = Read(p); if (Overrun(p) || Unit(victim) == nullptr || (damage == 0 && absorbed == 0 && resisted == 0)) return; Entry e = Begin(0, victim, ENVIRONMENTAL_DAMAGE, nullptr); e.info |= INFO_ENVIRONMENTAL | INFO_DAMAGE; e.v[0] = static_cast(type); e.v[1] = damage; e.v[2] = Overkill(victim, damage); e.v[3] = static_cast(SchoolMask(type < 6 ? kSchools[type] : 0)); e.v[4] = absorbed; e.v[5] = resisted; Queue(e); } // SMSG_PROCRESIST → Packet_SMSG_PROC_RESIST: a resisted proc is a spell miss. void ProcResist(CDataStore *p) { const uint64_t caster = Read(p); const uint64_t target = Read(p); const int spellId = Read(p); if (Overrun(p)) return; const uint8_t *spell = SpellRecord(spellId); if (Hidden(spell)) return; SendMiss(caster, target, SPELL_MISSED, spell, MISS_RESIST, 0, false); } // SMSG_SPELLORDAMAGE_IMMUNE → Packet_SMSG_SPELLORDAMAGE_IMMUNE: a target immune // to the damage (a damage shield's, a periodic tick's). 4.3.4 passes it to // UnitCombatLogSpellMissed as IMMUNE with damageShield = !debug and periodic = // debug, so with the server's debug byte of 0 the event is // DAMAGE_SHIELD_MISSED whatever dealt the damage; 3.3.5 does the same. 1.12's // own line (0x0062D240, IMMUNESPELL…) comes from this handler alone, not from // the miss writer Miss.cpp hooks. void SpellOrDamageImmune(CDataStore *p) { const uint64_t caster = Read(p); const uint64_t target = Read(p); const int spellId = Read(p); const bool debug = Read(p) != 0; if (Overrun(p)) return; const uint8_t *spell = SpellRecord(spellId); if (Hidden(spell)) return; SendMiss(caster, target, debug ? SPELL_PERIODIC_MISSED : DAMAGE_SHIELD_MISSED, spell, MISS_IMMUNE, 0, false); } void OnPacket(uint32_t opcode, CDataStore *p) { switch (opcode) { case SMSG_ATTACKERSTATEUPDATE: AttackerState(p); break; case SMSG_SPELLNONMELEEDAMAGELOG: NonMeleeDamage(p); break; case SMSG_SPELLHEALLOG: HealLog(p); break; case SMSG_SPELLENERGIZELOG: EnergizeLog(p); break; case SMSG_PERIODICAURALOG: PeriodicAuraLog(p); break; case SMSG_SPELLDAMAGESHIELD: DamageShield(p); break; case SMSG_ENVIRONMENTALDAMAGELOG: EnvironmentalDamage(p); break; case SMSG_PROCRESIST: ProcResist(p); break; case SMSG_SPELLORDAMAGE_IMMUNE: SpellOrDamageImmune(p); break; default: break; } } const Net::PacketDispatch::AutoSubscribe _sub{&OnPacket}; } // namespace } // namespace CombatLog::Packets