Files
ClassicAPI/src/combatlog/Execute.cpp
T
Brues 39ab9eb1ee feat(combatlog): name the damage shield, the dispelling spell and the instakill caster
Three values 1.12's messages leave out, read from what the client already
holds at the moment each message arrives.

DAMAGE_SHIELD: the owner's one damage-shield aura (EffectApplyAuraName 15)
of the damage's school names the shield — Thorns, Fire Shield, Retribution
Aura. Two of one school on one owner, or an owner out of view, keep the
unnamed form.

SPELL_DISPEL, SPELL_DISPEL_FAILED and SPELL_INSTAKILL: the server sends each
from the spell's effect handler, in the same tick as and after that cast's
SMSG_SPELL_GO. CombatLog::RecentCasts keeps the last second of hit lists,
fed from Casts.cpp's existing SPELL_GO parse, and names the caster's newest
cast at the target with a dispel effect (38, 108), or the caster of the
newest cast of the instakill spell at the victim. A dispel from an aura
(Abolish Poison) has no cast and stays unnamed.

Verified live: Remove Lesser Curse -> SPELL_DISPEL 475 "Remove Lesser Curse"
"Curse of Tongues"; a druid's Thorns -> DAMAGE_SHIELD 9910 "Thorns".
2026-10-26 20:55:52 -05:00

316 lines
11 KiB
C++

// 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 <https://www.gnu.org/licenses/>.
// Spell effects — 4.3.4's CombatLog::HandleSpellLogExecute and
// Packet_SMSG_SPELLINSTAKILLLOG, read from 1.12's bodies of the same messages
// through Net::PacketDispatch.
//
// 0x24c SPELLLOGEXECUTE (handler 0x005E7F90): packed caster, spell, effect
// count; per effect its id and a target count, then per target what that
// effect carries. The layout is the server's (tortoise-wow
// Spell::SendLogExecute), which 1.12's reader follows for every effect it
// knows:
// 8 (power drain) u64 target, amount, power, float multiplier
// 19 (extra attacks) u64 target, count
// 24 (create item) item
// 68 (interrupt) u64 target, interrupted spell
// 101 (feed pet) item
// 111 (durability) u64 target, item, slot (both -1: every item)
// 1, 18, 33, 38, 59, 63, 69, 79, 91, 102, 108, 113, 114, 116, 125, 126
// u64 target
// 28, 41, 42, 50, 56, 73, 74, 76, 87-90, 97, 104-107, 112 (the summons)
// u64 summoned — the one block 1.12's reader skips:
// it reads nothing for these effects and leaves the
// GUID in the buffer, so the engine's own log never
// names a summon
// any other nothing (the server sends no message for it)
// 4.3.4 logs drains and leeches, resurrections (18, 113), extra attacks,
// interrupts, durability losses and summons (SPELL_SUMMON for a unit,
// SPELL_CREATE for a game object) from these.
//
// 0x32f SPELLINSTAKILLLOG (0x005E85A0): the victim (u64) and the spell. 1.12
// names no caster; the server sends it from the effect's handler, after the
// cast's SMSG_SPELL_GO in the same tick, so the source is the caster of the
// newest cast of that spell at the victim (RecentCasts), else none.
#include "combatlog/Entry.h"
#include "Game.h"
#include "Offsets.h"
#include "combatlog/RecentCasts.h"
#include "guid/Guid.h"
#include "net/PacketDispatch.h"
#include <cstdint>
namespace CombatLog::Execute {
namespace {
using Net::CDataStore;
using Net::Read;
using Net::ReadPackedGuid;
constexpr uint32_t SMSG_SPELLLOGEXECUTE = 0x24c;
constexpr uint32_t SMSG_SPELLINSTAKILLLOG = 0x32f;
enum Effect : uint32_t {
EFFECT_INSTAKILL = 1,
EFFECT_POWER_DRAIN = 8,
EFFECT_RESURRECT = 18,
EFFECT_ADD_EXTRA_ATTACKS = 19,
EFFECT_CREATE_ITEM = 24,
EFFECT_SUMMON = 28,
EFFECT_OPEN_LOCK = 33,
EFFECT_DISPEL = 38,
EFFECT_SUMMON_WILD = 41,
EFFECT_SUMMON_GUARDIAN = 42,
EFFECT_TRANS_DOOR = 50,
EFFECT_SUMMON_PET = 56,
EFFECT_OPEN_LOCK_ITEM = 59,
EFFECT_THREAT = 63,
EFFECT_INTERRUPT_CAST = 68,
EFFECT_DISTRACT = 69,
EFFECT_SUMMON_POSSESSED = 73,
EFFECT_SUMMON_TOTEM = 74,
EFFECT_SUMMON_OBJECT_WILD = 76,
EFFECT_SANCTUARY = 79,
EFFECT_SUMMON_TOTEM_SLOT1 = 87,
EFFECT_SUMMON_TOTEM_SLOT2 = 88,
EFFECT_SUMMON_TOTEM_SLOT3 = 89,
EFFECT_SUMMON_TOTEM_SLOT4 = 90,
EFFECT_THREAT_ALL = 91,
EFFECT_SUMMON_CRITTER = 97,
EFFECT_FEED_PET = 101,
EFFECT_DISMISS_PET = 102,
EFFECT_SUMMON_OBJECT_SLOT1 = 104,
EFFECT_SUMMON_OBJECT_SLOT2 = 105,
EFFECT_SUMMON_OBJECT_SLOT3 = 106,
EFFECT_SUMMON_OBJECT_SLOT4 = 107,
EFFECT_DISPEL_MECHANIC = 108,
EFFECT_DURABILITY_DAMAGE = 111,
EFFECT_SUMMON_DEMON = 112,
EFFECT_RESURRECT_NEW = 113,
EFFECT_ATTACK_ME = 114,
EFFECT_SKIN_PLAYER_CORPSE = 116,
EFFECT_MODIFY_THREAT_PERCENT = 125,
EFFECT_126 = 126,
};
// AttributesEx3 0x2000000: a drain 4.3.4 logs as periodic.
constexpr uint32_t ATTR_EX3_TREAT_AS_PERIODIC = 0x2000000;
bool Overrun(const CDataStore *p) { return p->m_read > p->m_size; }
// UnitCombatLogPowerDrain.
void PowerDrainEffect(uint64_t caster, uint64_t target, const uint8_t *spell, int amount,
int powerType, float multiplier) {
if (amount == 0 || Hidden(spell))
return;
const bool periodic = (Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_ATTRIBUTES_EX3) &
ATTR_EX3_TREAT_AS_PERIODIC) != 0;
// A drain (effect 8) gives the caster `multiplier` of it: a leech.
const int extra = static_cast<int>(static_cast<float>(amount) * multiplier);
if (extra != 0)
PowerDrain(caster, target, periodic ? SPELL_PERIODIC_LEECH : SPELL_LEECH, spell, amount,
powerType, extra);
else
PowerDrain(caster, target, periodic ? SPELL_PERIODIC_DRAIN : SPELL_DRAIN, spell, amount,
powerType, 0);
}
void Simple(uint64_t caster, uint64_t target, int event, const uint8_t *spell) {
if (Hidden(spell))
return;
Entry e = Begin(caster, target, event, spell);
Queue(e);
}
// UnitCombatLogSummon: a game object or dynamic object is SPELL_CREATE, a
// unit SPELL_SUMMON. A portal writes nothing: every portal spell has
// Attributes 0x100 (verified in Spell.dbc: 11417, 11418, Turtle's 49362), the
// same bit that keeps it out of 1.12's own cast lines; Fishing does not.
void Summon(uint64_t caster, uint64_t summoned, const uint8_t *spell) {
if (summoned == 0)
return;
const bool object = Guid::IsGameObject(summoned) || Guid::IsDynamicObject(summoned);
Simple(caster, summoned, object ? SPELL_CREATE : SPELL_SUMMON, spell);
}
// UnitCombatLogExtraAttacks.
void ExtraAttacks(uint64_t caster, uint64_t target, const uint8_t *spell, int count) {
if (count == 0 || Hidden(spell))
return;
Entry e = Begin(caster, target, SPELL_EXTRA_ATTACKS, spell);
e.info |= INFO_COUNT;
e.v[0] = count;
Queue(e);
}
// UnitCombatLogInterrupt.
void Interrupt(uint64_t caster, uint64_t target, const uint8_t *spell, int interruptedId) {
const uint8_t *interrupted = SpellRecord(interruptedId);
if (Hidden(spell) || Hidden(interrupted))
return;
Entry e = Begin(caster, target, SPELL_INTERRUPT, spell);
e.info |= INFO_EXTRA_SPELL;
e.v[0] = interruptedId;
Queue(e);
}
// UnitCombatLogDurabilityDamage / DurabilityDamageAll.
void Durability(uint64_t caster, uint64_t target, const uint8_t *spell, int itemId, int slot) {
if (Hidden(spell))
return;
if (itemId == -1 && slot == -1) {
Entry e = Begin(caster, target, SPELL_DURABILITY_DAMAGE_ALL, spell);
Queue(e);
return;
}
Entry e = Begin(caster, target, SPELL_DURABILITY_DAMAGE, spell);
SetItem(e, itemId);
Queue(e);
}
// One target of one effect: reads what 1.12 reads, logs what 4.3.4 logs.
// False for an effect that carries nothing, whose other targets read nothing
// either.
bool Target(CDataStore *p, uint32_t effect, uint64_t caster, const uint8_t *spell) {
switch (effect) {
case EFFECT_POWER_DRAIN: {
const uint64_t target = Read<uint64_t>(p);
const int amount = Read<int32_t>(p);
const int powerType = Read<int32_t>(p);
const float multiplier = Read<float>(p);
if (!Overrun(p))
PowerDrainEffect(caster, target, spell, amount, powerType, multiplier);
break;
}
case EFFECT_ADD_EXTRA_ATTACKS: {
const uint64_t target = Read<uint64_t>(p);
const int count = Read<int32_t>(p);
if (!Overrun(p))
ExtraAttacks(caster, target, spell, count);
break;
}
case EFFECT_INTERRUPT_CAST: {
const uint64_t target = Read<uint64_t>(p);
const int interrupted = Read<int32_t>(p);
if (!Overrun(p))
Interrupt(caster, target, spell, interrupted);
break;
}
case EFFECT_DURABILITY_DAMAGE: {
const uint64_t target = Read<uint64_t>(p);
const int itemId = Read<int32_t>(p);
const int slot = Read<int32_t>(p);
if (!Overrun(p))
Durability(caster, target, spell, itemId, slot);
break;
}
case EFFECT_RESURRECT:
case EFFECT_RESURRECT_NEW: {
const uint64_t target = Read<uint64_t>(p);
if (!Overrun(p))
Simple(caster, target, SPELL_RESURRECT, spell);
break;
}
case EFFECT_SUMMON:
case EFFECT_SUMMON_WILD:
case EFFECT_SUMMON_GUARDIAN:
case EFFECT_TRANS_DOOR:
case EFFECT_SUMMON_PET:
case EFFECT_SUMMON_POSSESSED:
case EFFECT_SUMMON_TOTEM:
case EFFECT_SUMMON_OBJECT_WILD:
case EFFECT_SUMMON_TOTEM_SLOT1:
case EFFECT_SUMMON_TOTEM_SLOT2:
case EFFECT_SUMMON_TOTEM_SLOT3:
case EFFECT_SUMMON_TOTEM_SLOT4:
case EFFECT_SUMMON_CRITTER:
case EFFECT_SUMMON_OBJECT_SLOT1:
case EFFECT_SUMMON_OBJECT_SLOT2:
case EFFECT_SUMMON_OBJECT_SLOT3:
case EFFECT_SUMMON_OBJECT_SLOT4:
case EFFECT_SUMMON_DEMON: {
const uint64_t summoned = Read<uint64_t>(p);
if (!Overrun(p))
Summon(caster, summoned, spell);
break;
}
case EFFECT_CREATE_ITEM:
case EFFECT_FEED_PET:
Read<uint32_t>(p);
break;
case EFFECT_INSTAKILL:
case EFFECT_OPEN_LOCK:
case EFFECT_DISPEL:
case EFFECT_OPEN_LOCK_ITEM:
case EFFECT_THREAT:
case EFFECT_DISTRACT:
case EFFECT_SANCTUARY:
case EFFECT_THREAT_ALL:
case EFFECT_DISMISS_PET:
case EFFECT_DISPEL_MECHANIC:
case EFFECT_ATTACK_ME:
case EFFECT_SKIN_PLAYER_CORPSE:
case EFFECT_MODIFY_THREAT_PERCENT:
case EFFECT_126:
Read<uint64_t>(p);
break;
default:
return false;
}
return true;
}
void SpellLogExecute(CDataStore *p) {
const uint64_t caster = ReadPackedGuid(p);
const int spellId = Read<int32_t>(p);
const uint32_t effects = Read<uint32_t>(p);
const uint8_t *spell = SpellRecord(spellId);
if (Overrun(p) || spell == nullptr)
return;
for (uint32_t i = 0; i < effects && !Overrun(p); ++i) {
const uint32_t effect = Read<uint32_t>(p);
const uint32_t targets = Read<uint32_t>(p);
for (uint32_t j = 0; j < targets && !Overrun(p); ++j) {
if (!Target(p, effect, caster, spell))
break;
}
}
}
// SMSG_SPELLINSTAKILLLOG → UnitCombatLogInstakill.
void InstakillLog(CDataStore *p) {
const uint64_t victim = Read<uint64_t>(p);
const int spellId = Read<int32_t>(p);
if (Overrun(p))
return;
const uint64_t caster = RecentCasts::CasterOf(static_cast<uint32_t>(spellId), victim);
Simple(caster, victim, SPELL_INSTAKILL, SpellRecord(spellId));
}
void OnPacket(uint32_t opcode, CDataStore *p) {
if (opcode == SMSG_SPELLLOGEXECUTE)
SpellLogExecute(p);
else if (opcode == SMSG_SPELLINSTAKILLLOG)
InstakillLog(p);
}
const Net::PacketDispatch::AutoSubscribe _sub{&OnPacket};
} // namespace
} // namespace CombatLog::Execute