- Port hit-order Lua stand-ins (unit tokens, tooltips, combat log filters and current entry, bags/containers, quest POI, minimap, titles, world states, trade, group roles, runes, mirror timers, saved-variable registration, Quit) - LoadAddOn: real add-on loading (Blizzard_CombatLog etc. now load) - CombatLogEntry::PushEvent: COMBAT_LOG_EVENT arguments - World map chain: SetMapToCurrentZone, SetMap, GetWorldPosition, landmarks, overlays, highlight, zones, dungeon levels, player position - OpenArchives: locale index was off by one (enUS read the koKR DBC slot, leaving zone/map names empty) - Zone/area sound chain, invisible units (spline mode read size), raid/bag crash fixes, stand-in console, waystone icon for all executables - Coding-rule cleanups: statics/includes at the top, event enums, Lua _Scripts layout Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
1445 lines
43 KiB
C++
1445 lines
43 KiB
C++
#include "UnitCombatLog_C.h"
|
|
#include <cstring>
|
|
#include "Engine/Source/FrameScript/FrameScript.h"
|
|
#include "Engine/Source/Storm/H/storm.h"
|
|
#include "WoW/Source/DB/DBClient/CreatureStats_C.h"
|
|
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
|
|
#include "WoW/Source/DB/Rec/SpellRec.h"
|
|
#include "WoW/Source/Object/ObjectClient/UnitCombat_C.h"
|
|
#include "WoW/Source/WorldClient/FrameTime.h"
|
|
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
|
|
#include <ctime>
|
|
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
|
|
#include "Engine/Source/lua-5.1/src/lua.h"
|
|
#include "WoW/Source/DB/DBClient/GameObjectStats_C.h"
|
|
#include "WoW/Source/Game/GameClient/NameCache.h"
|
|
#include "WoW/Source/Game/GameClient/PetNameCache.h"
|
|
#include "WoW/Source/Object/GameObject.h"
|
|
#include "WoW/Source/Object/ItemStats.h"
|
|
#include "WoW/Source/Object/ObjectClient/GameObject_C.h"
|
|
#include "WoW/Source/Object/ObjectClient/Unit_C.h"
|
|
#include "WoW/Source/Object/ObjectClient/Player_C.h"
|
|
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
|
|
#include "WoW/Source/Ui/ChatFrame.h"
|
|
#include "WoW/Source/Ui/GameUI.h"
|
|
#include "WoW/Source/Ui/PartyFrame.h"
|
|
#include "WoW/Source/Ui/RaidInfo.h"
|
|
#include "WoW/Source/Ui/ScriptEvents.h"
|
|
#include "WoW/Source/Object/ObjectClient/AuraData.h"
|
|
#include "WoW/Source/DB/DBClient/DBClient.h"
|
|
|
|
// STATIC: 0x00ADB758
|
|
static const char* s_combatLogEventNames[50] = {
|
|
"ENVIRONMENTAL_DAMAGE",
|
|
"SWING_DAMAGE",
|
|
"SWING_MISSED",
|
|
"RANGE_DAMAGE",
|
|
"RANGE_MISSED",
|
|
"SPELL_CAST_START",
|
|
"SPELL_CAST_SUCCESS",
|
|
"SPELL_CAST_FAILED",
|
|
"SPELL_MISSED",
|
|
"SPELL_DAMAGE",
|
|
"SPELL_HEAL",
|
|
"SPELL_ENERGIZE",
|
|
"SPELL_DRAIN",
|
|
"SPELL_LEECH",
|
|
"SPELL_INSTAKILL",
|
|
"SPELL_SUMMON",
|
|
"SPELL_CREATE",
|
|
"SPELL_INTERRUPT",
|
|
"SPELL_EXTRA_ATTACKS",
|
|
"SPELL_DURABILITY_DAMAGE",
|
|
"SPELL_DURABILITY_DAMAGE_ALL",
|
|
"SPELL_AURA_APPLIED",
|
|
"SPELL_AURA_APPLIED_DOSE",
|
|
"SPELL_AURA_REMOVED_DOSE",
|
|
"SPELL_AURA_REMOVED",
|
|
"SPELL_AURA_REFRESH",
|
|
"SPELL_DISPEL",
|
|
"SPELL_STOLEN",
|
|
"SPELL_AURA_BROKEN",
|
|
"SPELL_AURA_BROKEN_SPELL",
|
|
"DAMAGE_AURA_BROKEN",
|
|
"ENCHANT_APPLIED",
|
|
"ENCHANT_REMOVED",
|
|
"SPELL_PERIODIC_MISSED",
|
|
"SPELL_PERIODIC_DAMAGE",
|
|
"SPELL_PERIODIC_HEAL",
|
|
"SPELL_PERIODIC_ENERGIZE",
|
|
"SPELL_PERIODIC_DRAIN",
|
|
"SPELL_PERIODIC_LEECH",
|
|
"SPELL_DISPEL_FAILED",
|
|
"DAMAGE_SHIELD",
|
|
"DAMAGE_SHIELD_MISSED",
|
|
"DAMAGE_SPLIT",
|
|
"PARTY_KILL",
|
|
"UNIT_DIED",
|
|
"UNIT_DESTROYED",
|
|
"SPELL_RESURRECT",
|
|
"SPELL_BUILDING_DAMAGE",
|
|
"SPELL_BUILDING_HEAL",
|
|
"UNIT_DISSIPATES"
|
|
};
|
|
|
|
// STATIC: 0x00ADB820
|
|
static const char* s_combatTextTypes[48] = {
|
|
"INTERRUPT",
|
|
"DAMAGE_CRIT",
|
|
"DAMAGE",
|
|
"MISS",
|
|
"DODGE",
|
|
"PARRY",
|
|
"EVADE",
|
|
"IMMUNE",
|
|
"DEFLECT",
|
|
"REFLECT",
|
|
"RESIST",
|
|
"BLOCK",
|
|
"ABSORB",
|
|
"SPELL_DAMAGE_CRIT",
|
|
"SPELL_DAMAGE",
|
|
"SPELL_MISS",
|
|
"SPELL_DODGE",
|
|
"SPELL_PARRY",
|
|
"SPELL_EVADE",
|
|
"SPELL_IMMUNE",
|
|
"SPELL_DEFLECT",
|
|
"SPELL_REFLECT",
|
|
"SPELL_RESIST",
|
|
"SPELL_BLOCK",
|
|
"SPELL_ABSORB",
|
|
"ENCHANTMENT_REMOVED",
|
|
"ENCHANTMENT_ADDED",
|
|
"PERIODIC_HEAL",
|
|
"ENERGIZE",
|
|
"PERIODIC_ENERGIZE",
|
|
"SPELL_CAST",
|
|
"SPELL_AURA_END",
|
|
"SPELL_AURA_END_HARMFUL",
|
|
"SPELL_AURA_START",
|
|
"SPELL_AURA_START_HARMFUL",
|
|
"SPELL_ACTIVE",
|
|
"FACTION",
|
|
"HEAL_CRIT",
|
|
"HEAL",
|
|
"DAMAGE_SHIELD",
|
|
"SPELL_DISPELLED",
|
|
"EXTRA_ATTACKS",
|
|
"SPLIT_DAMAGE",
|
|
"HONOR_GAINED",
|
|
"PERIODIC_HEAL_ABSORB",
|
|
"HEAL_CRIT_ABSORB",
|
|
"HEAL_ABSORB",
|
|
"ARENA_POINTS_GAINED"
|
|
};
|
|
|
|
// STATIC: 0x00ADB944
|
|
static TSList<InvalidatedName, TSGetLink<InvalidatedName> > s_invalidatedNames;
|
|
|
|
// STATIC: 0x00ADB950
|
|
static TSList<PendingCombatLogData, TSGetLink<PendingCombatLogData> > s_pendingData;
|
|
|
|
// STATIC: 0x00ADB95C
|
|
static TSList<PendingCombatLogData, TSGetLink<PendingCombatLogData> > s_freePendingData;
|
|
|
|
// STATIC: 0x00ADB968
|
|
TSList<CombatLogFilter, TSGetLink<CombatLogFilter> > s_filters;
|
|
|
|
// STATIC: 0x00ADB974
|
|
TSList<CombatLogEntry, TSGetLink<CombatLogEntry> > s_entries;
|
|
|
|
// STATIC: 0x00ADB980
|
|
static TSList<CombatLogEntry, TSGetLink<CombatLogEntry> > s_freeEntries;
|
|
|
|
// STATIC: 0x00CA1380
|
|
WOWGUID s_combatTextActiveUnit;
|
|
|
|
// STATIC: 0x00CA1388
|
|
static uint32_t s_startTimeMs;
|
|
|
|
// STATIC: 0x00CA138C
|
|
static uint32_t s_startTime;
|
|
|
|
// STATIC: 0x00CA1390
|
|
CombatLogEntry* s_currentEntry;
|
|
|
|
// STATIC: 0x00CA1394
|
|
CombatLogEntry* s_pendingEntries;
|
|
|
|
// STATIC: 0x00ADBFAC
|
|
const char* g_spellMissStrings[12] = { "NONE", "MISS", "RESIST", "DODGE", "PARRY", "BLOCK", "EVADE", "IMMUNE", "IMMUNE", "DEFLECT", "ABSORB", "REFLECT" };
|
|
|
|
// STATIC: 0x00AD671C
|
|
static const char* s_environmentalDamageTypes[6] = { "FATIGUE", "DROWNING", "FALLING", "LAVA", "SLIME", "FIRE" };
|
|
|
|
// INLINED
|
|
inline CombatLogEntry::CombatLogEntry() {
|
|
this->m_infoFlags = 0;
|
|
this->Clear();
|
|
}
|
|
|
|
// INLINED
|
|
inline CombatLogEntry::~CombatLogEntry() {
|
|
if (this->m_infoFlags & 0x2) {
|
|
SMemFree(this->m_info.m_text, __FILE__, __LINE__, 0);
|
|
}
|
|
|
|
this->CancelPendingCallbacks();
|
|
}
|
|
|
|
// INLINED
|
|
inline InvalidatedName::InvalidatedName() : m_name(nullptr) {
|
|
}
|
|
|
|
// INLINED
|
|
inline InvalidatedName::~InvalidatedName() {
|
|
SMemFree(this->m_name, __FILE__, __LINE__, 0);
|
|
}
|
|
|
|
// VERIFY: e107c6e5 manual
|
|
// OFFSET: 0x0074D1E0
|
|
void CombatLogEntry::SetFailReason(const char* reason) {
|
|
this->m_infoFlags |= 0x2;
|
|
this->m_info.m_text = SStrDupA(reason, __FILE__, __LINE__);
|
|
}
|
|
|
|
// VERIFY: 77d0900b auto
|
|
// OFFSET: 0x0074D210
|
|
void __stdcall CheckToSanitizeUnitLowGuid(WOWGUID* guid) {
|
|
uint32_t type = static_cast<uint32_t>(guid->m_guid >> 32) & 0xF0F00000;
|
|
|
|
if (type == 0xF0300000 || type == 0xF0500000) {
|
|
CreatureStats_C* stats = g_creatureDBCache.GetRecord(static_cast<int32_t>(guid->m_guid >> 24) & 0xFFFFFFF, *guid, nullptr, nullptr, false);
|
|
|
|
if (stats && (stats->m_typeFlags & 0x4000)) {
|
|
guid->m_guid &= 0xFFFFFFFFFF000000ull;
|
|
}
|
|
}
|
|
}
|
|
|
|
// VERIFY: 178bd755 auto
|
|
// OFFSET: 0x0074D430
|
|
int32_t IsCombatTextActiveUnit(WOWGUID guid) {
|
|
return s_combatTextActiveUnit == guid;
|
|
}
|
|
|
|
// VERIFY: 4b539030 auto
|
|
// OFFSET: 0x0074D460
|
|
void SendToCombatText(int32_t type, const char* text, int32_t amount) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%s%d", s_combatTextTypes[type], text, amount);
|
|
}
|
|
|
|
// VERIFY: ec53185e auto
|
|
// OFFSET: 0x0074D490
|
|
void SendToCombatText(int32_t type, const char* text, int32_t amount, int32_t overflow) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%s%d%d", s_combatTextTypes[type], text, amount, overflow);
|
|
}
|
|
|
|
// VERIFY: 41c0dd5e auto
|
|
// OFFSET: 0x0074D4C0
|
|
void SendToCombatText(int32_t type, int32_t amount, int32_t overflow) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%d%d", s_combatTextTypes[type], amount, overflow);
|
|
}
|
|
|
|
// VERIFY: 832fb9f0 auto
|
|
// OFFSET: 0x0074D4F0
|
|
void SendToCombatText(int32_t type, int32_t amount) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%d", s_combatTextTypes[type], amount);
|
|
}
|
|
|
|
// VERIFY: 4c54569b auto
|
|
// OFFSET: 0x0074D520
|
|
void SendToCombatText(int32_t type, const char* text) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%s", s_combatTextTypes[type], text);
|
|
}
|
|
|
|
// VERIFY: 8f0453d6 auto
|
|
// OFFSET: 0x0074D550
|
|
void SendToCombatText(int32_t type) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s", s_combatTextTypes[type]);
|
|
}
|
|
|
|
// VERIFY: 197967e0 auto
|
|
// OFFSET: 0x0074D700
|
|
void UnitCombatLogProcGo(const WOWGUID& casterGuid, const SpellRec* spell) {
|
|
if (s_combatTextActiveUnit == casterGuid && (spell->m_attributesExF & 0x40)) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%s", s_combatTextTypes[30], spell->m_name);
|
|
}
|
|
}
|
|
|
|
// VERIFY: ab3c05fe manual
|
|
// OFFSET: 0x0074D920
|
|
void CombatLogEntry::Clear() {
|
|
this->m_event = -1;
|
|
this->m_pendingMask = 0;
|
|
this->m_sourceGuid = WOWGUID();
|
|
this->m_sourceName = nullptr;
|
|
this->m_sourceRealm = nullptr;
|
|
this->m_sourceFlags = 0x80000000;
|
|
this->m_destGuid = WOWGUID();
|
|
this->m_destName = nullptr;
|
|
this->m_destRealm = nullptr;
|
|
this->m_destFlags = 0x80000000;
|
|
this->m_spellId = 0;
|
|
this->m_spellName.Copy(static_cast<const char*>(nullptr));
|
|
|
|
if (this->m_infoFlags & 0x2) {
|
|
SMemFree(this->m_info.m_text, __FILE__, __LINE__, 0);
|
|
}
|
|
|
|
this->m_infoFlags = 0;
|
|
}
|
|
|
|
// VERIFY: 10cdb977 manual
|
|
// OFFSET: 0x0074D980
|
|
void CombatLogEntry::SetMissInfo(int32_t missType, int32_t amount) {
|
|
this->m_infoFlags |= 0x4;
|
|
this->m_info.m_values[0] = missType;
|
|
|
|
switch (missType) {
|
|
case 2:
|
|
this->m_infoFlags |= 0x4000;
|
|
this->m_info.m_values[5] = amount;
|
|
break;
|
|
case 5:
|
|
this->m_infoFlags |= 0x8000;
|
|
this->m_info.m_values[6] = amount;
|
|
break;
|
|
case 10:
|
|
this->m_infoFlags |= 0x2000;
|
|
this->m_info.m_values[4] = amount;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// VERIFY: 4abe76e4 manual
|
|
// OFFSET: 0x0074E050
|
|
bool CombatLogFilter::SetFilterData(const char* events, const WOWGUID& sourceGuid, uint32_t sourceFlags, const WOWGUID& destGuid, uint32_t destFlags, int32_t spellId, const char* spellName) {
|
|
if (events) {
|
|
if (this->m_events.m_count) {
|
|
memset(this->m_events.m_bits.m_data, 0, sizeof(uint32_t) * this->m_events.m_bits.m_count);
|
|
}
|
|
|
|
char token[128];
|
|
|
|
do {
|
|
SStrTokenize(&events, token, sizeof(token), " ,", nullptr);
|
|
|
|
if (!token[0]) {
|
|
break;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < 50; i++) {
|
|
if (!SStrCmpI(token, s_combatLogEventNames[i], STORM_MAX_STR)) {
|
|
this->m_events.m_bits.m_data[i >> 5] |= 1 << (i & 0x1F);
|
|
break;
|
|
}
|
|
}
|
|
} while (token[0] && *events);
|
|
} else if (this->m_events.m_count) {
|
|
memset(this->m_events.m_bits.m_data, 0xFF, sizeof(uint32_t) * this->m_events.m_bits.m_count);
|
|
}
|
|
|
|
if (sourceGuid) {
|
|
this->m_sourceGuid = sourceGuid;
|
|
this->m_sourceFlags = 0;
|
|
} else {
|
|
this->m_sourceGuid = WOWGUID();
|
|
this->m_sourceFlags = sourceFlags;
|
|
}
|
|
|
|
if (destGuid) {
|
|
this->m_destGuid = destGuid;
|
|
this->m_destFlags = 0;
|
|
} else {
|
|
this->m_destGuid = WOWGUID();
|
|
this->m_destFlags = destFlags;
|
|
}
|
|
|
|
if (spellId) {
|
|
this->m_spellId = spellId;
|
|
this->m_spellName.Copy(static_cast<const char*>(nullptr));
|
|
return true;
|
|
}
|
|
|
|
this->m_spellId = 0;
|
|
this->m_spellName.Copy(spellName);
|
|
return true;
|
|
}
|
|
|
|
// VERIFY: 23038301 manual
|
|
// OFFSET: 0x0074F350
|
|
PendingCombatLogData* GetPendingCombatLogData(CombatLogEntry* entry, const WOWGUID& guid, uint32_t mask) {
|
|
PendingCombatLogData* data = s_freePendingData.Head();
|
|
|
|
if (!data) {
|
|
data = s_freePendingData.NewNode(2, 0, 0);
|
|
}
|
|
|
|
data->m_entry = entry;
|
|
data->m_guid = guid;
|
|
data->m_id = 0;
|
|
data->m_type = 0;
|
|
data->m_mask = mask;
|
|
return data;
|
|
}
|
|
|
|
// VERIFY: 106263c5 manual
|
|
// OFFSET: 0x0074F400
|
|
void UnitCombatLogInvalidateName(const char* name) {
|
|
InvalidatedName* node = s_invalidatedNames.NewNode(2, 0, 0);
|
|
node->m_name = SStrDupA(name, __FILE__, __LINE__);
|
|
|
|
for (CombatLogEntry* entry = s_entries.Head(); entry; entry = s_entries.Next(entry)) {
|
|
if (entry->m_sourceName == name) {
|
|
entry->m_sourceName = node->m_name;
|
|
}
|
|
|
|
if (entry->m_destName == name) {
|
|
entry->m_destName = node->m_name;
|
|
}
|
|
}
|
|
}
|
|
|
|
// VERIFY: aa58db07 manual
|
|
// OFFSET: 0x0074D0D0
|
|
char* GUIDToHexString(WOWGUID guid, char* buffer) {
|
|
buffer[0] = '0';
|
|
buffer[1] = 'x';
|
|
buffer[18] = 0;
|
|
|
|
uint64_t value = guid.m_guid;
|
|
char* digit = &buffer[17];
|
|
|
|
for (int32_t i = 0; i < 16; i++) {
|
|
uint8_t nibble = value & 0xF;
|
|
*digit-- = nibble >= 10 ? nibble + 'A' - 10 : nibble + '0';
|
|
value >>= 4;
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
// VERIFY: b288c8ef auto
|
|
// OFFSET: 0x00756BD0
|
|
void UnitCombatClientInitialize() {
|
|
ClientServices::SetMessageHandler(SMSG_ATTACK_START, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACK_STOP, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACKER_STATE_UPDATE, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACKSWING_NOTINRANGE, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACKSWING_BADFACING, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACKSWING_DEADTARGET, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ATTACKSWING_CANT_ATTACK, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ENVIRONMENTAL_DAMAGE_LOG, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_CLEAR_TARGET, Packet_Group_29, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_COMBAT_EVENT_FAILED, Packet_Group_29, nullptr);
|
|
s_entries.Clear();
|
|
s_freeEntries.Clear();
|
|
s_pendingEntries = nullptr;
|
|
s_currentEntry = nullptr;
|
|
s_filters.Clear();
|
|
s_pendingData.Clear();
|
|
s_freePendingData.Clear();
|
|
s_invalidatedNames.Clear();
|
|
s_startTime = static_cast<uint32_t>(time(nullptr));
|
|
s_startTimeMs = FrameTime::s_curTimeMs;
|
|
ClientServices::SetMessageHandler(SMSG_SPELL_PERIODIC_AURA_LOG, Packet_SMSG_PERIODICAURALOG, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_ENCHANTMENT_LOG, Packet_SMSG_ENCHANTMENTLOG, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_PARTY_KILL_LOG, Packet_SMSG_PARTYKILLLOG, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_PROC_RESIST, Packet_SMSG_PROCRESIST, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_DISPEL_FAILED, Packet_SMSG_DISPEL_FAILED, nullptr);
|
|
ClientServices::SetMessageHandler(SMSG_DESTRUCTIBLE_BUILDING_DAMAGE, Packet_SMSG_DESTRUCTIBLE_BUILDING_DAMAGE, nullptr);
|
|
s_combatTextActiveUnit = WOWGUID{ 0 };
|
|
}
|
|
|
|
// VERIFY: 0526cc02 manual
|
|
// OFFSET: 0x00750270
|
|
void CombatLogEntry::CancelPendingCallbacks() {
|
|
PendingCombatLogData* data = s_pendingData.Head();
|
|
|
|
while (data) {
|
|
if (data->m_entry != this) {
|
|
data = s_pendingData.Next(data);
|
|
continue;
|
|
}
|
|
|
|
switch (data->m_type) {
|
|
case 1:
|
|
g_nameDBCache.CancelCallback(data->m_guid.m_guid, &CombatLogEntry::PendingCombatLogResolved, data);
|
|
break;
|
|
case 2:
|
|
g_petNameCache.CancelCallback(data->m_id, &CombatLogEntry::PendingCombatLogResolved, data);
|
|
break;
|
|
case 3:
|
|
g_creatureDBCache.CancelCallback(data->m_id, &CombatLogEntry::PendingCombatLogResolved, data);
|
|
break;
|
|
case 4:
|
|
g_gameObjectDBCache.CancelCallback(data->m_id, &CombatLogEntry::PendingCombatLogResolved, data);
|
|
break;
|
|
case 5:
|
|
g_itemDBCache.CancelCallback(data->m_id, &CombatLogEntry::PendingCombatLogResolved, data);
|
|
break;
|
|
}
|
|
|
|
data = s_pendingData.DeleteNode(data);
|
|
}
|
|
}
|
|
|
|
// VERIFY: 65a90c44 manual
|
|
// OFFSET: 0x00750390
|
|
void RecycleCombatLogEntry(CombatLogEntry* entry) {
|
|
if (s_pendingEntries == entry) {
|
|
s_pendingEntries = s_entries.Next(entry);
|
|
}
|
|
|
|
if (s_currentEntry == entry) {
|
|
s_currentEntry = s_entries.Next(entry);
|
|
}
|
|
|
|
entry->CancelPendingCallbacks();
|
|
s_freeEntries.LinkToTail(entry);
|
|
}
|
|
|
|
// VERIFY: 40633cfb manual
|
|
// OFFSET: 0x0074F720
|
|
const char* CombatLogEntry::ResolveName(PendingCombatLogData* data, const char** realm, bool pending) {
|
|
void (*callback)(int32_t id, const WOWGUID& guid, void* param, bool success) = pending ? &CombatLogEntry::PendingCombatLogResolved : nullptr;
|
|
const char* name = nullptr;
|
|
|
|
switch (data->m_type) {
|
|
case 1: {
|
|
NameCache* record = g_nameDBCache.GetRecord(data->m_guid.m_guid, data->m_guid, callback, data, false);
|
|
|
|
if (record) {
|
|
if (record->m_realmName[0] && realm) {
|
|
*realm = record->m_realmName;
|
|
}
|
|
|
|
name = record->m_name;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 2: {
|
|
PetNameCache* record = g_petNameCache.GetRecord(data->m_id, data->m_guid, callback, data, false);
|
|
|
|
if (!record) {
|
|
break;
|
|
}
|
|
|
|
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(data->m_guid, TYPEMASK_UNIT, __FILE__, __LINE__));
|
|
|
|
if (unit ? record->m_timestamp == unit->m_unit->m_unitFieldPetNameTimestamp : !pending) {
|
|
name = record->m_name;
|
|
break;
|
|
}
|
|
|
|
UnitCombatLogInvalidateName(record->m_name);
|
|
g_petNameCache.Invalidate(data->m_id);
|
|
g_petNameCache.GetRecord(data->m_id, data->m_guid, callback, data, false);
|
|
break;
|
|
}
|
|
case 3: {
|
|
CreatureStats_C* stats = g_creatureDBCache.GetRecord(data->m_id, data->m_guid, callback, data, false);
|
|
|
|
if (stats) {
|
|
name = stats->GetName(0);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 4: {
|
|
GameObjectStats_C* stats = g_gameObjectDBCache.GetRecord(data->m_id, data->m_guid, callback, data, false);
|
|
|
|
if (stats) {
|
|
name = stats->GetName(0);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 5: {
|
|
ItemStats_C* stats = g_itemDBCache.GetRecord(data->m_id, data->m_guid, callback, data, false);
|
|
|
|
if (stats) {
|
|
name = stats->GetName(0);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (name) {
|
|
return name;
|
|
}
|
|
|
|
const char* text = FrameScript_GetText("UNKNOWNOBJECT", -1, GENDER_NOT_APPLICABLE);
|
|
|
|
if (pending) {
|
|
this->m_pendingMask |= data->m_mask;
|
|
s_pendingData.LinkToTail(data);
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
// VERIFY: d93fe918 manual
|
|
// OFFSET: 0x0074FD40
|
|
const char* CombatLogEntry::GetObjectName(const WOWGUID& guid, uint32_t mask, const char** realm) {
|
|
PendingCombatLogData* data = GetPendingCombatLogData(this, guid, mask);
|
|
uint32_t high = static_cast<uint32_t>(guid.m_guid >> 32);
|
|
|
|
if (!(high & 0xF0000000) && ((high & 0xF07FFFFF) | static_cast<uint32_t>(guid.m_guid))) {
|
|
data->m_type = 1;
|
|
} else {
|
|
uint32_t type = high & 0xF0F00000;
|
|
|
|
if (type == 0xF0300000 || type == 0xF0500000) {
|
|
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(guid, TYPEMASK_UNIT, __FILE__, __LINE__));
|
|
|
|
if (!unit) {
|
|
data->m_type = 3;
|
|
data->m_id = static_cast<int32_t>(guid.m_guid >> 24) & 0xFFFFFFF;
|
|
} else if (unit->m_unit->m_unitFieldPetnumber) {
|
|
data->m_type = 2;
|
|
data->m_id = unit->m_unit->m_unitFieldPetnumber;
|
|
} else {
|
|
data->m_id = unit->m_obj->m_entryID;
|
|
data->m_type = 3;
|
|
}
|
|
} else if (type == 0xF0400000) {
|
|
data->m_id = static_cast<int32_t>(guid.m_guid >> 24) & 0xFFFFFFF;
|
|
data->m_type = 2;
|
|
} else if (type == 0xF0100000) {
|
|
data->m_id = static_cast<int32_t>(guid.m_guid >> 24) & 0xFFFFFFF;
|
|
data->m_type = 4;
|
|
} else {
|
|
return FrameScript_GetText("UNKNOWNOBJECT", -1, GENDER_NOT_APPLICABLE);
|
|
}
|
|
}
|
|
|
|
return this->ResolveName(data, realm, true);
|
|
}
|
|
|
|
// VERIFY: 3635c9ab auto
|
|
// OFFSET: 0x0074FE90
|
|
void CombatLogEntry::PendingCombatLogResolved(int32_t id, const WOWGUID& guid, void* param, bool success) {
|
|
PendingCombatLogData* data = static_cast<PendingCombatLogData*>(param);
|
|
CombatLogEntry* entry = data->m_entry;
|
|
|
|
if (success) {
|
|
const char* realm = nullptr;
|
|
const char* name = entry->ResolveName(data, &realm, false);
|
|
|
|
switch (data->m_mask) {
|
|
case 1:
|
|
entry->m_sourceName = name;
|
|
entry->m_sourceRealm = realm;
|
|
break;
|
|
case 2:
|
|
entry->m_destName = name;
|
|
entry->m_destRealm = realm;
|
|
break;
|
|
case 4:
|
|
entry->m_info.m_names[1] = name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
entry->m_pendingMask &= ~data->m_mask;
|
|
|
|
if (!entry->m_pendingMask) {
|
|
CheckToSanitizeUnitLowGuid(&entry->m_sourceGuid);
|
|
CheckToSanitizeUnitLowGuid(&entry->m_destGuid);
|
|
|
|
if (s_pendingEntries == entry) {
|
|
SendCombatLogEvents();
|
|
}
|
|
}
|
|
|
|
s_freePendingData.LinkToTail(data);
|
|
}
|
|
|
|
// VERIFY: bfdde389 manual
|
|
// OFFSET: 0x0074DCB0
|
|
uint32_t GetCombatLogFlags(const WOWGUID& guid) {
|
|
if (!guid.m_guid) {
|
|
return 0x80000000;
|
|
}
|
|
|
|
bool inRaid = CGRaidInfo::m_numMembers != 0;
|
|
bool inGroup = inRaid || CGPartyInfo::GetNumPartyMembers();
|
|
WOWGUID owner = guid;
|
|
CGObject_C* object = ClntObjMgrObjectPtr(guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
|
|
CGUnit_C* unit = nullptr;
|
|
|
|
if (object) {
|
|
if (object->m_obj->m_type & TYPEMASK_UNIT) {
|
|
unit = static_cast<CGUnit_C*>(object);
|
|
|
|
if (unit->GetCharmerOrCreatorGuid()->m_guid) {
|
|
owner = *unit->GetCharmerOrCreatorGuid();
|
|
}
|
|
} else if (object->m_obj->m_type & TYPEMASK_GAMEOBJECT) {
|
|
owner = static_cast<CGGameObject_C*>(object)->m_gameObject->m_createdBy;
|
|
}
|
|
|
|
uint32_t ownerHigh = static_cast<uint32_t>(owner.m_guid >> 32);
|
|
|
|
if (owner != guid && ((ownerHigh & 0xF0000000) || !((ownerHigh & 0xF07FFFFF) | static_cast<uint32_t>(owner.m_guid)))) {
|
|
CGUnit_C* ownerUnit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(owner, TYPEMASK_UNIT, __FILE__, __LINE__));
|
|
|
|
if (ownerUnit && ownerUnit->GetCharmerOrCreatorGuid()->m_guid) {
|
|
owner = *ownerUnit->GetCharmerOrCreatorGuid();
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t high = static_cast<uint32_t>(guid.m_guid >> 32);
|
|
bool isPlayer = !(high & 0xF0000000) && ((high & 0xF07FFFFF) | static_cast<uint32_t>(guid.m_guid));
|
|
uint32_t type = high & 0xF0F00000;
|
|
uint32_t flags;
|
|
|
|
if (isPlayer || type == 0xF0300000 || type == 0xF0500000 || type == 0xF0400000) {
|
|
if (owner == guid) {
|
|
if (isPlayer) {
|
|
flags = 0x400;
|
|
} else {
|
|
flags = type == 0xF0400000 ? 0x1000 : 0x800;
|
|
}
|
|
} else {
|
|
const WOWGUID& controller = unit->m_unit->m_unitFieldCharmedby.m_guid ? unit->m_unit->m_unitFieldCharmedby : unit->m_unit->m_unitFieldSummonedby;
|
|
flags = controller.m_guid ? 0x1000 : 0x2000;
|
|
}
|
|
} else {
|
|
flags = 0x4000;
|
|
}
|
|
|
|
uint32_t ownerHigh = static_cast<uint32_t>(owner.m_guid >> 32);
|
|
|
|
if ((ownerHigh & 0xF0000000) || !((ownerHigh & 0xF07FFFFF) | static_cast<uint32_t>(owner.m_guid))) {
|
|
flags |= 0x200;
|
|
} else {
|
|
flags |= 0x100;
|
|
}
|
|
|
|
if (owner == ClntObjMgrGetActivePlayer()) {
|
|
flags |= 0x11;
|
|
} else {
|
|
bool hostile = false;
|
|
|
|
if (unit) {
|
|
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
|
|
|
|
if (player) {
|
|
int32_t reaction = unit->UnitReaction(player);
|
|
|
|
if (reaction >= 4) {
|
|
flags |= 0x10;
|
|
} else if (reaction <= 1) {
|
|
flags |= 0x40;
|
|
hostile = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!hostile && inGroup) {
|
|
if (CGPartyInfo::IsMember(owner)) {
|
|
flags |= 0x12;
|
|
} else if (inRaid && IsGuidInMyRaid(owner)) {
|
|
flags |= 0x14;
|
|
}
|
|
}
|
|
|
|
if (!(flags & 0xF)) {
|
|
flags |= 0x8;
|
|
}
|
|
|
|
if (!(flags & 0xF0)) {
|
|
flags |= 0x20;
|
|
}
|
|
}
|
|
|
|
if (guid == CGGameUI::m_lockedTarget) {
|
|
flags |= 0x10000;
|
|
}
|
|
|
|
if (guid == CGGameUI::unk_BD07D0) {
|
|
flags |= 0x20000;
|
|
}
|
|
|
|
if ((flags & 0x400) && ((flags & 0x6) || (owner == ClntObjMgrGetActivePlayer() && inGroup))) {
|
|
uint8_t assignments = inRaid ? CGRaidInfo::GetPartyAssignments(guid) : CGPartyInfo::GetPartyAssignments(guid);
|
|
|
|
if (assignments & 0x2) {
|
|
flags |= 0x40000;
|
|
} else if (assignments & 0x4) {
|
|
flags |= 0x80000;
|
|
}
|
|
}
|
|
|
|
if (inGroup) {
|
|
uint32_t index = GetRaidTargetIndexFromGuid(guid);
|
|
|
|
if (index < 8) {
|
|
return (0x100000 << index) | flags;
|
|
}
|
|
}
|
|
|
|
return flags;
|
|
}
|
|
|
|
// VERIFY: e1ed1d33 auto
|
|
// OFFSET: 0x00750400
|
|
CombatLogEntry* GetCombatLogEntry(const WOWGUID& source, const WOWGUID& dest, int32_t event, const SpellRec* spell) {
|
|
CombatLogEntry* entry = s_freeEntries.Head();
|
|
|
|
if (!entry) {
|
|
CombatLogEntry* oldest = s_entries.Head();
|
|
|
|
if (oldest && static_cast<int32_t>(FrameTime::s_curTimeMs - 1000 * g_combatLogRetentionTimeCVar->m_intValue - oldest->m_timestamp) >= 0) {
|
|
RecycleCombatLogEntry(oldest);
|
|
entry = oldest;
|
|
} else {
|
|
entry = s_freeEntries.NewNode(2, 0, 0);
|
|
}
|
|
}
|
|
|
|
entry->Clear();
|
|
entry->m_event = event;
|
|
|
|
if (source.m_guid && (!spell || !(spell->m_attributesExD & 0x2000))) {
|
|
entry->m_sourceGuid = source;
|
|
entry->m_sourceName = entry->GetObjectName(source, 1, &entry->m_sourceRealm);
|
|
entry->m_sourceFlags = GetCombatLogFlags(source);
|
|
}
|
|
|
|
if (dest.m_guid) {
|
|
entry->m_destGuid = dest;
|
|
entry->m_destName = entry->GetObjectName(dest, 2, &entry->m_destRealm);
|
|
entry->m_destFlags = GetCombatLogFlags(dest);
|
|
}
|
|
|
|
if (spell) {
|
|
entry->m_spellId = spell->m_id;
|
|
entry->m_spellName.Copy(spell->m_name);
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
// VERIFY: c707d13e manual
|
|
// OFFSET: 0x0074F6C0
|
|
bool CombatLogEntry::MatchesFilter() {
|
|
CombatLogFilter* filter = s_filters.Head();
|
|
|
|
if (!filter) {
|
|
return true;
|
|
}
|
|
|
|
for (; filter; filter = s_filters.Next(filter)) {
|
|
if (filter->MatchesFilter(this->m_event, this->m_sourceGuid, this->m_sourceFlags, this->m_destGuid, this->m_destFlags, this->m_spellId, this->m_spellName.m_str)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// VERIFY: c77149c7 manual
|
|
// OFFSET: 0x0074F910
|
|
void SendCombatLogEvents() {
|
|
char text[4096];
|
|
bool logging = CGChat::IsChatLogging(1) != 0;
|
|
lua_State* L = FrameScript_GetContext();
|
|
lua_pushstring(L, g_scriptEvents[566]);
|
|
CombatLogEntry* entry = s_pendingEntries;
|
|
|
|
while (true) {
|
|
int32_t count = entry->PushEvent(L);
|
|
|
|
if (s_pendingEntries->MatchesFilter()) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_LOG_EVENT, L, count + 1);
|
|
}
|
|
|
|
if (!FrameScript_GetEventListeners(g_scriptEvents[567])->Head()) {
|
|
lua_settop(L, -1 - count);
|
|
} else {
|
|
lua_pushstring(L, g_scriptEvents[567]);
|
|
lua_insert(L, -count - 1);
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_LOG_EVENT_UNFILTERED, L, count + 1);
|
|
lua_settop(L, -count - 2);
|
|
}
|
|
|
|
if (logging) {
|
|
s_pendingEntries->PackEvent(text, sizeof(text));
|
|
CGChat::AddCombatMessage(text);
|
|
}
|
|
|
|
entry = s_entries.Next(s_pendingEntries);
|
|
|
|
if (!entry) {
|
|
break;
|
|
}
|
|
|
|
s_pendingEntries = entry;
|
|
|
|
if (entry->m_pendingMask) {
|
|
lua_settop(L, -2);
|
|
return;
|
|
}
|
|
}
|
|
|
|
s_pendingEntries = nullptr;
|
|
lua_settop(L, -2);
|
|
}
|
|
|
|
// VERIFY: fbd407d2 auto
|
|
// OFFSET: 0x0074FF20
|
|
void QueueCombatLogEntry(CombatLogEntry* entry, uint32_t timeOffset) {
|
|
entry->m_timestamp = FrameTime::s_curTimeMs - timeOffset;
|
|
s_entries.LinkToTail(entry);
|
|
|
|
if (s_pendingEntries) {
|
|
return;
|
|
}
|
|
|
|
s_pendingEntries = entry;
|
|
|
|
if (!entry->m_pendingMask) {
|
|
CheckToSanitizeUnitLowGuid(&entry->m_sourceGuid);
|
|
CheckToSanitizeUnitLowGuid(&entry->m_destGuid);
|
|
SendCombatLogEvents();
|
|
}
|
|
}
|
|
|
|
// VERIFY: ebb52f1a auto
|
|
// OFFSET: 0x00754FD0
|
|
bool ShouldShowFeedback(const ATTACKROUNDINFO& info) {
|
|
return !info.m_meleeSpellId || info.m_victimState == 1;
|
|
}
|
|
|
|
// VERIFY: 9b0ab217 manual
|
|
// OFFSET: 0x007512B0
|
|
void UnitCombatLog(const ATTACKROUNDINFO& info) {
|
|
if (info.m_hitInfo & 0x800000) {
|
|
CGUnit_C* attacker = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(info.m_attacker, TYPEMASK_UNIT, __FILE__, __LINE__));
|
|
|
|
if (attacker) {
|
|
attacker->ModifyPredictedPower(1, info.m_rageGained);
|
|
}
|
|
}
|
|
|
|
if (!ShouldShowFeedback(info)) {
|
|
return;
|
|
}
|
|
|
|
uint32_t victimState = info.m_victimState;
|
|
|
|
if ((victimState == 1 || victimState == 5) && info.m_damage) {
|
|
int32_t damage = info.m_damage;
|
|
int32_t resisted = 0;
|
|
int32_t absorbed = 0;
|
|
|
|
for (uint32_t i = 0; i < 2 && info.m_schoolMask[i]; i++) {
|
|
resisted += info.m_resisted[i];
|
|
absorbed += info.m_absorbed[i];
|
|
}
|
|
|
|
WOWGUID target = info.m_target;
|
|
bool crushing = (info.m_hitInfo & 0x20000) != 0;
|
|
bool glancing = (info.m_hitInfo >> 16) & 1;
|
|
bool critical = (info.m_hitInfo & 0x200) != 0;
|
|
int32_t blocked = info.m_blocked;
|
|
uint32_t school = info.m_schoolMask[0];
|
|
int32_t overkill = info.m_overkill;
|
|
CombatLogEntry* entry = GetCombatLogEntry(info.m_attacker, target, 1, nullptr);
|
|
entry->m_infoFlags |= 0x10;
|
|
entry->m_info.m_values[2] = overkill;
|
|
entry->m_info.m_values[4] = absorbed;
|
|
entry->m_info.m_values[3] = school;
|
|
entry->m_info.m_values[6] = blocked;
|
|
entry->m_info.m_values[1] = damage;
|
|
entry->m_info.m_values[5] = resisted;
|
|
entry->m_infoBits = (entry->m_infoBits & ~0x7) | critical | ((glancing | (crushing << 1)) << 1);
|
|
QueueCombatLogEntry(entry, 0);
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
if (resisted > 0) {
|
|
FrameScript_SignalEvent(SCRIPT_EVENT_COMBAT_TEXT_UPDATE, "%s%d%d", s_combatTextTypes[10], damage, resisted);
|
|
} else if (blocked) {
|
|
SendToCombatText(11, damage, blocked);
|
|
} else if (absorbed) {
|
|
SendToCombatText(12, damage, absorbed);
|
|
} else if (critical) {
|
|
SendToCombatText(1, damage);
|
|
} else {
|
|
SendToCombatText(2, damage);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
WOWGUID target = info.m_target;
|
|
CombatLogEntry* entry;
|
|
|
|
if (info.m_hitInfo & 0x10) {
|
|
entry = GetCombatLogEntry(info.m_attacker, target, 2, nullptr);
|
|
entry->SetMissInfo(1, 0);
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
SendToCombatText(3);
|
|
}
|
|
} else if (info.m_hitInfo & 0x20) {
|
|
int32_t absorbed = 0;
|
|
|
|
for (uint32_t i = 0; i < 2 && info.m_schoolMask[i]; i++) {
|
|
absorbed += info.m_absorbed[i];
|
|
}
|
|
|
|
entry = GetCombatLogEntry(info.m_attacker, target, 2, nullptr);
|
|
entry->SetMissInfo(10, absorbed);
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
SendToCombatText(12);
|
|
}
|
|
} else if (info.m_hitInfo & 0x80) {
|
|
int32_t resisted = 0;
|
|
|
|
for (uint32_t i = 0; i < 2 && info.m_schoolMask[i]; i++) {
|
|
resisted += info.m_resisted[i];
|
|
}
|
|
|
|
entry = GetCombatLogEntry(info.m_attacker, target, 2, nullptr);
|
|
entry->SetMissInfo(2, resisted);
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
SendToCombatText(10);
|
|
}
|
|
} else {
|
|
int32_t missType;
|
|
int32_t textType;
|
|
|
|
switch (victimState) {
|
|
case 2:
|
|
missType = 3;
|
|
textType = 4;
|
|
break;
|
|
case 3:
|
|
missType = 4;
|
|
textType = 5;
|
|
break;
|
|
case 5:
|
|
missType = 5;
|
|
textType = 11;
|
|
break;
|
|
case 6:
|
|
missType = 6;
|
|
textType = 6;
|
|
break;
|
|
case 7:
|
|
missType = 7;
|
|
textType = 7;
|
|
break;
|
|
case 8:
|
|
missType = 9;
|
|
textType = 8;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
entry = GetCombatLogEntry(info.m_attacker, target, 2, nullptr);
|
|
entry->SetMissInfo(missType, info.m_blocked);
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
SendToCombatText(textType);
|
|
}
|
|
}
|
|
|
|
QueueCombatLogEntry(entry, 0);
|
|
}
|
|
|
|
// VERIFY: a0eac561 manual
|
|
// OFFSET: 0x00750C90
|
|
int32_t Packet_SMSG_PARTYKILLLOG(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
|
|
uint64_t value = 0;
|
|
msg->Get(value);
|
|
WOWGUID killer = WOWGUID{ value };
|
|
value = 0;
|
|
msg->Get(value);
|
|
WOWGUID victim = WOWGUID{ value };
|
|
CombatLogEntry* entry = GetCombatLogEntry(killer, victim, 43, nullptr);
|
|
QueueCombatLogEntry(entry, 0);
|
|
return 1;
|
|
}
|
|
|
|
// VERIFY: 7cbd4790 manual
|
|
// OFFSET: 0x00750D40
|
|
int32_t Packet_SMSG_PROCRESIST(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
|
|
uint64_t value = 0;
|
|
msg->Get(value);
|
|
WOWGUID caster = WOWGUID{ value };
|
|
value = 0;
|
|
msg->Get(value);
|
|
WOWGUID target = WOWGUID{ value };
|
|
uint32_t spellId = 0;
|
|
msg->Get(spellId);
|
|
uint8_t debug = 0;
|
|
msg->Get(debug);
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(spellId, &spell) && !(spell.m_attributes & 0x180) && *spell.m_name) {
|
|
CombatLogEntry* entry = GetCombatLogEntry(caster, target, 8, &spell);
|
|
entry->m_infoFlags |= 0x4004;
|
|
entry->m_info.m_values[0] = 2;
|
|
entry->m_info.m_values[5] = 0;
|
|
|
|
if (s_combatTextActiveUnit == target) {
|
|
SendToCombatText(22);
|
|
}
|
|
|
|
QueueCombatLogEntry(entry, 0);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// VERIFY: 46a3d6bd auto
|
|
// OFFSET: 0x00750EA0
|
|
int32_t Packet_SMSG_DISPEL_FAILED(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
|
|
uint64_t value = 0;
|
|
msg->Get(value);
|
|
WOWGUID caster = WOWGUID{ value };
|
|
value = 0;
|
|
msg->Get(value);
|
|
WOWGUID target = WOWGUID{ value };
|
|
uint32_t spellId = 0;
|
|
msg->Get(spellId);
|
|
SpellRec spell;
|
|
SpellRec failed;
|
|
|
|
if (g_spellDB.GetRecord(spellId, &spell) && !(spell.m_attributes & 0x180) && *spell.m_name) {
|
|
while (!msg->IsRead()) {
|
|
uint32_t failedId = 0;
|
|
msg->Get(failedId);
|
|
|
|
if (g_spellDB.GetRecord(failedId, &failed) && !(failed.m_attributes & 0x180) && *failed.m_name) {
|
|
CombatLogEntry* entry = GetCombatLogEntry(caster, target, 39, &spell);
|
|
entry->m_infoFlags |= 0x100;
|
|
entry->m_info.m_values[0] = failedId;
|
|
QueueCombatLogEntry(entry, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// VERIFY: dc01d408 auto
|
|
// OFFSET: 0x00752210
|
|
void UnitCombatLogInstakill(const WOWGUID& casterGuid, const WOWGUID& targetGuid, int32_t spellId) {
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(spellId, &spell) && !(spell.m_attributes & 0x180) && *spell.m_name) {
|
|
CombatLogEntry* entry = GetCombatLogEntry(casterGuid, targetGuid, 14, &spell);
|
|
QueueCombatLogEntry(entry, 0);
|
|
}
|
|
}
|
|
|
|
// VERIFY: 80058a0f auto
|
|
// OFFSET: 0x00752860
|
|
void UnitCombatLogAuraDose(CGUnit_C* unit, const AuraData* aura, int32_t spellId, int32_t oldStack, int32_t newStack, uint8_t a6) {
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(spellId, &spell) && !(spell.m_attributes & 0x180) && *spell.m_name && spell.m_cumulativeAura > 1) {
|
|
WOWGUID guid = unit->m_obj->m_guid;
|
|
CombatLogEntry* entry = GetCombatLogEntry(aura->m_creator, guid, (newStack <= oldStack) + 22, &spell);
|
|
entry->m_infoFlags |= 0xC00;
|
|
entry->m_info.m_values[2] = newStack;
|
|
reinterpret_cast<uint8_t&>(entry->m_info.m_values[1]) = a6;
|
|
QueueCombatLogEntry(entry, 0);
|
|
}
|
|
}
|
|
|
|
// VERIFY: 7035a324 manual
|
|
// OFFSET: 0x00752C90
|
|
void UnitCombatLogDamageShield(const WOWGUID& victimGuid, const WOWGUID& casterGuid, int32_t spellId, int32_t damage, uint32_t overkill, uint32_t schoolMask) {
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(spellId, &spell) && !(spell.m_attributes & 0x180) && *spell.m_name) {
|
|
CGUnit_C* caster = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(casterGuid, TYPEMASK_UNIT, __FILE__, __LINE__));
|
|
|
|
if (caster) {
|
|
caster->ModifyPredictedHealth(-damage);
|
|
}
|
|
|
|
CombatLogEntry* entry = GetCombatLogEntry(victimGuid, casterGuid, 40, &spell);
|
|
entry->m_infoFlags |= 0x10;
|
|
entry->m_infoBits &= ~0x7;
|
|
entry->m_info.m_values[1] = damage;
|
|
entry->m_info.m_values[2] = overkill;
|
|
entry->m_info.m_values[3] = schoolMask;
|
|
entry->m_info.m_values[5] = 0;
|
|
entry->m_info.m_values[6] = 0;
|
|
entry->m_info.m_values[4] = 0;
|
|
QueueCombatLogEntry(entry, 0);
|
|
|
|
if (s_combatTextActiveUnit == casterGuid) {
|
|
SendToCombatText(39, damage);
|
|
}
|
|
}
|
|
}
|
|
|
|
// VERIFY: 40adbf60 auto
|
|
// OFFSET: 0x0074D120
|
|
WOWGUID StringToGuid(const char* string) {
|
|
uint64_t value = 0;
|
|
|
|
if (!SStrCmpI(string, "0x", 2)) {
|
|
string += 2;
|
|
}
|
|
|
|
for (int32_t i = 16; i; i--) {
|
|
char c = *string++;
|
|
uint32_t digit;
|
|
|
|
if (static_cast<uint8_t>(c - '0') <= 9) {
|
|
digit = c - '0';
|
|
} else if (static_cast<uint32_t>(c - 'a') <= 5) {
|
|
digit = c - 'a' + 10;
|
|
} else if (static_cast<uint32_t>(c - 'A') <= 5) {
|
|
digit = c - 'A' + 10;
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
value = (value << 4) | digit;
|
|
}
|
|
|
|
return WOWGUID{ value };
|
|
}
|
|
|
|
// VERIFY: 7da56105 manual
|
|
// OFFSET: 0x0074E290
|
|
int32_t CombatLogEntry::PushEvent(lua_State* L) {
|
|
char name[305];
|
|
char guid[20];
|
|
double timestamp = (this->m_timestamp - s_startTimeMs) * 0.001 + static_cast<int32_t>(s_startTime);
|
|
lua_checkstack(L, 8);
|
|
lua_pushnumber(L, timestamp);
|
|
lua_pushstring(L, s_combatLogEventNames[this->m_event]);
|
|
lua_pushstring(L, GUIDToHexString(this->m_sourceGuid, guid));
|
|
|
|
if (!this->m_sourceName) {
|
|
lua_pushnil(L);
|
|
} else if (this->m_sourceRealm) {
|
|
SStrPrintf(name, sizeof(name), "%s-%s", this->m_sourceName, this->m_sourceRealm);
|
|
lua_pushstring(L, name);
|
|
} else if (*this->m_sourceName) {
|
|
lua_pushstring(L, this->m_sourceName);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
lua_pushinteger(L, this->m_sourceFlags);
|
|
lua_pushstring(L, GUIDToHexString(this->m_destGuid, guid));
|
|
|
|
if (!this->m_destName) {
|
|
lua_pushnil(L);
|
|
} else if (this->m_destRealm) {
|
|
SStrPrintf(name, sizeof(name), "%s-%s", this->m_destName, this->m_destRealm);
|
|
lua_pushstring(L, name);
|
|
} else if (*this->m_destName) {
|
|
lua_pushstring(L, this->m_destName);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
lua_pushinteger(L, this->m_destFlags);
|
|
int32_t count = 8;
|
|
|
|
if (this->m_spellId) {
|
|
lua_checkstack(L, 3);
|
|
lua_pushinteger(L, this->m_spellId);
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(this->m_spellId, &spell)) {
|
|
lua_pushstring(L, spell.m_name);
|
|
lua_pushinteger(L, spell.m_schoolMask);
|
|
} else {
|
|
lua_pushnil(L);
|
|
lua_pushinteger(L, 0);
|
|
}
|
|
|
|
count = 11;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x1) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushinteger(L, this->m_info.m_values[0]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x2) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushstring(L, this->m_info.m_text);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x4) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushstring(L, g_spellMissStrings[this->m_info.m_values[0]]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x8) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushstring(L, s_environmentalDamageTypes[this->m_info.m_values[0]]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x10) {
|
|
lua_checkstack(L, 9);
|
|
lua_pushnumber(L, this->m_info.m_values[1]);
|
|
lua_pushnumber(L, this->m_info.m_values[2]);
|
|
lua_pushinteger(L, this->m_info.m_values[3]);
|
|
|
|
if (this->m_info.m_values[5]) {
|
|
lua_pushnumber(L, this->m_info.m_values[5]);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
if (this->m_info.m_values[6]) {
|
|
lua_pushnumber(L, this->m_info.m_values[6]);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
if (this->m_info.m_values[4]) {
|
|
lua_pushnumber(L, this->m_info.m_values[4]);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
if (this->m_infoBits & 0x1) {
|
|
lua_pushnumber(L, 1.0);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
if (this->m_infoBits & 0x2) {
|
|
lua_pushnumber(L, 1.0);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
if (this->m_infoBits & 0x4) {
|
|
lua_pushnumber(L, 1.0);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
count += 9;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x2000) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushinteger(L, this->m_info.m_values[4]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x4000) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushinteger(L, this->m_info.m_values[5]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x8000) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushinteger(L, this->m_info.m_values[6]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x20) {
|
|
lua_checkstack(L, 4);
|
|
lua_pushnumber(L, this->m_info.m_values[0]);
|
|
lua_pushnumber(L, this->m_info.m_values[1]);
|
|
lua_pushnumber(L, this->m_info.m_values[2]);
|
|
|
|
if (static_cast<uint8_t>(this->m_info.m_values[3])) {
|
|
lua_pushnumber(L, 1.0);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
count += 4;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x40) {
|
|
lua_checkstack(L, 2);
|
|
lua_pushnumber(L, this->m_info.m_values[0]);
|
|
lua_pushnumber(L, this->m_info.m_values[1]);
|
|
count += 2;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x80) {
|
|
lua_checkstack(L, 3);
|
|
lua_pushnumber(L, this->m_info.m_values[0]);
|
|
lua_pushnumber(L, this->m_info.m_values[1]);
|
|
|
|
if (this->m_info.m_values[2]) {
|
|
lua_pushnumber(L, this->m_info.m_values[2]);
|
|
} else {
|
|
lua_pushnil(L);
|
|
}
|
|
|
|
count += 3;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x100) {
|
|
lua_checkstack(L, 2);
|
|
lua_pushinteger(L, this->m_info.m_values[0]);
|
|
SpellRec spell;
|
|
|
|
if (g_spellDB.GetRecord(this->m_info.m_values[0], &spell)) {
|
|
lua_pushstring(L, spell.m_name);
|
|
lua_pushinteger(L, spell.m_schoolMask);
|
|
} else {
|
|
lua_pushnil(L);
|
|
lua_pushnumber(L, 0.0);
|
|
}
|
|
|
|
count += 3;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x1000) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushstring(L, this->m_info.m_names[2]);
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x200) {
|
|
lua_checkstack(L, 2);
|
|
lua_pushinteger(L, this->m_info.m_values[0]);
|
|
lua_pushstring(L, this->m_info.m_names[1]);
|
|
count += 2;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x400) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushstring(L, static_cast<uint8_t>(this->m_info.m_values[1]) ? "DEBUFF" : "BUFF");
|
|
count++;
|
|
}
|
|
|
|
if (this->m_infoFlags & 0x800) {
|
|
lua_checkstack(L, 1);
|
|
lua_pushinteger(L, this->m_info.m_values[2]);
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|