Port Ui missing functions: KB, AccountMsg, Minigame, Dance, EquipmentManager, InstanceEncounter, macro conditions, Trade, Rune, misc LeaveWorld handlers

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
This commit is contained in:
Saty
2026-10-02 18:37:56 +02:00
co-authored by Claude Opus 5.5
parent d9e4c5f644
commit 7c83a8297a
72 changed files with 4646 additions and 188 deletions
+4 -4
View File
@@ -400,7 +400,7 @@ TSList<T, TGetLink>::TSList(const TSList<T, TGetLink>& source) {
}
// VERIFY: 4c44cf25 manual
// OFFSET: 0x00488A70
// OFFSET: [0x00488A70, 0x0056CF00]
template <class T, class TGetLink>
TSList<T, TGetLink>::~TSList() {
this->UnlinkAll();
@@ -547,7 +547,7 @@ T* TSList<T, TGetLink>::Tail() {
}
// VERIFY: cdd999f0 manual
// OFFSET: [0x0047D170, 0x005BD800, 0x007CECD0, 0x00879980]
// OFFSET: [0x0047D170, 0x0056CA70, 0x005BD800, 0x007CECD0, 0x00879980]
template <class T, class TGetLink>
void TSList<T, TGetLink>::UnlinkAll() {
T* node;
@@ -687,7 +687,7 @@ TSFixedArray<T>::TSFixedArray(const TSFixedArray<T>& source) {
}
// VERIFY: 0f3f0aeb manual
// OFFSET: [0x0047C630, 0x0047C6C0, 0x00490BE0, 0x004967E0, 0x004B74F0, 0x004BAFD0, 0x004BC2F0, 0x004BC380, 0x004BE2D0, 0x004C0260, 0x004C9520, 0x004CA720, 0x004CC6F0, 0x004CC780, 0x004CDDD0, 0x004CF070, 0x004D0A70, 0x004D3130, 0x004D33C0, 0x004D4E10, 0x004F31F0, 0x00502360, 0x005032A0, 0x00503330, 0x005033C0, 0x00503450, 0x005053E0, 0x00527BF0, 0x00527C80, 0x00527E70, 0x0052F100, 0x0053F160, 0x00548B70, 0x00558C50, 0x00558CE0, 0x0055F560, 0x0055F5F0, 0x0055F680, 0x0055F710, 0x0055F7A0, 0x00566700, 0x00575F60, 0x005920F0, 0x005B4DE0, 0x005B4E70, 0x005BE830, 0x005BE8C0, 0x005C7290, 0x005C7320, 0x005C91F0, 0x005D24E0, 0x005E6880, 0x005F03B0, 0x005F3E20, 0x005F5AD0, 0x005F5B60, 0x005F5BF0, 0x005FCB80, 0x00617AA0, 0x00617B30, 0x00617BC0, 0x0066E830, 0x0066E8C0, 0x0066E950, 0x0066E9E0, 0x0066EA70, 0x0066EB00, 0x0066EB90, 0x0066EC20, 0x0066ECB0, 0x0066ED40, 0x0066EDD0, 0x0066EE60, 0x0066EEF0, 0x0066EF80, 0x0066F010, 0x0066F0A0, 0x0066F130, 0x0066F1C0, 0x0066F250, 0x0066F2E0, 0x0066F370, 0x0066F400, 0x0066F490, 0x0066F520, 0x0066F5B0, 0x0066F640, 0x0066F6D0, 0x0066F760, 0x0066F7F0, 0x0066F880, 0x006881A0, 0x006BBE30, 0x006BEE90, 0x006C2650, 0x006C2AC0, 0x006C2B50, 0x006C8380, 0x006E4EB0, 0x006E4F40, 0x006F2C50, 0x006F2CE0, 0x006F2D70, 0x006F2E00, 0x006F2E90, 0x006F2F20, 0x006F2FB0, 0x00709AA0, 0x00709B30, 0x007131B0, 0x0072FFC0, 0x007675F0, 0x007685D0, 0x00776AD0, 0x007B04D0, 0x007B5DF0, 0x007C0B40, 0x007C0BD0, 0x007DD360, 0x007DD3F0, 0x007E01C0, 0x007F2A20, 0x007F4ED0, 0x00804EF0, 0x00804F80, 0x008109F0, 0x00810A80, 0x00810B10, 0x00812BC0, 0x00812C50, 0x00814910, 0x0081A620, 0x00848800, 0x0084B570, 0x00876550, 0x00877760, 0x0087B0F0, 0x00965260, 0x009681C0, 0x009694A0, 0x009694F0, 0x0097BB80]
// OFFSET: [0x0047C630, 0x0047C6C0, 0x00490BE0, 0x004967E0, 0x004B74F0, 0x004BAFD0, 0x004BC2F0, 0x004BC380, 0x004BE2D0, 0x004C0260, 0x004C9520, 0x004CA720, 0x004CC6F0, 0x004CC780, 0x004CDDD0, 0x004CF070, 0x004D0A70, 0x004D3130, 0x004D33C0, 0x004D4E10, 0x004F31F0, 0x00502360, 0x005032A0, 0x00503330, 0x005033C0, 0x00503450, 0x005053E0, 0x00527BF0, 0x00527C80, 0x00527E70, 0x0052F100, 0x0053F160, 0x00546FE0, 0x00548B70, 0x00558C50, 0x00558CE0, 0x0055F560, 0x0055F5F0, 0x0055F680, 0x0055F710, 0x0055F7A0, 0x00566700, 0x00575F60, 0x005920F0, 0x005B4DE0, 0x005B4E70, 0x005BE830, 0x005BE8C0, 0x005C7290, 0x005C7320, 0x005C91F0, 0x005D24E0, 0x005E6880, 0x005F03B0, 0x005F3E20, 0x005F5AD0, 0x005F5B60, 0x005F5BF0, 0x005FCB80, 0x00617AA0, 0x00617B30, 0x00617BC0, 0x0066E830, 0x0066E8C0, 0x0066E950, 0x0066E9E0, 0x0066EA70, 0x0066EB00, 0x0066EB90, 0x0066EC20, 0x0066ECB0, 0x0066ED40, 0x0066EDD0, 0x0066EE60, 0x0066EEF0, 0x0066EF80, 0x0066F010, 0x0066F0A0, 0x0066F130, 0x0066F1C0, 0x0066F250, 0x0066F2E0, 0x0066F370, 0x0066F400, 0x0066F490, 0x0066F520, 0x0066F5B0, 0x0066F640, 0x0066F6D0, 0x0066F760, 0x0066F7F0, 0x0066F880, 0x006881A0, 0x006BBE30, 0x006BEE90, 0x006C2650, 0x006C2AC0, 0x006C2B50, 0x006C8380, 0x006E4EB0, 0x006E4F40, 0x006F2C50, 0x006F2CE0, 0x006F2D70, 0x006F2E00, 0x006F2E90, 0x006F2F20, 0x006F2FB0, 0x00709AA0, 0x00709B30, 0x007131B0, 0x0072FFC0, 0x007675F0, 0x007685D0, 0x00776AD0, 0x007B04D0, 0x007B5DF0, 0x007C0B40, 0x007C0BD0, 0x007DD360, 0x007DD3F0, 0x007E01C0, 0x007F2A20, 0x007F4ED0, 0x00804EF0, 0x00804F80, 0x008109F0, 0x00810A80, 0x00810B10, 0x00812BC0, 0x00812C50, 0x00814910, 0x0081A620, 0x00848800, 0x0084B570, 0x00876550, 0x00877760, 0x0087B0F0, 0x00965260, 0x009681C0, 0x009694A0, 0x009694F0, 0x0097BB80]
template <class T>
TSFixedArray<T>::~TSFixedArray() {
for (uint32_t i = 0; i < this->m_count; i++) {
@@ -727,7 +727,7 @@ void TSFixedArray<T>::ReallocAndClearData(uint32_t count) {
}
// VERIFY: e2efd710 manual
// OFFSET: [0x00403760, 0x004037F0, 0x00408340, 0x004083F0, 0x00408490, 0x00408D80, 0x004644C0, 0x004657D0, 0x00466910, 0x0047CCC0, 0x0047D9F0, 0x0047DA80, 0x00480EE0, 0x004827C0, 0x00490A80, 0x00493A40, 0x00493AD0, 0x00496680, 0x00497970, 0x00497A00, 0x004B7580, 0x004B9990, 0x004B9A20, 0x004BB060, 0x004BBDA0, 0x004BBF00, 0x004BC060, 0x004BE170, 0x004BEBB0, 0x004C00B0, 0x004C46C0, 0x004C4750, 0x004CA380, 0x004CB930, 0x004CB9C0, 0x004CC360, 0x004CC4C0, 0x004CDB20, 0x004CEA00, 0x004CEAA0, 0x004CEF00, 0x004D0910, 0x004D2D90, 0x004D34A0, 0x004D4FF0, 0x004D85A0, 0x004DE520, 0x004E0EC0, 0x004E25C0, 0x004E6660, 0x004F2FB0, 0x004FCFC0, 0x004FD050, 0x004FD150, 0x004FFCE0, 0x005014A0, 0x005023E0, 0x00502540, 0x005026A0, 0x00502800, 0x005034E0, 0x00514100, 0x005141A0, 0x0051A2E0, 0x00525720, 0x00525880, 0x00527D10, 0x0052EF00, 0x0053B790, 0x0053B820, 0x0053EFA0, 0x005436A0, 0x00548640, 0x005489C0, 0x0054EC50, 0x0054ECF0, 0x00553220, 0x005532C0, 0x00553350, 0x005533E0, 0x00558710, 0x00558870, 0x0055EAD0, 0x0055EC30, 0x0055ED90, 0x0055EEF0, 0x0055F050, 0x00564CE0, 0x00566790, 0x005685D0, 0x0056BAD0, 0x0056BD40, 0x0056D780, 0x0056D810, 0x00575DC0, 0x00577410, 0x0057C120, 0x0057C1B0, 0x0057E360, 0x0057E400, 0x0058E030, 0x0058F8F0, 0x005907A0, 0x00590870, 0x00590920, 0x005909C0, 0x00590A60, 0x00591F70, 0x00592180, 0x00592290, 0x00593FC0, 0x00594050, 0x00599030, 0x0059B150, 0x0059B1F0, 0x005A2AF0, 0x005A46F0, 0x005B49B0, 0x005B4B10, 0x005B8C80, 0x005BDF60, 0x005BE0C0, 0x005C58D0, 0x005C5960, 0x005C6C60, 0x005C6DC0, 0x005C9080, 0x005CA3D0, 0x005CD240, 0x005CD2D0, 0x005CEB50, 0x005CFFB0, 0x005D0080, 0x005D0110, 0x005D2360, 0x005D3260, 0x005DA3F0, 0x005DA480, 0x005DA510, 0x005E6E40, 0x005E7940, 0x005ED620, 0x005EEB80, 0x005F0240, 0x005F0440, 0x005F1420, 0x005F39B0, 0x005F4E30, 0x005F5020, 0x005F5180, 0x005F52E0, 0x005FC9C0, 0x005FEF70, 0x0060A1C0, 0x0060A260, 0x006152E0, 0x006169A0, 0x00616C20, 0x00617280, 0x006173E0, 0x00617540, 0x0061BD20, 0x0061BDB0, 0x00634790, 0x00634820, 0x00669EB0, 0x0066CD10, 0x0066CE70, 0x0066CFD0, 0x0066D130, 0x0066D290, 0x0066D3F0, 0x0066D550, 0x0066D6B0, 0x0066D810, 0x0066D970, 0x0066DAD0, 0x0066DC30, 0x0066DD90, 0x0066DEF0, 0x0066E050, 0x00681800, 0x006822B0, 0x00683760, 0x00683810, 0x006838B0, 0x00683960, 0x00688040, 0x00689F90, 0x006A54A0, 0x006A9440, 0x006B1EF0, 0x006BA590, 0x006BBBE0, 0x006C26E0, 0x006C2840, 0x006C4210, 0x006C4E20, 0x006C5EE0, 0x006C5F80, 0x006C6020, 0x006C8220, 0x006C9DF0, 0x006CF4A0, 0x006CF540, 0x006CF5E0, 0x006E4BF0, 0x006E4D50, 0x006F2120, 0x006F2280, 0x006F23E0, 0x006F2540, 0x006F26A0, 0x006F2800, 0x006F2960, 0x006FECD0, 0x00709580, 0x007096E0, 0x00716260, 0x00716300, 0x007163B0, 0x0072FE60, 0x00746400, 0x00747C10, 0x00747CA0, 0x007583D0, 0x00767490, 0x00768460, 0x00769D80, 0x0076D060, 0x007760A0, 0x00776950, 0x00786B90, 0x00790250, 0x007902E0, 0x00790370, 0x007917D0, 0x00791870, 0x0079B370, 0x0079BA30, 0x0079D510, 0x0079F650, 0x007A01C0, 0x007B0370, 0x007B0D60, 0x007B0DF0, 0x007B0E80, 0x007B4F10, 0x007BA120, 0x007BDFE0, 0x007BE140, 0x007C30B0, 0x007CC020, 0x007CCBE0, 0x007CCC80, 0x007CDEC0, 0x007DBB10, 0x007DBBC0, 0x007DD0A0, 0x007DD200, 0x007E0050, 0x007E6600, 0x007E7FF0, 0x007EBEA0, 0x007ECFF0, 0x007F1F80, 0x007F3BF0, 0x007F3D70, 0x007F4CF0, 0x007F78F0, 0x007F79C0, 0x007F8E30, 0x007F9F80, 0x007FA020, 0x007FA0B0, 0x00804830, 0x00804990, 0x00810370, 0x00810500, 0x00810660, 0x008107C0, 0x008128D0, 0x00812A30, 0x00814800, 0x008196A0, 0x0081A2F0, 0x0081CDC0, 0x00824660, 0x00824700, 0x00848890, 0x0084B140, 0x0084B2A0, 0x008555E0, 0x0086D0E0, 0x0086E8E0, 0x008704B0, 0x00876370, 0x00878E90, 0x00878F30, 0x0087AEB0, 0x00887490, 0x008A17D0, 0x008A1860, 0x008A18F0, 0x00959260, 0x0095E2C0, 0x009633C0, 0x00967E50, 0x00967EF0, 0x009690F0, 0x00969540, 0x00978EC0, 0x0097BBE0, 0x0097F650, 0x00980EE0, 0x009A80F0, 0x009A8D50, 0x009A8DF0]
// OFFSET: [0x00403760, 0x004037F0, 0x00408340, 0x004083F0, 0x00408490, 0x00408D80, 0x004644C0, 0x004657D0, 0x00466910, 0x0047CCC0, 0x0047D9F0, 0x0047DA80, 0x00480EE0, 0x004827C0, 0x00490A80, 0x00493A40, 0x00493AD0, 0x00496680, 0x00497970, 0x00497A00, 0x004B7580, 0x004B9990, 0x004B9A20, 0x004BB060, 0x004BBDA0, 0x004BBF00, 0x004BC060, 0x004BE170, 0x004BEBB0, 0x004C00B0, 0x004C46C0, 0x004C4750, 0x004CA380, 0x004CB930, 0x004CB9C0, 0x004CC360, 0x004CC4C0, 0x004CDB20, 0x004CEA00, 0x004CEAA0, 0x004CEF00, 0x004D0910, 0x004D2D90, 0x004D34A0, 0x004D4FF0, 0x004D85A0, 0x004DE520, 0x004E0EC0, 0x004E25C0, 0x004E6660, 0x004F2FB0, 0x004FCFC0, 0x004FD050, 0x004FD150, 0x004FFCE0, 0x005014A0, 0x005023E0, 0x00502540, 0x005026A0, 0x00502800, 0x005034E0, 0x00514100, 0x005141A0, 0x0051A2E0, 0x00525720, 0x00525880, 0x00527D10, 0x0052EF00, 0x0053B790, 0x0053B820, 0x0053EFA0, 0x005436A0, 0x00547C20, 0x00548640, 0x005489C0, 0x0054EC50, 0x0054ECF0, 0x00553220, 0x005532C0, 0x00553350, 0x005533E0, 0x00558710, 0x00558870, 0x0055EAD0, 0x0055EC30, 0x0055ED90, 0x0055EEF0, 0x0055F050, 0x00564CE0, 0x00566790, 0x005685D0, 0x0056BAD0, 0x0056BD40, 0x0056D780, 0x0056D810, 0x00575DC0, 0x00577410, 0x0057C120, 0x0057C1B0, 0x0057E360, 0x0057E400, 0x0058E030, 0x0058F8F0, 0x005907A0, 0x00590870, 0x00590920, 0x005909C0, 0x00590A60, 0x00591F70, 0x00592180, 0x00592290, 0x00593FC0, 0x00594050, 0x00599030, 0x0059B150, 0x0059B1F0, 0x005A2AF0, 0x005A46F0, 0x005B49B0, 0x005B4B10, 0x005B8C80, 0x005BDF60, 0x005BE0C0, 0x005C58D0, 0x005C5960, 0x005C6C60, 0x005C6DC0, 0x005C9080, 0x005CA3D0, 0x005CD240, 0x005CD2D0, 0x005CEB50, 0x005CFFB0, 0x005D0080, 0x005D0110, 0x005D2360, 0x005D3260, 0x005DA3F0, 0x005DA480, 0x005DA510, 0x005E6E40, 0x005E7940, 0x005ED620, 0x005EEB80, 0x005F0240, 0x005F0440, 0x005F1420, 0x005F39B0, 0x005F4E30, 0x005F5020, 0x005F5180, 0x005F52E0, 0x005FC9C0, 0x005FEF70, 0x0060A1C0, 0x0060A260, 0x006152E0, 0x006169A0, 0x00616C20, 0x00617280, 0x006173E0, 0x00617540, 0x0061BD20, 0x0061BDB0, 0x00634790, 0x00634820, 0x00669EB0, 0x0066CD10, 0x0066CE70, 0x0066CFD0, 0x0066D130, 0x0066D290, 0x0066D3F0, 0x0066D550, 0x0066D6B0, 0x0066D810, 0x0066D970, 0x0066DAD0, 0x0066DC30, 0x0066DD90, 0x0066DEF0, 0x0066E050, 0x00681800, 0x006822B0, 0x00683760, 0x00683810, 0x006838B0, 0x00683960, 0x00688040, 0x00689F90, 0x006A54A0, 0x006A9440, 0x006B1EF0, 0x006BA590, 0x006BBBE0, 0x006C26E0, 0x006C2840, 0x006C4210, 0x006C4E20, 0x006C5EE0, 0x006C5F80, 0x006C6020, 0x006C8220, 0x006C9DF0, 0x006CF4A0, 0x006CF540, 0x006CF5E0, 0x006E4BF0, 0x006E4D50, 0x006F2120, 0x006F2280, 0x006F23E0, 0x006F2540, 0x006F26A0, 0x006F2800, 0x006F2960, 0x006FECD0, 0x00709580, 0x007096E0, 0x00716260, 0x00716300, 0x007163B0, 0x0072FE60, 0x00746400, 0x00747C10, 0x00747CA0, 0x007583D0, 0x00767490, 0x00768460, 0x00769D80, 0x0076D060, 0x007760A0, 0x00776950, 0x00786B90, 0x00790250, 0x007902E0, 0x00790370, 0x007917D0, 0x00791870, 0x0079B370, 0x0079BA30, 0x0079D510, 0x0079F650, 0x007A01C0, 0x007B0370, 0x007B0D60, 0x007B0DF0, 0x007B0E80, 0x007B4F10, 0x007BA120, 0x007BDFE0, 0x007BE140, 0x007C30B0, 0x007CC020, 0x007CCBE0, 0x007CCC80, 0x007CDEC0, 0x007DBB10, 0x007DBBC0, 0x007DD0A0, 0x007DD200, 0x007E0050, 0x007E6600, 0x007E7FF0, 0x007EBEA0, 0x007ECFF0, 0x007F1F80, 0x007F3BF0, 0x007F3D70, 0x007F4CF0, 0x007F78F0, 0x007F79C0, 0x007F8E30, 0x007F9F80, 0x007FA020, 0x007FA0B0, 0x00804830, 0x00804990, 0x00810370, 0x00810500, 0x00810660, 0x008107C0, 0x008128D0, 0x00812A30, 0x00814800, 0x008196A0, 0x0081A2F0, 0x0081CDC0, 0x00824660, 0x00824700, 0x00848890, 0x0084B140, 0x0084B2A0, 0x008555E0, 0x0086D0E0, 0x0086E8E0, 0x008704B0, 0x00876370, 0x00878E90, 0x00878F30, 0x0087AEB0, 0x00887490, 0x008A17D0, 0x008A1860, 0x008A18F0, 0x00959260, 0x0095E2C0, 0x009633C0, 0x00967E50, 0x00967EF0, 0x009690F0, 0x00969540, 0x00978EC0, 0x0097BBE0, 0x0097F650, 0x00980EE0, 0x009A80F0, 0x009A8D50, 0x009A8DF0]
template <class T>
void TSFixedArray<T>::ReallocData(uint32_t count) {
T* olddata = this->m_data;
+1 -1
View File
@@ -290,7 +290,7 @@ void DBCache<T, TKey, THashKey>::Load() {
}
// VERIFY: a9ebf5d0 manual
// OFFSET: [0x0067B6A0, 0x0067BD40, 0x0067CA30, 0x0067D930, 0x0067DE90]
// OFFSET: [0x0067B6A0, 0x0067BD40, 0x0067CA30, 0x0067D0D0, 0x0067D930, 0x0067DE90, 0x0067E3E0, 0x0067F4C0, 0x006806D0]
template <class T, class TKey, class THashKey>
T* DBCache<T, TKey, THashKey>::GetRecord(TKey key, const WOWGUID& guid, void (*callback)(int32_t id, const WOWGUID& guid, void* param, bool success), void* param, bool unique) {
if (DBCacheIsNullKey(key)) {
+102
View File
@@ -0,0 +1,102 @@
#include "RandomSeed.h"
#include <cstdlib>
#include <ctime>
#include "Engine/Source/Tempest/CMath.h"
// VERIFY: 20bd83da manual
// OFFSET: 0x007F6AA0
static void GenerateRandomValues(_RandomSeed* seed) {
uint32_t a = seed->m_a;
uint32_t b = seed->m_b;
for (uint32_t i = 0; i < 256; i += 4) {
uint32_t x = seed->m_mem[i];
a = ((a << 19) ^ (a >> 13)) + seed->m_mem[(i + 128) & 0xFF];
uint32_t y = seed->m_mem[x & 0xFF] + b + a;
seed->m_mem[i] = y;
b = seed->m_mem[(y >> 8) & 0xFF] + x;
seed->m_rsl[i] = b;
x = seed->m_mem[i + 1];
a = ((a << 19) ^ (a >> 13)) + seed->m_mem[(i + 129) & 0xFF];
y = seed->m_mem[x & 0xFF] + b + a;
seed->m_mem[i + 1] = y;
b = seed->m_mem[(y >> 8) & 0xFF] + x;
seed->m_rsl[i + 1] = b;
x = seed->m_mem[i + 2];
a = ((a << 19) ^ (a >> 13)) + seed->m_mem[(i + 130) & 0xFF];
y = seed->m_mem[x & 0xFF] + b + a;
seed->m_mem[i + 2] = y;
b = seed->m_mem[(y >> 8) & 0xFF] + x;
seed->m_rsl[i + 2] = b;
x = seed->m_mem[i + 3];
a = ((a << 19) ^ (a >> 13)) + seed->m_mem[(i + 131) & 0xFF];
y = seed->m_mem[x & 0xFF] + b + a;
seed->m_mem[i + 3] = y;
b = seed->m_mem[(y >> 8) & 0xFF] + x;
seed->m_rsl[i + 3] = b;
}
seed->m_b = b;
seed->m_a = a;
}
// VERIFY: f330564e auto
// OFFSET: 0x007F6C10
static void SeedRandomValues(_RandomSeed* seed, int32_t value) {
seed->m_b = 0;
seed->m_a = 0;
int32_t x = value | 1;
for (uint32_t i = 0; i < 256; i++) {
x = 16807 * (x % 127773) - 2836 * (x / 127773);
if (x < 0) {
x += 0x7FFFFFFF;
}
seed->m_mem[i] = x;
}
GenerateRandomValues(seed);
seed->m_count = 256;
}
// VERIFY: c41f952f manual
// OFFSET: 0x007F6C70
void InitializeRandomSeed(_RandomSeed* seed, uint32_t value) {
if (value) {
srand(value);
} else {
srand(static_cast<uint32_t>(time(nullptr)));
}
SeedRandomValues(seed, rand());
}
// VERIFY: 78b9370d manual
// OFFSET: 0x007F6CC0
static double GetRandomFraction(_RandomSeed* seed) {
int32_t count = seed->m_count--;
uint32_t value;
if (count) {
value = seed->m_rsl[count - 1];
} else {
GenerateRandomValues(seed);
seed->m_count = 255;
value = seed->m_rsl[255];
}
return value * 2.3283064e-10f;
}
// VERIFY: c890b33b manual
// OFFSET: 0x007F6D10
uint32_t GetRandomValue(uint32_t max, _RandomSeed* seed) {
float value = static_cast<float>(GetRandomFraction(seed) * max);
uint32_t result = CMath::fint_(value - 0.5f);
return result < max - 1 ? result : max - 1;
}
+17
View File
@@ -0,0 +1,17 @@
#ifndef WOW_SOURCE_GAME_GAMECLIENT_RANDOMSEED_H
#define WOW_SOURCE_GAME_GAMECLIENT_RANDOMSEED_H
#include <cstdint>
struct _RandomSeed {
/* 0000 */ uint32_t m_mem[256];
/* 0400 */ uint32_t m_rsl[256];
/* 0800 */ uint32_t m_a;
/* 0804 */ uint32_t m_b;
/* 0808 */ int32_t m_count;
};
void InitializeRandomSeed(_RandomSeed* seed, uint32_t value);
uint32_t GetRandomValue(uint32_t max, _RandomSeed* seed);
#endif
+7 -1
View File
@@ -224,7 +224,7 @@ int32_t CGlueMgr::m_acceptedContest;
uint8_t CGlueMgr::m_authenticated;
// STATIC: 0x00B6AF79
uint8_t CGlueMgr::s_scriptFunctionsLoaded;
bool CGlueMgr::s_scriptFunctionsLoaded;
// STATIC: 0x00B6AF7C
int32_t CGlueMgr::m_screenWidth;
@@ -449,6 +449,12 @@ static void RequestLatestAgreements() {
}
}
// VERIFY: f4782413 auto
// OFFSET: 0x004D7880
bool CGlueMgr::AreScriptFunctionsLoaded() {
return CGlueMgr::s_scriptFunctionsLoaded;
}
// VERIFY: 60565de3 auto
// OFFSET: 0x004D7890
bool CGlueMgr::ServerAlertURLCallback(void* param, const char* data, uint32_t size, bool done, HTTPError::ErrorCode error) {
+2 -1
View File
@@ -80,7 +80,7 @@ class CGlueMgr {
static int32_t m_rereadContest;
static int32_t m_acceptedContest;
static uint8_t m_authenticated;
static uint8_t s_scriptFunctionsLoaded;
static bool s_scriptFunctionsLoaded;
static int32_t m_screenWidth;
static int32_t m_screenHeight;
static float m_aspect;
@@ -117,6 +117,7 @@ class CGlueMgr {
static void ChangeRealm(REALM_INFO* realm);
static void CreateCharacter(const CHARACTER_CREATE_INFO* info);
static void CustomizeCharacter(WOWGUID guid, const CHARACTER_CREATE_INFO* info);
static bool AreScriptFunctionsLoaded();
static bool DeclineCharacter(WOWGUID guid, const char** names);
static void DeleteCharacter(WOWGUID guid);
static void EnterWorld();
+101
View File
@@ -1 +1,102 @@
#include "Minigame_c.h"
#include <cstring>
#include <new>
#include "Engine/Source/Base/CDataStore.h"
#include "Engine/Source/lua-5.1/src/lua.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/Net/Types.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
// INLINED
CMinigame_C::CMinigame_C(MINIGAME_TYPE type, uint64_t guid) {
this->m_guid = guid;
this->m_type = type;
}
// INLINED
CMinigameTicTacToe_C::CMinigameTicTacToe_C(uint64_t guid) : CMinigame_C(MINIGAME_TICTACTOE, guid) {
this->m_guid = guid;
this->m_type = MINIGAME_TICTACTOE;
this->m_state = 0;
this->unk_0010 = 0;
this->unk_0018 = 0;
this->unk_0020 = 0;
this->unk_0021 = 0;
memset(this->m_board, 0, sizeof(this->m_board));
}
// VERIFY: 3cfba3e7 manual
// OFFSET: 0x00847C20
CMinigame_C* CMinigame_C::CreateMinigame(MINIGAME_TYPE type, uint64_t guid) {
if (type != MINIGAME_TICTACTOE) {
return nullptr;
}
void* memory = SMemAlloc(sizeof(CMinigameTicTacToe_C), __FILE__, __LINE__, 0);
return memory ? new (memory) CMinigameTicTacToe_C(guid) : nullptr;
}
// VERIFY: 34118bc1 auto
// OFFSET: 0x00847CA0
void CMinigame_C::UpdateSetup(CDataStore* msg) {
uint8_t state;
msg->Get(state);
this->m_state = state;
msg->Get(this->unk_0010);
msg->Get(this->unk_0018);
msg->GetData(this->m_board, sizeof(this->m_board));
if (this->m_state == 2) {
msg->Get(this->unk_0021);
}
}
// VERIFY: 287363f9 auto
// OFFSET: 0x00847D00
void CMinigameTicTacToe_C::UpdateState(CDataStore* msg) {
for (uint32_t i = 0; i < 9; i++) {
msg->Get(this->m_board[i]);
}
msg->Get(this->unk_0020);
}
// VERIFY: 289f88b4 auto
// OFFSET: 0x00847D40
bool CMinigameTicTacToe_C::ValidateMoveClient(uint8_t moveType, int32_t param) {
return CMinigameTicTacToe::ValidateMove(this, moveType, param);
}
// VERIFY: 05a92019 auto
// OFFSET: 0x00847D70
int32_t CMinigameTicTacToe_C::PushStateToLua(lua_State* L) {
lua_checkstack(L, 9);
for (uint32_t i = 0; i < 9; i++) {
lua_pushnumber(L, this->m_board[i]);
}
return 9;
}
// VERIFY: 0b7228bf manual
// OFFSET: 0x00847DC0
void CMinigame_C::MakeMove(uint8_t moveType, int32_t param) {
if (!this->ValidateMoveClient(moveType, param)) {
return;
}
CDataStore msg;
msg.Put(static_cast<uint32_t>(CMSG_MINIGAME_MOVE));
msg.Put(this->m_guid);
msg.Put(moveType);
msg.Put(static_cast<uint32_t>(param));
msg.Finalize();
ClientServices::Send2(&msg);
}
// VERIFY: b53c7de0 auto
// OFFSET: 0x00847E70
bool CMinigameTicTacToe::ValidateMove(MiniGameData* data, uint8_t moveType, int32_t param) {
return static_cast<uint32_t>(param) <= 9 && data->m_board[param] == 0xFF;
}
+41 -6
View File
@@ -4,13 +4,48 @@
#include <cstddef>
#include <cstdint>
class CMinigame_C {
class CDataStore;
struct lua_State;
enum MINIGAME_TYPE {
MINIGAME_NONE = 0,
MINIGAME_TICTACTOE = 1,
};
struct MiniGameData {
/* 0000 */ uint32_t m_type;
/* 0004 */ uint8_t m_state;
/* 0008 */ uint64_t m_guid;
/* 0010 */ uint64_t unk_0010;
/* 0018 */ uint64_t unk_0018;
/* 0020 */ uint8_t unk_0020;
/* 0021 */ uint8_t unk_0021;
/* 0022 */ uint8_t m_board[64];
};
class CMinigameTicTacToe {
public:
/* 0000 */ uint32_t unk_0000;
/* 0004 */ uint8_t unk_0004[8];
/* 000C */ uint32_t unk_000C;
/* 0010 */ uint32_t unk_0010;
/* 0014 */ uint32_t unk_0014;
static bool ValidateMove(MiniGameData* data, uint8_t moveType, int32_t param);
};
class CMinigame_C : public MiniGameData {
public:
static CMinigame_C* CreateMinigame(MINIGAME_TYPE type, uint64_t guid);
CMinigame_C(MINIGAME_TYPE type, uint64_t guid);
void UpdateSetup(CDataStore* msg);
void MakeMove(uint8_t moveType, int32_t param);
virtual void UpdateState(CDataStore* msg) = 0;
virtual bool ValidateMoveClient(uint8_t moveType, int32_t param) = 0;
virtual int32_t PushStateToLua(lua_State* L) = 0;
};
class CMinigameTicTacToe_C : public CMinigame_C {
public:
CMinigameTicTacToe_C(uint64_t guid);
virtual void UpdateState(CDataStore* msg);
virtual bool ValidateMoveClient(uint8_t moveType, int32_t param);
virtual int32_t PushStateToLua(lua_State* L);
};
#endif
+2 -2
View File
@@ -28,7 +28,7 @@ void DanceCache::Pack(CDataStore* msg) {
msg->Put(this->unk_0098);
}
// VERIFY: a4007070 manual
// VERIFY: 54057452 manual
// OFFSET: 0x0098D300
void DanceCache::Unpack(CDataStore* msg) {
msg->Get(reinterpret_cast<uint32_t&>(this->m_id));
@@ -40,7 +40,7 @@ void DanceCache::Unpack(CDataStore* msg) {
*msg >> static_cast<SmartGUID&>(this->m_guid);
msg->GetString(this->m_name, sizeof(this->m_name));
msg->Get(this->m_dataCount);
this->m_data = new (__FILE__, __LINE__) uint32_t[this->m_dataCount];
this->m_data = new (__FILE__, __LINE__) DANCEMOVE[this->m_dataCount];
msg->GetData(this->m_data, 4 * this->m_dataCount);
msg->Get(this->unk_0098);
}
+7 -1
View File
@@ -7,6 +7,12 @@
class CDataStore;
struct DANCEMOVE {
/* 0000 */ int16_t m_moveId;
/* 0002 */ uint8_t m_chance;
/* 0003 */ uint8_t m_type;
};
class DanceCache {
public:
static const uint32_t s_cacheVersion = 1;
@@ -15,7 +21,7 @@ class DanceCache {
/* 0004 */ uint32_t unk_0004;
/* 0008 */ WOWGUID m_guid;
/* 0010 */ char m_name[128];
/* 0090 */ uint32_t* m_data;
/* 0090 */ DANCEMOVE* m_data;
/* 0094 */ uint32_t m_dataCount;
/* 0098 */ uint32_t unk_0098;
/* 009C */ uint32_t unk_009C;
+196 -7
View File
@@ -9,10 +9,16 @@
#include "WoW/Source/Ui/TradeFrame.h"
#include "WoW/Source/WorldClient/FrameTime.h"
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "WoW/Source/Ui/Types.h"
#include <cstring>
// STATIC: 0x00CA0B7C
uint32_t s_clientStateIndex;
// STATIC: 0x00CA0B80
static TRADE_ITEM s_tradeItems[2][7];
// STATIC: 0x00CA0FE0
static int32_t s_unk_CA0FE0;
@@ -28,6 +34,24 @@ static int32_t s_tradeEnchantSpell[2];
// STATIC: 0x00CA0FF8
static uint32_t s_nextTradeRequestTime;
// VERIFY: 43528ed3 auto
// OFFSET: 0x00703C10
WOWGUID Trade_C_GetTradeTarget() {
return s_unk_CA0FE8;
}
// VERIFY: 522e8804 auto
// OFFSET: 0x00703C20
int32_t Trade_C_IsTradeRequested() {
return s_unk_CA0FE0;
}
// VERIFY: 714e84f5 auto
// OFFSET: 0x00703C30
int32_t Trade_C_UseCursorItem() {
return s_unk_CA0FE0 && s_unk_CA0FE4;
}
// VERIFY: 71c6ebe1 auto
// OFFSET: 0x00703C50
int32_t Trade_C_GetEnchantSpell(int32_t player) {
@@ -111,12 +135,12 @@ void Trade_C_PlayerIgnored() {
ClientServices::Send2(&msg);
}
// VERIFY: db33ff5b manual
// VERIFY: 6f4e5623 manual
// OFFSET: 0x00703F50
void Trade_C_AcceptTrade() {
CDataStore msg;
msg.Put(static_cast<uint32_t>(CMSG_ACCEPT_TRADE));
msg.Put(CGTradeInfo::m_playerTrade.unk_0000[2]);
msg.Put(CGTradeInfo::m_playerTrade.m_stateIndex[1]);
msg.Finalize();
ClientServices::Send2(&msg);
}
@@ -173,14 +197,14 @@ void Trade_C_RemoveItem(uint8_t tradeSlot) {
ClientServices::Send2(&msg);
}
// VERIFY: 9b901e66 manual
// VERIFY: d84bfa10 manual
// OFFSET: 0x00704220
bool CGTradeInfo::AddMoney(int32_t amount) {
if (!amount) {
return true;
}
uint32_t total = CGTradeInfo::m_playerTrade.m_money + amount;
uint32_t total = CGTradeInfo::m_playerTrade.m_money[0] + amount;
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (!player || player->GetCoinage() < total) {
@@ -192,12 +216,12 @@ bool CGTradeInfo::AddMoney(int32_t amount) {
msg.Put(total);
s_clientStateIndex++;
msg.Finalize();
CGTradeInfo::m_playerTrade.m_money = total;
CGTradeInfo::m_playerTrade.m_money[0] = total;
ClientServices::Send2(&msg);
return true;
}
// VERIFY: 01456882 manual
// VERIFY: 1c5417e1 manual
// OFFSET: 0x007043C0
bool CGTradeInfo::SetMoney(uint32_t amount) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
@@ -211,7 +235,7 @@ bool CGTradeInfo::SetMoney(uint32_t amount) {
msg.Put(amount);
s_clientStateIndex++;
msg.Finalize();
CGTradeInfo::m_playerTrade.m_money = amount;
CGTradeInfo::m_playerTrade.m_money[0] = amount;
ClientServices::Send2(&msg);
return true;
}
@@ -225,3 +249,168 @@ void Trade_C_Initialize() {
ClientServices::SetMessageHandler(SMSG_TRADE_STATUS, Packet_SMSG_TRADE_STATUS, nullptr);
ClientServices::SetMessageHandler(SMSG_TRADE_STATUS_EXTENDED, Packet_SMSG_TRADE_STATUS_EXTENDED, nullptr);
}
// VERIFY: 991b8783 manual
// OFFSET: 0x007044A0
int32_t Packet_SMSG_TRADE_STATUS(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint32_t status;
msg->Get(status);
int32_t reset = 0;
uint32_t bagResult = 0;
uint8_t target = 0;
uint32_t itemId = 0;
uint8_t slot = 0;
switch (status) {
case 0:
case 5:
case 6:
case 10:
case 11:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
reset = 1;
break;
case 1: {
uint64_t guid;
msg->Get(guid);
if (s_unk_CA0FE0) {
Trade_C_PlayerBusy();
} else {
s_unk_CA0FE8.m_guid = guid;
}
break;
}
case 2:
s_clientStateIndex = 1;
CGTradeInfo::m_playerTrade.m_stateIndex[0] = 1;
CGTradeInfo::m_playerTrade.m_stateIndex[1] = 1;
memset(s_tradeItems, 0, sizeof(s_tradeItems));
CGTradeInfo::m_playerTrade.m_money[0] = 0;
CGTradeInfo::m_playerTrade.m_money[1] = 0;
s_tradeEnchantSpell[0] = 0;
s_tradeEnchantSpell[1] = 0;
msg->Get(CGTradeInfo::m_playerTrade.m_tradeId);
break;
case 3:
case 13:
reset = 1;
memset(s_tradeItems, 0, sizeof(s_tradeItems));
CGTradeInfo::m_playerTrade.m_money[0] = 0;
CGTradeInfo::m_playerTrade.m_money[1] = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_MONEY, nullptr);
break;
case 12:
msg->Get(bagResult);
msg->Get(target);
msg->Get(itemId);
case 8:
reset = 1;
memset(s_tradeItems, 0, sizeof(s_tradeItems));
CGTradeInfo::m_playerTrade.m_money[0] = 0;
CGTradeInfo::m_playerTrade.m_money[1] = 0;
break;
case 22:
case 23:
msg->Get(slot);
if (slot == 0xFF) {
CGTradeInfo::m_playerTrade.m_money[0] = 0;
}
break;
}
CGTradeInfo::HandleTradeMessage(status, bagResult, target != 0, itemId, slot);
if (reset) {
s_unk_CA0FE0 = 0;
s_unk_CA0FE8 = WOWGUID();
}
return 1;
}
// VERIFY: 6a4a3506 manual
// OFFSET: 0x00704680
int32_t Packet_SMSG_TRADE_STATUS_EXTENDED(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint8_t side;
uint32_t tradeId;
uint32_t stateIndex;
msg->Get(side);
msg->Get(tradeId);
msg->Get(stateIndex);
if (tradeId != CGTradeInfo::m_playerTrade.m_tradeId) {
Trade_C_CancelTrade();
return 1;
}
if (!side && stateIndex < s_clientStateIndex) {
msg->m_read = msg->m_size;
return 1;
}
msg->Get(CGTradeInfo::m_playerTrade.m_stateIndex[side]);
msg->Get(CGTradeInfo::m_playerTrade.m_money[side]);
bool received[7] = {};
msg->Get(reinterpret_cast<uint32_t&>(s_tradeEnchantSpell[side]));
while (msg->m_read < msg->m_size) {
uint8_t slot;
TRADE_ITEM item;
msg->Get(slot);
msg->Get(reinterpret_cast<uint32_t&>(item.m_itemID));
msg->Get(reinterpret_cast<uint32_t&>(item.m_displayID));
msg->Get(reinterpret_cast<uint32_t&>(item.m_count));
msg->Get(reinterpret_cast<uint32_t&>(item.m_wrapped));
msg->Get(item.m_giftCreator.m_guid);
msg->Get(reinterpret_cast<uint32_t&>(item.m_enchant));
for (uint32_t i = 0; i < 3; i++) {
msg->Get(reinterpret_cast<uint32_t&>(item.m_socketEnchants[i]));
}
msg->Get(item.m_creator.m_guid);
msg->Get(reinterpret_cast<uint32_t&>(item.m_spellCharges));
msg->Get(reinterpret_cast<uint32_t&>(item.m_suffixFactor));
msg->Get(reinterpret_cast<uint32_t&>(item.m_randomPropertyID));
msg->Get(reinterpret_cast<uint32_t&>(item.m_lockID));
msg->Get(reinterpret_cast<uint32_t&>(item.m_maxDurability));
msg->Get(reinterpret_cast<uint32_t&>(item.m_durability));
if (!side && s_tradeItems[0][slot].m_itemID && !item.m_itemID) {
CGTradeInfo::DenyPlayerItem(slot);
}
s_tradeItems[side][slot] = item;
received[slot] = true;
}
for (uint32_t i = 0; i < 7; i++) {
if (!received[i]) {
if (!side && s_tradeItems[0][i].m_itemID) {
CGTradeInfo::DenyPlayerItem(i);
}
memset(&s_tradeItems[side][i], 0, sizeof(TRADE_ITEM));
}
}
CGTradeInfo::OnTradeUpdated(s_tradeItems[1]);
return 1;
}
+3
View File
@@ -22,6 +22,9 @@ void Trade_C_UnacceptTrade();
void Trade_C_Initialize();
int32_t Trade_C_GetEnchantSpell(int32_t player);
WOWGUID Trade_C_GetTradeTarget();
int32_t Trade_C_IsTradeRequested();
int32_t Trade_C_UseCursorItem();
int32_t Packet_SMSG_TRADE_STATUS(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
int32_t Packet_SMSG_TRADE_STATUS_EXTENDED(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
@@ -1531,7 +1531,7 @@ static int32_t ObjectUpdateSecondPass(CDataStore* msg, uint32_t time, uint32_t c
return 1;
}
// VERIFY: 6d778ab3 manual
// VERIFY: 3bda6338 manual
// OFFSET: 0x004D7230
static void UpdateOutOfRangeObjects(CDataStore* msg) {
uint32_t count;
@@ -1557,7 +1557,7 @@ static void UpdateOutOfRangeObjects(CDataStore* msg) {
if (CGBattlefieldInfo::m_instanceType == 4) {
WOWGUID objectGuid = object->m_obj->m_guid;
CGBattlefieldInfo::AddArenaOpponent(objectGuid);
CGBattlefieldInfo::OnArenaUnitOutOfRange(objectGuid);
}
object->HandleOutOfRange(static_cast<OUT_OF_RANGE_TYPE>(0));
-3
View File
@@ -45,7 +45,4 @@ class CGBarberShop {
static void UnregisterScriptFunctions();
};
int32_t Script_GetHairCustomization(lua_State* L);
int32_t Script_GetFacialHairCustomization(lua_State* L);
#endif
+14
View File
@@ -112,6 +112,20 @@ static int32_t Script_SetNextBarberShopStyle(lua_State* L) {
return 0;
}
// VERIFY: 270ee40e auto
// OFFSET: 0x0052E9B0
static int32_t Script_GetHairCustomization(lua_State* L) {
lua_pushstring(L, CGPlayer_C::GetHairCustomizationName());
return 1;
}
// VERIFY: eceedfeb auto
// OFFSET: 0x0052E9D0
static int32_t Script_GetFacialHairCustomization(lua_State* L) {
lua_pushstring(L, CGPlayer_C::GetFacialHairCustomizationName());
return 1;
}
// STATIC: 0x00ACC790
static FrameScript_Method s_ScriptFunctions[] = {
{ "GetBarberShopStyleInfo", &Script_GetBarberShopStyleInfo },
+51
View File
@@ -273,6 +273,18 @@ static void ReleaseBattlefieldNameCacheRef(int32_t id, const WOWGUID& guid, void
}
}
// VERIFY: 8a2636c7 manual
// OFFSET: 0x0054E330
void CGBattlefieldInfo::LeaveWorld() {
if (!CGGameUI::m_currentlyReloadingUI) {
memset(CGBattlefieldInfo::m_vehicleGuids, 0, sizeof(CGBattlefieldInfo::m_vehicleGuids));
CGBattlefieldInfo::m_numVehicles = 0;
}
CGBattlefieldInfo::m_instances.Clear();
CGBattlefieldInfo::m_instanceType = 0;
}
// VERIFY: cf91ab36 manual
// OFFSET: 0x0054CA50
void CGBattlefieldInfo::EnterWorld() {
@@ -1504,6 +1516,45 @@ void CGBattlefieldInfo::AddVehicle(const WOWGUID& guid) {
CGBattlefieldInfo::m_numVehicles++;
}
// VERIFY: d69a70d5 manual
// OFFSET: 0x0054ABF0
void CGBattlefieldInfo::OnArenaUnitOutOfRange(const WOWGUID& guid) {
char token[32];
for (uint32_t i = 0; i < 5; i++) {
const WOWGUID& opponent = CGBattlefieldInfo::m_arenaOpponents[i];
if (opponent == guid) {
SStrPrintf(token, sizeof(token), "arena%d", i + 1);
FrameScript_SignalEvent(SCRIPT_EVENT_ARENA_OPPONENT_UPDATE, "%s%s", token, "unseen");
return;
}
if (opponent) {
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(opponent, TYPEMASK_UNIT, __FILE__, __LINE__));
if (unit) {
CGUnitData* data = unit->m_unit;
const WOWGUID& pet = data->m_unitFieldCharm ? data->m_unitFieldCharm : data->m_unitFieldSummon;
if (pet == guid) {
SStrPrintf(token, sizeof(token), "arenapet%d", i + 1);
FrameScript_SignalEvent(SCRIPT_EVENT_ARENA_OPPONENT_UPDATE, "%s%s", token, "unseen");
return;
}
}
}
}
for (uint32_t i = 0; i < 5; i++) {
if (CGBattlefieldInfo::m_arenaOpponentPets[i][0] == guid) {
SStrPrintf(token, sizeof(token), "arenapet%d", i + 1);
FrameScript_SignalEvent(SCRIPT_EVENT_ARENA_OPPONENT_UPDATE, "%s%s", token, "unseen");
return;
}
}
}
// STATIC: 0x00ACD310
static const char* s_flagTokens[2] = { "AllianceFlag", "HordeFlag" };
+2
View File
@@ -86,6 +86,7 @@ class CGBattlefieldInfo {
static void RequestBattlegroundInstanceInfo(uint32_t index);
static void SetBattlemaster(WOWGUID battlemaster);
static void EnterWorld();
static void LeaveWorld();
static void InitializeGame();
static void ShutdownGame();
static WOWGUID m_arenaOpponentPets[5][2];
@@ -143,6 +144,7 @@ class CGBattlefieldInfo {
static TSGrowableArray<int32_t> m_battlegroundTypes;
static void AddArenaOpponent(const WOWGUID& guid);
static void OnArenaUnitOutOfRange(const WOWGUID& guid);
static void OnArenaUnitDestroyed(const WOWGUID& guid);
static int32_t GetBattlegroundType(int32_t index);
static bool GetBracketForLevel(uint32_t level, const BattlemasterListRec* rec, int32_t* bracket);
+71
View File
@@ -1 +1,72 @@
#include "CAccountMsgBody.h"
#include "Engine/Source/Base/DynamicString.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "WoW/Source/Glue/CGlueMgr.h"
#include "WoW/Source/Glue/Types.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
#include "_Triage/SHA1.h"
// STATIC: 0x00BEA7B0
CAccountMsgBody g_accountMsgBody;
// VERIFY: f292b33b manual
// OFFSET: 0x0054FB10
CAccountMsgBody::~CAccountMsgBody() {
}
// VERIFY: 8fed53e6 auto
// OFFSET: 0x0054FC50
int32_t CAccountMsgBody::LoadBody(int32_t messageId) {
if (this->m_state == 1 || this->m_inQueue) {
return 0;
}
char accountName[1280];
accountName[0] = '\0';
SStrCopy(accountName, ClientServices::GetAccountName(), sizeof(accountName));
uint8_t* sessionKey = ClientServices::Connection()->GetSessionKey();
SHA1_CONTEXT context;
uint8_t digest[20];
SHA1_Init(&context);
SHA1_Update(&context, sessionKey, 40);
SHA1_Update(&context, reinterpret_cast<const uint8_t*>("\x0Bz"), 2);
SHA1_Final(digest, &context);
CDynamicString url;
url.SetCapacity(1024);
url = FrameScript_GetText("ACCOUNT_MESSAGE_BODY_NO_READ_URL", -1, GENDER_NOT_APPLICABLE);
url += "?accountName=";
url += accountName;
url += "&sessionKeyHash=";
for (int32_t i = 0; i < 20; i++) {
url += static_cast<int32_t>(digest[i]);
}
url += "&messageId=";
url += messageId;
if (!OsURLDownload(url.m_buffer, &CKBPage::LoadingCallback, this)) {
this->m_state = 3;
return 0;
}
this->m_iterator.m_node = nullptr;
this->_BeginLoading();
return 1;
}
// VERIFY: 2087b348 auto
// OFFSET: 0x0054FDB0
void CAccountMsgBody::_SendSuccessEvent() {
if (CGlueMgr::AreScriptFunctionsLoaded()) {
FrameScript_SignalEvent(GLUE_EVENT_ACCOUNT_MESSAGES_BODY_LOADED, nullptr);
}
}
// VERIFY: bc4f5626 auto
// OFFSET: 0x0054FDD0
void CAccountMsgBody::_SendFailureEvent() {
this->m_iterator.m_node = nullptr;
}
+10 -6
View File
@@ -3,14 +3,18 @@
#include <cstddef>
#include <cstdint>
#include "WoW/Source/Ui/KnowledgeBase.h"
class CAccountMsgBody {
class CAccountMsgBody : public CKBPage {
public:
/* 0000 */ uint8_t unk_0000[4];
/* 0004 */ uint32_t unk_0004;
/* 0008 */ uint8_t unk_0008[52];
/* 003C */ uint32_t unk_003C;
/* 0040 */ uint32_t unk_0040;
/* 0040 */ CKBIterator m_iterator;
virtual ~CAccountMsgBody();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
int32_t LoadBody(int32_t messageId);
};
extern CAccountMsgBody g_accountMsgBody;
#endif
+236
View File
@@ -1 +1,237 @@
#include "CAccountMsgHeaders.h"
#include "Engine/Source/Base/DynamicString.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "WoW/Source/Glue/CGlueMgr.h"
#include "WoW/Source/Glue/Types.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
#include "_Triage/SHA1.h"
// STATIC: 0x00BEA750
CAccountMsgHeaders g_accountMsgHeaders;
// VERIFY: 970fc24a auto
// OFFSET: 0x00427A90
static bool AccountMsgReadCallback(void* param, const char* data, uint32_t size, bool done, HTTPError::ErrorCode error) {
return false;
}
// VERIFY: dc5c5838 auto
// OFFSET: 0x0054FB40
void CAccountMsgHeaders::_SendFailureEvent() {
this->m_iterator.m_node = nullptr;
this->m_count = 0;
}
// VERIFY: da97ce32 manual
// OFFSET: 0x0054FB50
const char* CAccountMsgHeaders::GetHeaderSubject(int32_t index) {
if (this->m_state == 1 || index < 0 || index >= this->m_count) {
return nullptr;
}
this->m_iterator.GoTo(index);
CKBIterator subject = this->m_iterator;
subject.GoToChild("subject");
return this->_GetBodyString(subject.m_node);
}
// VERIFY: 40ef5b47 manual
// OFFSET: 0x0054FBB0
int32_t CAccountMsgHeaders::GetHeaderPriority(int32_t index) {
if (this->m_state == 1 || index < 0 || index >= this->m_count) {
return 0;
}
this->m_iterator.GoTo(index);
return this->_GetInt(this->m_iterator.m_node, "priority");
}
// VERIFY: 0b60f3e8 auto
// OFFSET: 0x0054FBF0
int32_t CAccountMsgHeaders::GetMessageId(int32_t index) {
if (this->m_state == 1 || index < 0 || index >= this->m_count) {
return 0;
}
if (!this->m_iterator.m_node) {
this->_GetRoot(this->m_iterator);
this->m_iterator.GoToFirstChild();
}
this->m_iterator.GoTo(index);
return this->_GetInt(this->m_iterator.m_node, "id");
}
// VERIFY: 2c3986b9 manual
// OFFSET: 0x005500D0
int32_t CAccountMsgHeaders::GetNumUnreadUrgentMsgs() {
int32_t count = 0;
for (int32_t i = 0; i < this->m_count; i++) {
if (!this->m_opened.m_data[i] && this->GetHeaderPriority(i) >= 3) {
count++;
}
}
return count;
}
// VERIFY: 4579967f manual
// OFFSET: 0x00550140
int32_t CAccountMsgHeaders::GetIndexHighestPriorityUnreadMsg() {
if (this->m_state == 1) {
return 0;
}
int32_t index = 0;
for (int32_t i = 0; i < this->m_count; i++) {
bool read = i >= 0 && i < this->m_count && this->m_opened.m_data[i];
if (!read && this->GetHeaderPriority(i) >= 3) {
index = i;
}
}
return index;
}
// VERIFY: 0b06d57d manual
// OFFSET: 0x005501C0
int32_t CAccountMsgHeaders::GetIndexNextUnreadMsg(int32_t index) {
if (this->m_state == 1) {
return -1;
}
for (int32_t i = 0; i < this->m_count; i++) {
bool read = i >= 0 && i < this->m_count && this->m_opened.m_data[i];
if (i > index && !read) {
return i;
}
}
return -1;
}
// VERIFY: d9ba6998 manual
// OFFSET: 0x00550210
int32_t CAccountMsgHeaders::SetMsgRead(int32_t index) {
int32_t messageId = this->GetMessageId(index);
char accountName[1280];
accountName[0] = '\0';
SStrCopy(accountName, ClientServices::GetAccountName(), sizeof(accountName));
uint8_t* sessionKey = ClientServices::Connection()->GetSessionKey();
SHA1_CONTEXT context;
uint8_t digest[20];
SHA1_Init(&context);
SHA1_Update(&context, sessionKey, 40);
SHA1_Update(&context, reinterpret_cast<const uint8_t*>("\x0Bz"), 2);
SHA1_Final(digest, &context);
CDynamicString url;
url.SetCapacity(1024);
url = FrameScript_GetText("ACCOUNT_MESSAGE_READ_URL", -1, GENDER_NOT_APPLICABLE);
url += "?accountName=";
url += accountName;
url += "&sessionKeyHash=";
for (int32_t i = 0; i < 20; i++) {
url += static_cast<int32_t>(digest[i]);
}
url += "&messageId=";
url += messageId;
if (!OsURLDownload(url.m_buffer, &AccountMsgReadCallback, nullptr)) {
return 0;
}
if (index >= 0 && index < this->m_count) {
this->m_opened.m_data[index] = 1;
}
return 1;
}
// VERIFY: 07228351 manual
// OFFSET: 0x00550650
CAccountMsgHeaders::~CAccountMsgHeaders() {
}
// VERIFY: 0dbdc78a auto
// OFFSET: 0x005506A0
int32_t CAccountMsgHeaders::LoadHeaders() {
if (this->m_state == 1 || this->m_inQueue) {
return 0;
}
char accountName[1280];
accountName[0] = '\0';
SStrCopy(accountName, ClientServices::GetAccountName(), sizeof(accountName));
uint8_t* sessionKey = ClientServices::Connection()->GetSessionKey();
SHA1_CONTEXT context;
uint8_t digest[20];
SHA1_Init(&context);
SHA1_Update(&context, sessionKey, 40);
SHA1_Update(&context, reinterpret_cast<const uint8_t*>("\x0Bz"), 2);
SHA1_Final(digest, &context);
CDynamicString url;
url.SetCapacity(1024);
url = FrameScript_GetText("ACCOUNT_MESSAGE_HEADERS_URL", -1, GENDER_NOT_APPLICABLE);
url += "?accountName=";
url += accountName;
url += "&sessionKeyHash=";
for (int32_t i = 0; i < 20; i++) {
url += static_cast<int32_t>(digest[i]);
}
if (!OsURLDownload(url.m_buffer, &CKBPage::LoadingCallback, this)) {
this->m_state = 3;
return 0;
}
this->m_iterator.m_node = nullptr;
this->m_count = 0;
this->m_opened.Clear();
this->_BeginLoading();
return 1;
}
// VERIFY: eea88f7b manual
// OFFSET: 0x00550810
void CAccountMsgHeaders::_SendSuccessEvent() {
if (!this->m_iterator.m_node) {
this->_GetRoot(this->m_iterator);
this->m_iterator.GoToFirstChild();
}
CKBIterator iterator = this->m_iterator;
this->m_count = 0;
iterator.GoToFirst();
while (iterator.m_node) {
this->m_count++;
iterator.GoToNext();
}
this->m_opened.SetCount(this->m_count);
iterator = this->m_iterator;
iterator.GoToFirst();
for (int32_t i = 0; i < this->m_count; i++) {
iterator.GoTo(i);
this->m_opened.m_data[i] = this->_GetInt(iterator.m_node, "opened");
}
if (CGlueMgr::AreScriptFunctionsLoaded()) {
FrameScript_SignalEvent(GLUE_EVENT_ACCOUNT_MESSAGES_HEADERS_LOADED, nullptr);
}
}
+20 -12
View File
@@ -3,22 +3,30 @@
#include <cstddef>
#include <cstdint>
#include "Engine/Source/Storm/H/stpl.h"
#include "WoW/Source/Ui/KnowledgeBase.h"
class CAccountMsgHeaders {
class CAccountMsgHeaders : public CKBPage {
public:
/* 0000 */ uint8_t unk_0000[4];
/* 0004 */ uint32_t unk_0004;
/* 0008 */ uint8_t unk_0008[52];
/* 003C */ uint32_t unk_003C;
/* 0040 */ uint32_t unk_0040;
/* 0044 */ uint32_t unk_0044;
/* 0048 */ uint32_t unk_0048;
/* 004C */ uint32_t unk_004C;
/* 0050 */ uint32_t unk_0050;
/* 0054 */ uint32_t unk_0054;
/* 0058 */ uint32_t unk_0058;
/* 0040 */ int32_t m_count;
/* 0044 */ CKBIterator m_iterator;
/* 004C */ TSGrowableArray<int32_t> m_opened;
virtual ~CAccountMsgHeaders();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
int32_t LoadHeaders();
const char* GetHeaderSubject(int32_t index);
int32_t GetHeaderPriority(int32_t index);
int32_t GetMessageId(int32_t index);
int32_t GetNumUnreadUrgentMsgs();
int32_t GetIndexHighestPriorityUnreadMsg();
int32_t GetIndexNextUnreadMsg(int32_t index);
int32_t SetMsgRead(int32_t index);
};
extern CAccountMsgHeaders g_accountMsgHeaders;
void AccountMsg_RegisterScriptFunctions();
void AccountMsg_UnregisterScriptFunctions();
+189 -11
View File
@@ -3,18 +3,196 @@
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameScript/FrameScript_Object.h"
#include "Engine/Source/lua-5.1/src/lua.h"
#include "Engine/Source/lua-5.1/src/lauxlib.h"
#include "WoW/Source/Ui/CAccountMsgBody.h"
int32_t Script_AccountMsg_LoadHeaders(lua_State* L);
int32_t Script_AccountMsg_GetNumTotalMsgs(lua_State* L);
int32_t Script_AccountMsg_GetNumUnreadMsgs(lua_State* L);
int32_t Script_AccountMsg_GetNumUnreadUrgentMsgs(lua_State* L);
int32_t Script_AccountMsg_GetIndexHighestPriorityUnreadMsg(lua_State* L);
int32_t Script_AccountMsg_GetIndexNextUnreadMsg(lua_State* L);
int32_t Script_AccountMsg_GetHeaderSubject(lua_State* L);
int32_t Script_AccountMsg_GetHeaderPriority(lua_State* L);
int32_t Script_AccountMsg_LoadBody(lua_State* L);
int32_t Script_AccountMsg_GetBody(lua_State* L);
int32_t Script_AccountMsg_SetMsgRead(lua_State* L);
// VERIFY: cd4edb0d auto
// OFFSET: 0x0054FDE0
static int32_t Script_AccountMsg_GetNumTotalMsgs(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetNumTotalMsgs() failed because the headers are not loaded");
}
lua_pushnumber(L, g_accountMsgHeaders.m_count);
return 1;
}
// VERIFY: 330f3fb3 manual
// OFFSET: 0x0054FE20
static int32_t Script_AccountMsg_GetHeaderSubject(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetHeaderSubject() failed because the headers are not loaded");
}
if (!lua_isnumber(L, 1)) {
luaL_error(L, "Usage: AccountMsg_GetHeaderSubject(number)");
}
double index = lua_tonumber(L, 1);
if (index < 0.0 || index >= g_accountMsgHeaders.m_count) {
luaL_error(L, "Usage: AccountMsg_GetHeaderSubject(number) failed because the number is out of range");
}
lua_pushstring(L, g_accountMsgHeaders.GetHeaderSubject(static_cast<int32_t>(index)));
return 1;
}
// VERIFY: 88802a6a manual
// OFFSET: 0x0054FEC0
static int32_t Script_AccountMsg_GetHeaderPriority(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetHeaderPriority() failed because the headers are not loaded");
}
if (!lua_isnumber(L, 1)) {
luaL_error(L, "Usage: AccountMsg_GetHeaderPriority(number)");
}
double index = lua_tonumber(L, 1);
if (index < 0.0 || index >= g_accountMsgHeaders.m_count) {
luaL_error(L, "Usage: AccountMsg_GetHeaderPriority(number) failed because the number is out of range");
}
lua_pushnumber(L, g_accountMsgHeaders.GetHeaderPriority(static_cast<int32_t>(index)));
return 1;
}
// VERIFY: b96bccdb manual
// OFFSET: 0x0054FF70
static int32_t Script_AccountMsg_LoadBody(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_LoadBody() failed because the headers are not loaded");
}
if (!lua_isnumber(L, 1)) {
luaL_error(L, "Usage: AccountMsg_LoadBody(number)");
}
double index = lua_tonumber(L, 1);
if (index < 0.0 || index >= g_accountMsgHeaders.m_count) {
luaL_error(L, "Usage: AccountMsg_LoadBody(number) failed because the number is out of range");
}
if (!g_accountMsgBody.LoadBody(g_accountMsgHeaders.GetMessageId(static_cast<int32_t>(index)))) {
luaL_error(L, "AccountMsg_LoadHeaders() failed");
}
return 0;
}
// VERIFY: c39284fd auto
// OFFSET: 0x00550020
static int32_t Script_AccountMsg_GetBody(lua_State* L) {
if (g_accountMsgBody.m_state != 2) {
luaL_error(L, "AccountMsg_GetBody() failed because the body was not loaded");
}
if (!g_accountMsgBody.m_iterator.m_node) {
g_accountMsgBody._GetRoot(g_accountMsgBody.m_iterator);
}
lua_pushstring(L, g_accountMsgBody._GetBodyString(g_accountMsgBody.m_iterator.m_node));
return 1;
}
// VERIFY: e5cebb94 auto
// OFFSET: 0x00550360
static int32_t Script_AccountMsg_GetNumUnreadMsgs(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetNumUnreadMsgs() failed because the headers are not loaded");
}
int32_t count = 0;
for (int32_t i = 0; i < g_accountMsgHeaders.m_count; i++) {
if (!g_accountMsgHeaders.m_opened.m_data[i]) {
count++;
}
}
lua_pushnumber(L, count);
return 1;
}
// VERIFY: 98c3b05b auto
// OFFSET: 0x005503E0
static int32_t Script_AccountMsg_GetNumUnreadUrgentMsgs(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetNumUnreadMsgs() failed because the headers are not loaded");
}
lua_pushnumber(L, g_accountMsgHeaders.GetNumUnreadUrgentMsgs());
return 1;
}
// VERIFY: 9a74e3c4 manual
// OFFSET: 0x00550430
static int32_t Script_AccountMsg_GetIndexHighestPriorityUnreadMsg(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetHeaderSubject() failed because the headers are not loaded");
}
int32_t index = g_accountMsgHeaders.GetIndexHighestPriorityUnreadMsg();
lua_pushnumber(L, index);
lua_pushnumber(L, g_accountMsgHeaders.GetHeaderPriority(index));
return 2;
}
// VERIFY: 672f6b27 manual
// OFFSET: 0x005504E0
static int32_t Script_AccountMsg_GetIndexNextUnreadMsg(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_GetHeaderSubject() failed because the headers are not loaded");
}
int32_t index = -1;
if (lua_isnumber(L, 1)) {
index = static_cast<int32_t>(lua_tonumber(L, 1));
}
int32_t next = g_accountMsgHeaders.GetIndexNextUnreadMsg(index);
lua_pushnumber(L, next);
lua_pushnumber(L, g_accountMsgHeaders.GetHeaderPriority(next));
return 2;
}
// VERIFY: d1327cbd auto
// OFFSET: 0x005505B0
static int32_t Script_AccountMsg_SetMsgRead(lua_State* L) {
if (g_accountMsgHeaders.m_state != 2) {
luaL_error(L, "AccountMsg_SetMsgRead() failed because the headers are not loaded");
}
if (!lua_isnumber(L, 1)) {
luaL_error(L, "Usage: AccountMsg_SetMsgRead(number)");
}
int32_t index = static_cast<int32_t>(lua_tonumber(L, 1));
if (index < 0 || index >= g_accountMsgHeaders.m_count) {
luaL_error(L, "Usage: AccountMsg_SetMsgRead(number) failed because the number is out of range");
}
if (!g_accountMsgHeaders.SetMsgRead(index)) {
luaL_error(L, "Usage: AccountMsg_SetMsgRead(number) failed due to an URL error");
}
return 0;
}
// VERIFY: e72580a8 auto
// OFFSET: 0x00550910
static int32_t Script_AccountMsg_LoadHeaders(lua_State* L) {
if (!g_accountMsgHeaders.LoadHeaders()) {
luaL_error(L, "AccountMsg_LoadHeaders() failed");
}
return 0;
}
// STATIC: 0x00ACD418
static FrameScript_Method s_scriptFunctions[] = {
+138
View File
@@ -6,6 +6,7 @@
#include "WoW/Source/WowServices/RealmConnection.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
#include "Engine/Source/lua-5.1/src/lua.h"
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
// STATIC: 0x00ACEB70
TSList<AUTOCOMPLETE_NAMENODE, TSGetLink<AUTOCOMPLETE_NAMENODE>> CGAutoCompleteName::m_list;
@@ -272,3 +273,140 @@ int32_t CGAutoCompleteName::RemoveFlagsFromAllNodes(uint32_t flags) {
return 1;
}
// VERIFY: 92a5fc59 manual
// OFFSET: 0x0057AED0
static AUTOCOMPLETE_NAMENODE* FindNodeByPresenceId(const uint32_t& presenceId) {
for (AUTOCOMPLETE_NAMENODE* node = CGAutoCompleteName::m_list.Head(); node; node = CGAutoCompleteName::m_list.Next(node)) {
if (node->m_presenceId && presenceId == static_cast<uint32_t>(node->m_guid.m_guid)) {
return node;
}
}
return nullptr;
}
// VERIFY: 8f504a74 manual
// OFFSET: 0x0057AF10
AUTOCOMPLETE_NAMENODE* CGAutoCompleteName::FindNodeByName(const char* name, bool characters, bool battlenet) {
for (AUTOCOMPLETE_NAMENODE* node = CGAutoCompleteName::m_list.Head(); node; node = CGAutoCompleteName::m_list.Next(node)) {
if (SStrCmpUTF8I(name, node->m_name, STORM_MAX_STR)) {
continue;
}
if (node->m_presenceId) {
if (battlenet) {
return node;
}
} else if (characters) {
return node;
}
}
return nullptr;
}
// VERIFY: e746300b auto
// OFFSET: 0x0057AFC0
int32_t CGAutoCompleteName::SetName(const uint32_t& presenceId, const char* name, bool overwrite) {
AUTOCOMPLETE_NAMENODE* node = FindNodeByPresenceId(presenceId);
if (!node) {
return 0;
}
if (node->m_name[0] && !overwrite) {
return 0;
}
SStrCopy(node->m_name, name, 305);
return 1;
}
// VERIFY: fcee10bc auto
// OFFSET: 0x0057B040
int32_t CGAutoCompleteName::RemoveFlags(const uint32_t& presenceId, uint32_t flags) {
AUTOCOMPLETE_NAMENODE* node = FindNodeByPresenceId(presenceId);
if (node) {
node->m_flags &= ~flags;
if (!(node->m_flags & ~0x20)) {
CGAutoCompleteName::m_list.DeleteNode(node);
}
}
return 1;
}
// VERIFY: a6f29eb9 auto
// OFFSET: 0x0057B080
int32_t CGAutoCompleteName::RemoveFlagsByName(const char* name, uint32_t flags, bool characters, bool battlenet) {
AUTOCOMPLETE_NAMENODE* node = CGAutoCompleteName::FindNodeByName(name, characters, battlenet);
if (node) {
node->m_flags &= ~flags;
if (!(node->m_flags & ~0x20) && CGAutoCompleteName::s_useContext) {
CGAutoCompleteName::m_list.DeleteNode(node);
}
}
return 1;
}
// VERIFY: 511f942a auto
// OFFSET: 0x0057B580
static void AutoCompleteNameQueryCallback(int32_t id, const WOWGUID& guid, void* param, bool success) {
WOWGUID none = WOWGUID();
const char* name = reinterpret_cast<const char*>(g_nameDBCache.GetRecord(guid.m_guid, none, nullptr, nullptr, false));
if (!name) {
return;
}
AUTOCOMPLETE_NAMENODE* node = FindNodeByGuid(guid);
if (node) {
SStrCopy(node->m_name, name, 305);
}
}
// VERIFY: a0c16f63 auto
// OFFSET: 0x0057B5E0
void CGAutoCompleteName::RefreshName(const WOWGUID& guid) {
const char* name = reinterpret_cast<const char*>(g_nameDBCache.GetRecord(guid.m_guid, guid, AutoCompleteNameQueryCallback, nullptr, false));
if (!name) {
return;
}
AUTOCOMPLETE_NAMENODE* node = FindNodeByGuid(guid);
if (node) {
SStrCopy(node->m_name, name, 305);
}
}
// VERIFY: 2cdda694 manual
// OFFSET: 0x0057B730
AUTOCOMPLETE_NAMENODE* CGAutoCompleteName::AddPlayerToList(const uint32_t& presenceId, uint32_t flags, uint32_t lastUsed, const char* name) {
AUTOCOMPLETE_NAMENODE* node = new (SMemAlloc(sizeof(AUTOCOMPLETE_NAMENODE), typeid(AUTOCOMPLETE_NAMENODE).raw_name(), -2, 0x8)) AUTOCOMPLETE_NAMENODE;
node->m_presenceId = 1;
*reinterpret_cast<uint32_t*>(&node->m_guid) = presenceId;
if (name) {
SStrCopy(node->m_name, name, 305);
} else {
node->m_name[0] = '\0';
}
if (node->m_lastUsed != lastUsed) {
node->m_lastUsed = lastUsed;
SortNameNode(node);
}
node->m_flags = flags | 0x8;
SortNameNode(node);
return node;
}
+6 -1
View File
@@ -20,7 +20,7 @@ class CGAutoCompleteName {
static int32_t RemoveFlagsFromAllNodes(uint32_t flags);
static TSList<AUTOCOMPLETE_NAMENODE, TSGetLink<AUTOCOMPLETE_NAMENODE>> m_list;
static bool s_resortNamesOnRecency;
static void RemoveFlagsByName(const char* name, uint32_t flags, int32_t a3, int32_t a4);
static int32_t RemoveFlagsByName(const char* name, uint32_t flags, bool characters, bool battlenet);
static bool s_whenEditingFromCenter;
static bool s_useContext;
@@ -28,6 +28,11 @@ class CGAutoCompleteName {
static int32_t GetPresenceID(const char* name, uint32_t* presenceId);
static void AddFlags(const WOWGUID& guid, uint32_t flags, int32_t add, const char* name);
static int32_t RemoveFlags(const WOWGUID& guid, uint32_t flags);
static int32_t RemoveFlags(const uint32_t& presenceId, uint32_t flags);
static int32_t SetName(const uint32_t& presenceId, const char* name, bool overwrite);
static AUTOCOMPLETE_NAMENODE* FindNodeByName(const char* name, bool characters, bool battlenet);
static AUTOCOMPLETE_NAMENODE* AddPlayerToList(const uint32_t& presenceId, uint32_t flags, uint32_t lastUsed, const char* name);
static void RefreshName(const WOWGUID& guid);
static int32_t SetName(const WOWGUID& guid, const char* name, bool overwrite);
static int32_t NodeMatchesParams(AUTOCOMPLETE_NAMENODE* node, const char* text, uint32_t include, uint32_t exclude, int32_t cursor, bool allowFullMatch);
static int32_t GetMatchingResults(lua_State* L, const char* text, uint32_t include, uint32_t exclude, int32_t numReturns, int32_t cursor, bool allowFullMatch);
+47
View File
@@ -1,6 +1,13 @@
#include "CGMinigameInfo.h"
#include "Engine/Source/Base/CDataStore.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "WoW/Source/Minigame/Minigame_c.h"
#include "WoW/Source/Ui/Types.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
// STATIC: 0x00C20FEC
CMinigame_C* CGMinigameInfo::m_minigame;
// VERIFY: 7481e654 auto
// OFFSET: 0x005C5720
void CGMinigameInfo::InitializeGame() {
@@ -14,3 +21,43 @@ void CGMinigameInfo::ShutdownGame() {
ClientServices::ClearMessageHandler(SMSG_MINIGAME_SETUP);
ClientServices::ClearMessageHandler(SMSG_MINIGAME_STATE);
}
// VERIFY: f115ee6d auto
// OFFSET: 0x005C54D0
int32_t Packet_SMSG_MINIGAME_STATE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
if (CGMinigameInfo::m_minigame) {
CGMinigameInfo::m_minigame->UpdateState(msg);
}
FrameScript_SignalEvent(SCRIPT_EVENT_MINIGAME_UPDATE, nullptr);
return 1;
}
// VERIFY: b1ed2177 auto
// OFFSET: 0x005C5660
void CGMinigameInfo::LeaveWorld() {
if (CGMinigameInfo::m_minigame) {
delete CGMinigameInfo::m_minigame;
CGMinigameInfo::m_minigame = nullptr;
}
}
// VERIFY: 67e71a08 auto
// OFFSET: 0x005C5690
int32_t Packet_SMSG_MINIGAME_SETUP(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint64_t guid;
uint8_t type;
msg->Get(guid);
msg->Get(type);
if (CGMinigameInfo::m_minigame) {
delete CGMinigameInfo::m_minigame;
CGMinigameInfo::m_minigame = nullptr;
}
CGMinigameInfo::m_minigame = CMinigame_C::CreateMinigame(static_cast<MINIGAME_TYPE>(type), guid);
CGMinigameInfo::m_minigame->UpdateSetup(msg);
FrameScript_SignalEvent(SCRIPT_EVENT_START_MINIGAME, nullptr);
FrameScript_SignalEvent(SCRIPT_EVENT_MINIGAME_UPDATE, nullptr);
return 1;
}
+4 -3
View File
@@ -5,16 +5,17 @@
#include "WoW/Source/Net/Types.h"
struct lua_State;
class CMinigame_C;
class CGMinigameInfo {
public:
static CMinigame_C* m_minigame;
static void LeaveWorld();
static void ShutdownGame();
static void InitializeGame();
};
int32_t Script_GetMinigameType(lua_State* L);
int32_t Script_MakeMinigameMove(lua_State* L);
int32_t Script_GetMinigameState(lua_State* L);
void MinigameInfoRegisterScriptFunctions();
void MinigameInfoUnregisterScriptFunctions();
+44
View File
@@ -3,6 +3,50 @@
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameScript/FrameScript_Object.h"
#include "Engine/Source/lua-5.1/src/lua.h"
#include "Engine/Source/lua-5.1/src/lauxlib.h"
#include "WoW/Source/Minigame/Minigame_c.h"
// STATIC: 0x00AD05C8
static const char* s_minigameNames[] = { "TicTacToe", nullptr };
// VERIFY: fbfbc768 auto
// OFFSET: 0x005C5500
static int32_t Script_GetMinigameType(lua_State* L) {
CMinigame_C* minigame = CGMinigameInfo::m_minigame;
if (minigame && minigame->m_type - 1 <= 0) {
lua_pushstring(L, s_minigameNames[minigame->m_type]);
return 1;
}
lua_pushnil(L);
return 1;
}
// VERIFY: e1b0959d manual
// OFFSET: 0x005C5550
static int32_t Script_MakeMinigameMove(lua_State* L) {
if (!lua_isnumber(L, 1) || !lua_isnumber(L, 2)) {
luaL_error(L, "Usage: MakeMinigameMove(moveType, param)");
}
uint8_t moveType = static_cast<int32_t>(lua_tonumber(L, 1) - 1.0);
double param = lua_tonumber(L, 2);
if (CGMinigameInfo::m_minigame) {
CGMinigameInfo::m_minigame->MakeMove(moveType, static_cast<int32_t>(param - 1.0));
}
return 0;
}
// VERIFY: 9ea74c41 auto
// OFFSET: 0x005C55F0
static int32_t Script_GetMinigameState(lua_State* L) {
return CGMinigameInfo::m_minigame ? CGMinigameInfo::m_minigame->PushStateToLua(L) : 0;
}
// STATIC: 0x00AD05D0
static FrameScript_Method s_ScriptFunctions[] = {
{ "GetMinigameType", &Script_GetMinigameType },
+56
View File
@@ -1,4 +1,9 @@
#include "CKBArticle.h"
#include "Engine/Source/Base/DynamicString.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "WoW/Source/Client.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/Ui/Types.h"
// STATIC: 0x00ACD600
CKBArticle g_KnowledgeBaseArticle;
@@ -7,5 +12,56 @@ CKBArticle g_KnowledgeBaseArticle;
CKBArticle::CKBArticle() {
}
// VERIFY: 431409c4 auto
// OFFSET: 0x005EEB70
void CKBArticle::_ComputeCachedData() {
}
// VERIFY: ffc220ae auto
// OFFSET: 0x00551430
int32_t CKBArticle::BeginLoading(int32_t articleId, int32_t searchType) {
if (this->m_state == 1 || this->m_inQueue) {
return 0;
}
CDynamicString url;
url.SetCapacity(1024);
url += KnowledgeBaseGetURLForLocale();
url += "sendKBArticleQuery.xml";
url += "?articleId=";
url += articleId;
url += "&languageId=";
url += s_locale;
url += "&searchType=";
url += searchType;
url += "&locale=";
url += s_localeCode;
if (!OsURLDownload(url.m_buffer, &CKBPage::LoadingCallback, this)) {
this->m_state = 3;
this->_SendFailureEvent();
return 0;
}
this->m_state = 1;
this->m_loadingNext = CKBPage::s_pLoadingQueue_Head;
CKBPage::s_pLoadingQueue_Head = this;
this->m_inQueue = 1;
return 1;
}
// VERIFY: 224696f2 auto
// OFFSET: 0x00552340
void CKBArticle::_SendSuccessEvent() {
if (CGGameUI::m_initialized) {
FrameScript_SignalEvent(SCRIPT_EVENT_KNOWLEDGE_BASE_ARTICLE_LOAD_SUCCESS, nullptr);
}
}
// VERIFY: cd1f15d5 auto
// OFFSET: 0x00552360
void CKBArticle::_SendFailureEvent() {
if (CGGameUI::m_initialized) {
FrameScript_SignalEvent(SCRIPT_EVENT_KNOWLEDGE_BASE_ARTICLE_LOAD_FAILURE, nullptr);
}
}
+1
View File
@@ -8,6 +8,7 @@
class CKBArticle : public CKBPage {
public:
CKBArticle();
int32_t BeginLoading(int32_t articleId, int32_t searchType);
virtual void _ComputeCachedData();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
+99
View File
@@ -1 +1,100 @@
#include "CKBIterator.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "Engine/Source/Storm/H/storm.h"
// VERIFY: 23adeffb auto
// OFFSET: 0x005509A0
void CKBIterator::GoToFirst() {
if (!this->m_node) {
return;
}
XMLNode* parent = this->m_node->m_parent;
this->m_node = parent ? parent->m_child : nullptr;
this->m_index = 0;
}
// VERIFY: d6f21bed auto
// OFFSET: 0x005509D0
void CKBIterator::GoToNext() {
if (!this->m_node) {
return;
}
XMLNode* next = this->m_node->m_next;
this->m_index++;
this->m_node = next;
}
// VERIFY: b80e814a auto
// OFFSET: 0x005509E0
void CKBIterator::GoTo(int32_t index) {
XMLNode* node = this->m_node;
if (!node) {
return;
}
if (this->m_index == index - 1) {
this->m_index++;
this->m_node = node->m_next;
return;
}
if (this->m_index == index) {
return;
}
if (index < 0) {
this->m_node = nullptr;
this->m_index = 0;
return;
}
if (this->m_index > index) {
this->GoToFirst();
node = this->m_node;
}
while (this->m_index < index) {
if (!node) {
break;
}
node = node->m_next;
this->m_index++;
}
this->m_node = node;
}
// VERIFY: ca923db9 auto
// OFFSET: 0x00550A60
void CKBIterator::GoToFirstChild() {
if (!this->m_node) {
return;
}
this->m_node = this->m_node->m_child;
this->m_index = 0;
}
// VERIFY: acf9db7c auto
// OFFSET: 0x00552060
void CKBIterator::GoToChild(const char* name) {
if (!this->m_node) {
return;
}
XMLNode* child = this->m_node->m_child;
for (this->m_index = 0; child; this->m_index++) {
if (!SStrCmpI(child->m_name.m_str, name, STORM_MAX_STR)) {
break;
}
child = child->m_next;
}
this->m_node = child;
}
+10 -2
View File
@@ -4,10 +4,18 @@
#include <cstddef>
#include <cstdint>
class XMLNode;
class CKBIterator {
public:
/* 0000 */ uint32_t unk_0000;
/* 0004 */ uint32_t unk_0004;
/* 0000 */ XMLNode* m_node;
/* 0004 */ int32_t m_index;
void GoToFirst();
void GoToNext();
void GoTo(int32_t index);
void GoToFirstChild();
void GoToChild(const char* name);
};
#endif
+144 -3
View File
@@ -1,11 +1,152 @@
#include "CKBQuery.h"
#include "Engine/Source/Base/DynamicString.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "WoW/Source/Client.h"
#include "WoW/Source/Game/ValidateName.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/Ui/Types.h"
// STATIC: 0x00ACD5B0
CKBQuery g_KnowledgeBaseQuery;
// STATIC: 0x00ACD474
static char s_hexDigits[] = "0123456789ABCDEF";
// INLINED
CKBQuery::CKBQuery() {
this->unk_0040 = 0;
this->unk_0044 = 0;
this->unk_0048 = 0;
this->m_numArticleHeaders = 0;
this->m_articleHeaders.m_node = nullptr;
this->m_articleHeaders.m_index = 0;
}
// VERIFY: 6e2f7385 manual
// OFFSET: 0x00551250
XMLNode* CKBQuery::GetArticleHeader(int32_t index) {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
if (!this->m_articleHeaders.m_node) {
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* headers = root->GetChildByName("ArticleHeaders");
if (headers) {
this->m_articleHeaders.m_node = headers->m_child;
this->m_articleHeaders.m_index = 0;
}
}
}
this->m_articleHeaders.GoTo(index);
return this->m_articleHeaders.m_node;
}
// VERIFY: 01823e52 auto
// OFFSET: 0x00551350
void CKBQuery::_ComputeCachedData() {
XMLNode* node = XMLTree_GetRoot(this->m_tree);
if (node) {
node = node->GetChildByName("ArticleHeaders");
if (node) {
node = node->m_child;
this->m_articleHeaders.m_node = node;
this->m_articleHeaders.m_index = 0;
}
}
for (this->m_numArticleHeaders = 0; node; node = node->m_next) {
this->m_numArticleHeaders++;
}
}
// VERIFY: 28ed3119 manual
// OFFSET: 0x005513A0
void CKBQuery::_AppendMangledSearchQuery(CDynamicString& url, const char* query) {
for (uint8_t c = *query; c; c = *++query) {
if (IsAlphaEnglish(c) || IsNumeric(c)) {
url += *query;
} else {
url += '%';
url += s_hexDigits[c >> 4];
url += s_hexDigits[c & 0xF];
}
}
}
// VERIFY: e70fa306 auto
// OFFSET: 0x00552140
int32_t CKBQuery::BeginLoading(const char* query, int32_t categoryId, int32_t numArticles, int32_t pageNumber) {
if (this->m_state == 1 || this->m_inQueue) {
return 0;
}
if (!*query) {
query = nullptr;
}
CDynamicString url;
url.SetCapacity(1024);
url += KnowledgeBaseGetURLForLocale();
url += "sendKBQuery.xml";
url += '?';
if (query) {
url += "searchQuery=";
CKBQuery::_AppendMangledSearchQuery(url, query);
if (categoryId != -1) {
url += '&';
url += "categoryId=";
url += categoryId;
}
url += '&';
} else if (categoryId != -1) {
url += "categoryId=";
url += categoryId;
url += '&';
}
url += "languageId=";
url += s_locale;
url += "&numArticles=";
url += numArticles;
url += "&pageNumber=";
url += pageNumber;
url += "&locale=";
url += s_localeCode;
if (!OsURLDownload(url.m_buffer, &CKBPage::LoadingCallback, this)) {
this->m_state = 3;
this->_SendFailureEvent();
return 0;
}
this->m_articleHeaders.m_node = nullptr;
this->m_state = 1;
this->m_loadingNext = CKBPage::s_pLoadingQueue_Head;
CKBPage::s_pLoadingQueue_Head = this;
this->m_inQueue = 1;
return 1;
}
// VERIFY: 956da126 auto
// OFFSET: 0x00552300
void CKBQuery::_SendSuccessEvent() {
if (CGGameUI::m_initialized) {
FrameScript_SignalEvent(SCRIPT_EVENT_KNOWLEDGE_BASE_QUERY_LOAD_SUCCESS, nullptr);
}
}
// VERIFY: 7b9f8b96 auto
// OFFSET: 0x00552320
void CKBQuery::_SendFailureEvent() {
if (CGGameUI::m_initialized) {
FrameScript_SignalEvent(SCRIPT_EVENT_KNOWLEDGE_BASE_QUERY_LOAD_FAILURE, nullptr);
}
}
+6 -3
View File
@@ -7,11 +7,14 @@
class CKBQuery : public CKBPage {
public:
/* 0040 */ int32_t unk_0040;
/* 0044 */ uint32_t unk_0044;
/* 0048 */ uint32_t unk_0048;
/* 0040 */ int32_t m_numArticleHeaders;
/* 0044 */ CKBIterator m_articleHeaders;
static void _AppendMangledSearchQuery(CDynamicString& url, const char* query);
CKBQuery();
int32_t BeginLoading(const char* query, int32_t categoryId, int32_t numArticles, int32_t pageNumber);
XMLNode* GetArticleHeader(int32_t index);
virtual void _ComputeCachedData();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
+1 -1
View File
@@ -442,6 +442,6 @@ void CGChatBubbleFrame::OnWorldLayerUpdate() {
}
// VERIFY: 28f3deba manual
// OFFSET: 0x0098FFE0
// OFFSET: [0x0098FFE0, 0x0056CF50]
CGChatBubbleFrame::~CGChatBubbleFrame() {
}
+57
View File
@@ -53,6 +53,63 @@ void CGContainerInfo::EnterWorld() {
CGContainerInfo::UpdateContainers();
}
// VERIFY: 9a1d25a2 auto
// OFFSET: 0x005D7110
void CGContainerInfo::OpenContainer(WOWGUID guid) {
if (guid == ClntObjMgrGetActivePlayer()) {
FrameScript_SignalEvent(SCRIPT_EVENT_BAG_OPEN, "%d", 0);
return;
}
for (uint32_t i = 0; i < 11; i++) {
if (CGContainerInfo::m_containers[i] == guid) {
FrameScript_SignalEvent(SCRIPT_EVENT_BAG_OPEN, "%d", i + 1);
}
}
}
// VERIFY: bf060c1c manual
// OFFSET: 0x005D9D90
void CGContainerInfo::LeaveWorld() {
for (uint32_t i = 0; i < 11; i++) {
if (!CGContainerInfo::m_containers[i]) {
continue;
}
CGContainer_C* container = static_cast<CGContainer_C*>(ClntObjMgrObjectPtr(CGContainerInfo::m_containers[i], TYPEMASK_CONTAINER, __FILE__, __LINE__));
if (!container) {
continue;
}
int32_t count = container->GetBag()->m_numSlots;
for (int32_t j = 0; j < count; j++) {
ClntObjMgrUnsetObjMirrorHandler(CGContainerInfo::m_containers[i], ID_CONTAINER, offsetof(CGContainerData, m_containerFieldSlot1) + j * sizeof(WOWGUID), UpdateContainerContents, nullptr);
}
}
for (uint32_t offset = 0x378; offset <= 0x3F0; offset += sizeof(WOWGUID)) {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, offset, UpdateInvContents, nullptr);
}
for (uint32_t offset = 0x358; offset <= 0x370; offset += sizeof(WOWGUID)) {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, offset, InvUpdateHandler, nullptr);
}
for (uint32_t offset = 0x4D8; offset <= 0x508; offset += sizeof(WOWGUID)) {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, offset, InvUpdateHandler, nullptr);
}
for (uint32_t offset = 0x570; offset <= 0x668; offset += sizeof(WOWGUID)) {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, offset, UpdateInvContents, nullptr);
}
for (uint32_t offset = 0x670; offset <= 0x768; offset += sizeof(WOWGUID)) {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, offset, UpdateInvContents, nullptr);
}
}
// VERIFY: bf489b49 auto
// OFFSET: 0x005D6F10
void CGContainerInfo::UpdateCooldowns() {
+1
View File
@@ -14,6 +14,7 @@ class CGContainerInfo {
static void UpdateContainers();
static void OpenContainer(WOWGUID guid);
static void EnterWorld();
static void LeaveWorld();
static void UpdateCooldowns();
static void UpdateItem(WOWGUID guid);
static void UpdateContents(WOWGUID guid);
+190
View File
@@ -5,6 +5,13 @@
#include "WoW/Source/Object/ObjectClient/Player_C.h"
#include "Engine/Source/ConsoleBase/IConsole.h"
#include "WoW/Source/WowServices/WDataStore.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
#include "WoW/Source/DB/DBClient/DBClient.h"
#include "WoW/Source/DB/Rec/DanceMovesRec.h"
#include "WoW/Source/Object/DanceCache.h"
#include "WoW/Source/Object/Unit.h"
#include "WoW/Source/Object/ObjectClient/Unit_C.h"
// STATIC: 0x00BEB630
uint64_t CGDanceStudio::m_learnedDanceMoves;
@@ -38,6 +45,189 @@ void CGDanceStudio::ShutdownGame() {
s_knownDances.InternalClear(0);
}
// VERIFY: e4e19b6d manual
// OFFSET: 0x005757C0
static bool IsDanceMoveAvailable(const DanceMovesRec* move, uint8_t race) {
if (!move) {
return false;
}
if (move->m_racemask && !((1 << (race - 1)) & move->m_racemask)) {
return false;
}
return !move->m_lockID || (CGDanceStudio::m_learnedDanceMoves & (1ull << (move->m_lockID - 1)));
}
// VERIFY: 86f950dc auto
// OFFSET: 0x00575850
int32_t Packet_SMSG_STOP_DANCE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
WOWGUID guid;
msg->Get(guid.m_guid);
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(guid, TYPEMASK_PLAYER, __FILE__, __LINE__));
if (player) {
player->StopDance();
}
return 1;
}
// VERIFY: 6a163f90 manual
// OFFSET: 0x005758C0
void CGDanceStudio::PlayDance(DanceCache* record, DANCE_REQUEST* request) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(request->m_guid, TYPEMASK_PLAYER, __FILE__, __LINE__));
if (!player) {
return;
}
if (player->m_dance) {
ConsoleWrite("WARNING! Cannot start a new dance while one is in progress", ERROR_COLOR);
return;
}
PlayerDance* dance = new (SMemAlloc(sizeof(PlayerDance), __FILE__, __LINE__, 0)) PlayerDance;
dance->m_count = record->m_dataCount;
dance->m_moves = new (__FILE__, __LINE__) int16_t[dance->m_count];
int32_t count = 0;
for (uint32_t i = 0; i < static_cast<uint32_t>(dance->m_count); i++) {
if (i < record->m_dataCount && record->m_data[i].m_chance && GetRandomValue(100, &request->m_seed) >= record->m_data[i].m_chance) {
continue;
}
if (i < record->m_dataCount && record->m_data[i].m_type == 1) {
DanceMovesRec* move = g_danceMovesDB.GetRecord(record->m_data[i].m_moveId);
if (move) {
dance->m_moves[count] = move->m_fallback;
}
} else {
dance->m_moves[count] = i < record->m_dataCount ? record->m_data[i].m_moveId : 0;
}
count++;
}
dance->m_count = count;
dance->m_start = request->m_start;
player->StartDance(dance);
}
// VERIFY: 4f2df949 auto
// OFFSET: 0x00575A30
static void DanceSequenceCallBack(int32_t id, const WOWGUID& guid, void* param, bool success) {
DANCE_REQUEST* request = static_cast<DANCE_REQUEST*>(param);
if (success) {
WOWGUID none = WOWGUID();
DanceCache* record = g_danceCache.GetRecord(id, none, nullptr, nullptr, false);
if (ClntObjMgrObjectPtr(request->m_guid, TYPEMASK_PLAYER, __FILE__, __LINE__)) {
CGDanceStudio::PlayDance(record, request);
}
}
delete request;
}
// VERIFY: 73009a16 auto
// OFFSET: 0x00575AB0
int32_t Packet_SMSG_PLAY_DANCE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
WOWGUID guid;
int32_t danceId;
uint32_t start;
uint32_t seed;
uint32_t version;
msg->Get(guid.m_guid);
msg->Get(reinterpret_cast<uint32_t&>(danceId));
msg->Get(start);
msg->Get(seed);
msg->Get(version);
WOWGUID none = WOWGUID();
DanceCache* record = g_danceCache.GetRecord(danceId, none, nullptr, nullptr, false);
if (record && record->unk_0098 == version) {
DANCE_REQUEST request;
request.m_danceId = danceId;
InitializeRandomSeed(&request.m_seed, seed);
request.m_start = start;
request.m_guid = guid;
CGDanceStudio::PlayDance(record, &request);
return 1;
}
DANCE_REQUEST* request = new (SMemAlloc(sizeof(DANCE_REQUEST), __FILE__, __LINE__, 0)) DANCE_REQUEST;
request->m_danceId = danceId;
InitializeRandomSeed(&request->m_seed, seed);
request->m_start = start;
request->m_guid = guid;
g_danceCache.GetRecord(danceId, none, DanceSequenceCallBack, request, false);
return 1;
}
// VERIFY: 570db325 manual
// OFFSET: 0x00575BE0
void CGDanceStudio::DisplayDance(DanceCache* record) {
ConsoleWrite("Dance Loaded:", DEFAULT_COLOR);
CGUnit_C* player = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (!player) {
return;
}
for (uint32_t i = 0; i < record->m_dataCount; i++) {
int32_t id = *reinterpret_cast<const int32_t*>(&record->m_data[i]);
DanceMovesRec* move = g_danceMovesDB.GetRecord(id);
if (move) {
char text[64];
SStrPrintf(text, sizeof(text), "%d) Move: %s Chance: %d%%", i + 1, move->m_internalName, i < record->m_dataCount ? record->m_data[i].m_chance : 0);
COLOR_T color = DEFAULT_COLOR;
if (!IsDanceMoveAvailable(move, player->m_unit->m_unitFieldBytes0[0])) {
color = ERROR_COLOR;
}
ConsoleWrite(text, color);
} else {
char text[128];
SStrPrintf(text, sizeof(text), "Unknown dance move (ID: %u)!", id);
ConsoleWrite(text, DEFAULT_COLOR);
}
}
}
// VERIFY: 56a6eefa manual
// OFFSET: 0x00575D10
static void DanceSequenceLoadCallBack(int32_t id, const WOWGUID& guid, void* param, bool success) {
if (!success) {
ConsoleWrite("Dance no longer exists", ERROR_COLOR);
return;
}
WOWGUID none = WOWGUID();
DanceCache* record = g_danceCache.GetRecord(id, none, nullptr, nullptr, false);
if (record) {
CGDanceStudio::DisplayDance(record);
}
}
// VERIFY: cd5d45ea auto
// OFFSET: 0x00575D70
void CGDanceStudio::LoadDance(int32_t danceId) {
g_danceCache.Invalidate(danceId);
WOWGUID none = WOWGUID();
DanceCache* record = g_danceCache.GetRecord(danceId, none, DanceSequenceLoadCallBack, nullptr, false);
if (record) {
CGDanceStudio::DisplayDance(record);
}
}
// VERIFY: bdf23759 manual
// OFFSET: 0x00576100
void PlayDance(const char* name) {
+12
View File
@@ -5,8 +5,11 @@
#include <cstdint>
#include "WoW/Source/Net/Types.h"
#include "Engine/Source/Storm/H/stpl.h"
#include "WoW/Source/Game/GameClient/RandomSeed.h"
#include "WoW/Source/Object/WGUID.h"
class CDataStore;
class DanceCache;
struct lua_State;
struct KNOWNDANCES : public TSHashObject<KNOWNDANCES, HASHKEY_STRI> {
@@ -14,6 +17,13 @@ struct KNOWNDANCES : public TSHashObject<KNOWNDANCES, HASHKEY_STRI> {
/* 001C */ uint32_t unk_001C;
};
struct DANCE_REQUEST {
/* 0000 */ WOWGUID m_guid;
/* 0008 */ int32_t m_danceId;
/* 000C */ uint32_t m_start;
/* 0010 */ _RandomSeed m_seed;
};
int32_t Packet_SMSG_PLAY_DANCE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
int32_t Packet_SMSG_STOP_DANCE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
int32_t Packet_SMSG_NOTIFY_DANCE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
@@ -26,6 +36,8 @@ class CGDanceStudio {
static void InitializeGame();
static void ShutdownGame();
static void LoadDance(int32_t danceId);
static void PlayDance(DanceCache* record, DANCE_REQUEST* request);
static void DisplayDance(DanceCache* record);
static void RegisterScriptFunctions();
static void UnregisterScriptFunctions();
static bool HasDance(const char* name);
+120
View File
@@ -18,6 +18,7 @@
#include "WoW/Source/Ui/Types.h"
#include "WoW/Source/WowServices/WDataStore.h"
#include "WoW/Source/Object/Unit.h"
#include "WoW/Source/DB/DBClient/DBClient.h"
// STATIC: 0x00C1E95C
uint32_t* CGEquipmentManager::s_equipmentSetHeap;
@@ -390,6 +391,125 @@ int32_t CGEquipmentManager::SetContainsLockedItems(const EQUIPMENT_SET* set) {
return 0;
}
// VERIFY: 82f5bbb0 manual
// OFFSET: 0x005AE040
int32_t CGEquipmentManager::SetUsesLockedSlots(const EQUIPMENT_SET* set) {
if (!set) {
return 0;
}
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (!player) {
return 0;
}
for (int32_t slot = 0; slot <= 18; slot++) {
if (set->m_items[slot].m_guid == 1) {
continue;
}
CGItem_C* item = player->m_bag.GetItemPointer(slot);
if (item && (item->m_itemFlags & 0x1)) {
return 1;
}
}
return 0;
}
// VERIFY: c926fac3 manual
// OFFSET: 0x005AE660
void CGEquipmentManager::EquipSet(int32_t id) {
const EQUIPMENT_SET* set = CGEquipmentManager::GetSetByID(id);
if (set) {
FrameScript_SignalEvent(SCRIPT_EVENT_WEAR_EQUIPMENT_SET, "%s", set->m_name);
}
}
// VERIFY: 5bdd1316 manual
// OFFSET: 0x005AE6B0
void CGEquipmentManager::GetFullIconPath(int32_t id, char* buffer, uint32_t size) {
const EQUIPMENT_SET* set = CGEquipmentManager::GetSetByID(id);
if (!set) {
SStrPrintf(buffer, size, "");
return;
}
const char* path = ClientDBStringLookup(3);
const char* icon = set->m_icon;
if (!icon || !*icon) {
SStrPrintf(buffer, size, "");
return;
}
SStrPrintf(buffer, size, "%s%s%s", path, *path ? "\\" : "", icon);
}
// VERIFY: 7e1e9f40 manual
// OFFSET: 0x005AE760
static void OnEquipmentSetSaved(int32_t id, WOWGUID guid) {
EQUIPMENT_SET* set = const_cast<EQUIPMENT_SET*>(CGEquipmentManager::GetSetByID(id));
if (!set) {
return;
}
if (guid.m_guid) {
set->m_guid = guid;
set->unk_0230 = 0;
return;
}
for (EQUIPMENT_SET_NODE* node = CGEquipmentManager::s_equipmentSets.Head(); node; node = CGEquipmentManager::s_equipmentSets.Next(node)) {
if (node->m_set->m_id == id) {
CGEquipmentManager::s_equipmentSets.DeleteNode(node);
break;
}
}
ObjectFree(*CGEquipmentManager::s_equipmentSetHeap, set->m_handle);
}
// VERIFY: 591dc89b auto
// OFFSET: 0x005AF6C0
int32_t Packet_SMSG_EQUIPMENT_SET_SAVED(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
int32_t id = 0;
msg->Get(reinterpret_cast<uint32_t&>(id));
SmartGUID guid;
*msg >> guid;
OnEquipmentSetSaved(id, guid);
return 1;
}
// VERIFY: f8a867f0 manual
// OFFSET: 0x005AF710
int32_t Packet_SMSG_EQUIPMENT_SET_USE_RESULT(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
CGEquipmentManager::m_swapPending = 0;
uint8_t result = 0;
msg->Get(result);
if (result) {
const EQUIPMENT_SET* set = CGEquipmentManager::GetSetByID(CGEquipmentManager::m_pendingSetID);
FrameScript_SignalEvent(SCRIPT_EVENT_EQUIPMENT_SWAP_FINISHED, "%b%s", 0, set ? set->m_name : nullptr);
if (result == 4) {
FrameScript_SignalEvent(SCRIPT_EVENT_UI_ERROR_MESSAGE, "%s", FrameScript_GetText("EQUIPMENT_MANAGER_BAGS_FULL", -1, GENDER_NOT_APPLICABLE));
}
} else {
const EQUIPMENT_SET* set = CGEquipmentManager::GetSetByID(CGEquipmentManager::m_pendingSetID);
FrameScript_SignalEvent(SCRIPT_EVENT_EQUIPMENT_SWAP_FINISHED, "%b%s", 1, set ? set->m_name : nullptr);
}
CGActionBar::UpdateUsable();
CGEquipmentManager::m_pendingSetID = 0;
return 1;
}
// VERIFY: 12a136d2 manual
// OFFSET: 0x005ADA20
bool CGEquipmentManager::UseEquipmentSet(const EQUIPMENT_SET* set) {
+3
View File
@@ -17,6 +17,7 @@
#include "WoW/Source/SoundInterface/SoundInterface2.h"
class CGUnit_C;
class CGItem_C;
class AreaTableRec;
class CImVector;
class CDataStore;
@@ -498,6 +499,8 @@ struct TAINTEVENT : public TSHashObject<TAINTEVENT, HASHKEY_STR> {
void LoadScriptFunctions();
int32_t IsInFlyableArea();
int32_t CanEquipInSlotCallback(const CGItem_C* item, void* param);
int32_t FindItemClassTypeCallback(const CGItem_C* item, void* param);
void UnloadScriptFunctions();
void SavePlacedFrames(HOSFILE localFile, HOSFILE file, void* param);
void SaveGameCVarsCallback(HOSFILE localFile, HOSFILE file, void* param);
+4 -4
View File
@@ -4993,17 +4993,17 @@ static int32_t Script_IsUsableItem(lua_State* L) {
return 2;
}
// VERIFY: 2bf67451 auto
// VERIFY: 35e2d9c5 auto
// OFFSET: 0x005176F0
static int32_t CanEquipInSlotCallback(const CGItem_C* item, void* param) {
int32_t CanEquipInSlotCallback(const CGItem_C* item, void* param) {
WOWGUID none = WOWGUID();
ItemStats_C* stats = g_itemDBCache.GetRecord(item->m_obj->m_entryID, none, nullptr, nullptr, false);
return stats && static_cast<int32_t>(stats->m_inventoryType) == *static_cast<int32_t*>(param);
}
// VERIFY: c43ef09a auto
// VERIFY: 50448300 manual
// OFFSET: 0x00517740
static int32_t FindItemClassTypeCallback(const CGItem_C* item, void* param) {
int32_t FindItemClassTypeCallback(const CGItem_C* item, void* param) {
const char* type = static_cast<const char*>(param);
WOWGUID none = WOWGUID();
ItemStats_C* stats = g_itemDBCache.GetRecord(item->m_obj->m_entryID, none, nullptr, nullptr, false);
+27
View File
@@ -16,6 +16,7 @@
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
#include "WoW/Source/Ui/ChatFrame.h"
#include "WoW/Source/Net/Types.h"
#include "WoW/Source/Ui/MinimapFrame.h"
// STATIC: 0x00A12FD0
static const int32_t s_questGreenRange[20] = { 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
@@ -475,3 +476,29 @@ int32_t Packet_SMSG_GOSSIP_COMPLETE(void* param, NETMESSAGE msgId, uint32_t time
CGGossipInfo::SetGossip(WOWGUID());
return 1;
}
// VERIFY: 06b6b0c5 auto
// OFFSET: 0x0058A870
int32_t Packet_SMSG_GOSSIP_POI(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint32_t flags;
float x;
float y;
uint32_t icon;
uint32_t importance;
char name[64];
msg->Get(flags);
msg->Get(x);
msg->Get(y);
msg->Get(icon);
msg->Get(importance);
msg->GetString(name, sizeof(name));
MinimapSetDynamicPOI(1, flags, x, y, icon, importance, name);
return 1;
}
// VERIFY: f5f2eac6 auto
// OFFSET: 0x0058AB20
void CGGossipInfo::LeaveWorld() {
CGGossipInfo::SetGossip(WOWGUID{ 0 });
CGGossipInfo::ClearOptions();
}
+1
View File
@@ -44,6 +44,7 @@ class CGGossipInfo {
static char m_gossipText[2048];
static void InitializeGame();
static void ShutdownGame();
static void LeaveWorld();
static WOWGUID m_gossip;
static uint32_t m_gossipOptionsCount;
};
+271 -9
View File
@@ -1,27 +1,289 @@
#include "InstanceEncounter_C.h"
#include <cstdlib>
#include <cstring>
#include "Engine/Source/Base/CDataStore.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/Os/TimeManager.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/Ui/Types.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
// STATIC: 0x00C242FC
int32_t CGInstanceEncounter_C::m_units;
// STATIC: 0x00C242F8
TSFixedArray<ENCOUNTER_UNIT> CGInstanceEncounter_C::m_units;
// STATIC: 0x00C24300
InstanceEncounterUnit* CGInstanceEncounter_C::m_unitList;
// STATIC: 0x00AD14BC
TSList<ENCOUNTER_TIMER> CGInstanceEncounter_C::m_timers;
// VERIFY: 91f190f2 manual
// STATIC: 0x00AD14C8
TSList<ENCOUNTER_OBJECTIVE> CGInstanceEncounter_C::m_objectives;
// VERIFY: 4679293d manual
// OFFSET: 0x005ED590
bool ENCOUNTER_UNIT::operator<(const ENCOUNTER_UNIT& other) const {
if (!this->m_guid.m_guid) {
return false;
}
if (!other.m_guid.m_guid) {
return true;
}
if (this->m_priority == other.m_priority) {
return this->m_index - other.m_index < 0;
}
return this->m_priority - other.m_priority < 0;
}
// VERIFY: fe77e6c5 manual
// OFFSET: 0x005ED5F0
int32_t ENCOUNTER_UNIT::Compare(const void* a, const void* b) {
const ENCOUNTER_UNIT* unitA = static_cast<const ENCOUNTER_UNIT*>(a);
const ENCOUNTER_UNIT* unitB = static_cast<const ENCOUNTER_UNIT*>(b);
if (unitA->m_guid == unitB->m_guid) {
return 0;
}
return *unitA < *unitB ? -1 : 1;
}
// VERIFY: 7ae67001 manual
// OFFSET: 0x005ED6C0
static ENCOUNTER_UNIT* FindUnit(const WOWGUID& guid) {
for (uint32_t i = 0; i < CGInstanceEncounter_C::m_units.Count(); i++) {
if (CGInstanceEncounter_C::m_units.m_data[i].m_guid == guid) {
return &CGInstanceEncounter_C::m_units.m_data[i];
}
}
return nullptr;
}
// VERIFY: f07369c6 manual
// OFFSET: 0x005ED710
WOWGUID CGInstanceEncounter_C::GetBoss(uint32_t index) {
if (static_cast<int32_t>(index) < 0 || static_cast<int32_t>(index) >= CGInstanceEncounter_C::m_units) {
if (static_cast<int32_t>(index) < 0 || static_cast<int32_t>(index) >= static_cast<int32_t>(CGInstanceEncounter_C::m_units.Count())) {
return WOWGUID{ 0 };
}
return CGInstanceEncounter_C::m_unitList[index].m_guid;
return CGInstanceEncounter_C::m_units.m_data[index].m_guid;
}
// VERIFY: 3f43a707 auto
// VERIFY: 1908566c auto
// OFFSET: 0x005ED740
uint32_t CGInstanceEncounter_C::GetNumBossSlots() {
return CGInstanceEncounter_C::m_units;
return CGInstanceEncounter_C::m_units.Count();
}
// VERIFY: 3301311d auto
// OFFSET: 0x005ED750
static void SortUnits() {
if (!CGInstanceEncounter_C::m_units.Count()) {
return;
}
qsort(CGInstanceEncounter_C::m_units.m_data, CGInstanceEncounter_C::m_units.Count(), sizeof(ENCOUNTER_UNIT), ENCOUNTER_UNIT::Compare);
for (uint32_t i = 0; i < 16; i++) {
if (CGInstanceEncounter_C::m_units.m_data[i].m_guid.m_guid) {
CGInstanceEncounter_C::m_units.m_data[i].m_index = static_cast<uint8_t>(i);
}
}
}
// VERIFY: bb045bc2 manual
// OFFSET: 0x005ED7B0
void CGInstanceEncounter_C::EngageUnit(const WOWGUID& guid, uint8_t priority) {
if (FindUnit(guid)) {
return;
}
if (CGInstanceEncounter_C::m_units.Count() < 16) {
CGInstanceEncounter_C::m_units.SetCount(16);
memset(CGInstanceEncounter_C::m_units.m_data, 0, sizeof(ENCOUNTER_UNIT) * 16);
}
for (uint32_t i = 0; i < CGInstanceEncounter_C::m_units.Count(); i++) {
if (!CGInstanceEncounter_C::m_units.m_data[i].m_guid.m_guid) {
CGInstanceEncounter_C::m_units.m_data[i].m_guid = guid;
CGInstanceEncounter_C::m_units.m_data[i].m_priority = priority;
CGInstanceEncounter_C::m_units.m_data[i].m_index = static_cast<uint8_t>(i);
break;
}
}
SortUnits();
FrameScript_SignalEvent(SCRIPT_EVENT_INSTANCE_ENCOUNTER_ENGAGE_UNIT, nullptr);
}
// VERIFY: 5afd30df manual
// OFFSET: 0x005ED870
void CGInstanceEncounter_C::DisengageUnit(const WOWGUID& guid) {
if (!FindUnit(guid)) {
return;
}
for (uint32_t i = 0; i < CGInstanceEncounter_C::m_units.Count(); i++) {
if (CGInstanceEncounter_C::m_units.m_data[i].m_guid == guid) {
CGInstanceEncounter_C::m_units.m_data[i].m_guid = WOWGUID{ 0 };
CGInstanceEncounter_C::m_units.m_data[i].m_priority = 0;
CGInstanceEncounter_C::m_units.m_data[i].m_index = 0;
break;
}
}
SortUnits();
FrameScript_SignalEvent(SCRIPT_EVENT_INSTANCE_ENCOUNTER_ENGAGE_UNIT, nullptr);
if (!CGInstanceEncounter_C::m_units.m_data[0].m_guid.m_guid) {
CGInstanceEncounter_C::m_units.Clear();
}
}
// VERIFY: aa66d396 manual
// OFFSET: 0x005ED930
static void OnUnitMessage(int32_t type, WOWGUID guid, uint8_t priority) {
if (type == 0) {
CGInstanceEncounter_C::EngageUnit(guid, priority);
} else if (type == 1) {
CGInstanceEncounter_C::DisengageUnit(guid);
} else if (type == 2) {
ENCOUNTER_UNIT* unit = FindUnit(guid);
if (unit) {
unit->m_priority = priority;
SortUnits();
FrameScript_SignalEvent(SCRIPT_EVENT_INSTANCE_ENCOUNTER_ENGAGE_UNIT, nullptr);
}
}
}
// VERIFY: 02f49995 manual
// OFFSET: 0x005EDB10
void CGInstanceEncounter_C::LeaveWorld() {
if (CGGameUI::m_currentlyReloadingUI) {
return;
}
ClientServices::ClearMessageHandler(SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT);
CGInstanceEncounter_C::m_units.Clear();
CGInstanceEncounter_C::m_timers.Clear();
}
// VERIFY: 8b8e61cc manual
// OFFSET: 0x005EDB70
void CGInstanceEncounter_C::ClearExpiredTimers() {
if (!CGInstanceEncounter_C::m_timers.Head()) {
return;
}
uint32_t now = OsGetAsyncTimeMs();
ENCOUNTER_TIMER* timer = CGInstanceEncounter_C::m_timers.Head();
while (timer) {
if (static_cast<int32_t>(now - timer->m_expireTime) < 0) {
timer = CGInstanceEncounter_C::m_timers.Next(timer);
} else {
timer = CGInstanceEncounter_C::m_timers.DeleteNode(timer);
}
}
}
// VERIFY: ae200c3e manual
// OFFSET: 0x005EDBC0
void CGInstanceEncounter_C::AddTimer(uint32_t duration) {
CGInstanceEncounter_C::ClearExpiredTimers();
ENCOUNTER_TIMER* timer = CGInstanceEncounter_C::m_timers.NewNode(2, 0, 0);
timer->m_expireTime = duration + OsGetAsyncTimeMs();
}
// VERIFY: c595bb8c manual
// OFFSET: 0x005EDC50
void CGInstanceEncounter_C::EnableObjective(int32_t id) {
for (ENCOUNTER_OBJECTIVE* objective = CGInstanceEncounter_C::m_objectives.Head(); objective; objective = CGInstanceEncounter_C::m_objectives.Next(objective)) {
if (objective->m_id == id) {
return;
}
}
ENCOUNTER_OBJECTIVE* objective = CGInstanceEncounter_C::m_objectives.NewNode(2, 0, 0);
objective->m_id = static_cast<uint8_t>(id);
objective->m_progress = 0;
}
// VERIFY: 33b377b6 manual
// OFFSET: 0x005EDD10
static void UpdateObjective(int32_t id, int32_t delta) {
for (ENCOUNTER_OBJECTIVE* objective = CGInstanceEncounter_C::m_objectives.Head(); objective; objective = CGInstanceEncounter_C::m_objectives.Next(objective)) {
if (objective->m_id == id) {
objective->m_progress += delta;
return;
}
}
}
// VERIFY: c5e756d6 manual
// OFFSET: 0x005EDD50
void CGInstanceEncounter_C::DisableObjective(int32_t id) {
for (ENCOUNTER_OBJECTIVE* objective = CGInstanceEncounter_C::m_objectives.Head(); objective; objective = CGInstanceEncounter_C::m_objectives.Next(objective)) {
if (objective->m_id == id) {
CGInstanceEncounter_C::m_objectives.DeleteNode(objective);
return;
}
}
}
// VERIFY: a2968217 manual
// OFFSET: 0x005EDD90
static void OnObjectiveMessage(int32_t type, uint8_t value) {
if (type == 3) {
CGInstanceEncounter_C::AddTimer(value);
} else if (type == 4) {
CGInstanceEncounter_C::EnableObjective(value);
} else if (type == 6) {
CGInstanceEncounter_C::DisableObjective(value);
}
}
// VERIFY: f40341b3 manual
// OFFSET: 0x005EDDD0
int32_t Packet_SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint32_t type;
SmartGUID guid;
uint8_t value;
uint8_t delta;
msg->Get(type);
switch (type) {
case 0:
case 1:
case 2:
*msg >> guid;
msg->Get(value);
OnUnitMessage(type, guid, value);
break;
case 3:
case 4:
case 6:
msg->Get(value);
OnObjectiveMessage(type, value);
break;
case 5:
msg->Get(value);
msg->Get(delta);
UpdateObjective(value, delta);
break;
case 7:
SortUnits();
FrameScript_SignalEvent(SCRIPT_EVENT_INSTANCE_ENCOUNTER_ENGAGE_UNIT, nullptr);
break;
}
return 1;
}
// VERIFY: e1fb6f4f auto
+29 -4
View File
@@ -4,21 +4,46 @@
#include <cstdint>
#include "WoW/Source/Net/Types.h"
#include "WoW/Source/Object/WGUID.h"
#include "Engine/Source/Storm/H/stpl.h"
class CDataStore;
struct InstanceEncounterUnit {
struct ENCOUNTER_UNIT {
/* 0000 */ WOWGUID m_guid;
/* 0008 */ uint32_t unk_0008[2];
/* 0008 */ uint8_t m_priority;
/* 0009 */ uint8_t m_index;
/* 000A */ uint8_t unk_000A[6];
bool operator<(const ENCOUNTER_UNIT& other) const;
static int32_t Compare(const void* a, const void* b);
};
struct ENCOUNTER_TIMER : public TSLinkedNode<ENCOUNTER_TIMER> {
/* 0008 */ uint32_t unk_0008;
/* 000C */ uint32_t m_expireTime;
};
struct ENCOUNTER_OBJECTIVE : public TSLinkedNode<ENCOUNTER_OBJECTIVE> {
/* 0008 */ uint32_t unk_0008;
/* 000C */ uint8_t m_id;
/* 0010 */ int32_t m_progress;
};
class CGInstanceEncounter_C {
public:
static void EnterWorld();
static void LeaveWorld();
static WOWGUID GetBoss(uint32_t index);
static uint32_t GetNumBossSlots();
static int32_t m_units;
static InstanceEncounterUnit* m_unitList;
static void EngageUnit(const WOWGUID& guid, uint8_t priority);
static void DisengageUnit(const WOWGUID& guid);
static void ClearExpiredTimers();
static void AddTimer(uint32_t duration);
static void EnableObjective(int32_t id);
static void DisableObjective(int32_t id);
static TSFixedArray<ENCOUNTER_UNIT> m_units;
static TSList<ENCOUNTER_TIMER> m_timers;
static TSList<ENCOUNTER_OBJECTIVE> m_objectives;
};
int32_t Packet_SMSG_UPDATE_INSTANCE_ENCOUNTER_UNIT(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg);
+46
View File
@@ -240,3 +240,49 @@ bool CGItemSocketInfo::IsSocketItemRefundable() {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
return static_cast<int32_t>(purchase->m_refundTimeLeft + 7200 - player->GetPlayedTime()) > 0;
}
// VERIFY: 47e2ebf9 auto
// OFFSET: 0x005C4EE0
void CGItemSocketInfo::LeaveWorld() {
CGItemSocketInfo::SetItem(WOWGUID{ 0 });
}
// VERIFY: e9a41a83 auto
// OFFSET: 0x005C4EF0
void CGItemSocketInfo::UpdateItem(WOWGUID item) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (player) {
player->CountEquippedGems();
}
if (item == CGItemSocketInfo::m_socketItem) {
FrameScript_SignalEvent(SCRIPT_EVENT_SOCKET_INFO_UPDATE, nullptr);
}
}
// VERIFY: db24a767 manual
// OFFSET: 0x005C4F40
void CGItemSocketInfo::RemoveItem(WOWGUID item) {
if (item == CGItemSocketInfo::m_socketItem) {
CGItemSocketInfo::SetItem(WOWGUID{ 0 });
return;
}
for (uint32_t i = 0; i < 3; i++) {
if (item == CGItemSocketInfo::m_gemItems[i]) {
if (CGItemSocketInfo::m_socketItem.m_guid && CGItemSocketInfo::m_socketItemStats) {
CGItemSocketInfo::m_gemItems[i] = WOWGUID{ 0 };
FrameScript_SignalEvent(SCRIPT_EVENT_SOCKET_INFO_UPDATE, nullptr);
}
break;
}
}
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (player) {
player->CountEquippedGems();
}
}
+3
View File
@@ -26,6 +26,9 @@ class CGItemSocketInfo {
static bool IsSocketItemBoundTradeable();
static bool IsSocketItemRefundable();
static void SetItem(WOWGUID item);
static void LeaveWorld();
static void UpdateItem(WOWGUID item);
static void RemoveItem(WOWGUID item);
static int32_t GemMatchesSocket(const ItemStats_C* item, const ItemStats_C* gem, int32_t socket);
};
+6
View File
@@ -212,3 +212,9 @@ void CGItemText::ItemTextCallback(int32_t id, const WOWGUID& guid, void* param,
CGItemText::SetItem(guid, 1);
}
}
// VERIFY: d0e6f233 auto
// OFFSET: 0x0058A430
void CGItemText::LeaveWorld() {
CGItemText::SetItem(WOWGUID{ 0 }, 0);
}
+1
View File
@@ -12,6 +12,7 @@ class CGItemText {
public:
static void InitializeGame();
static void ShutdownGame();
static void LeaveWorld();
static WOWGUID m_itemGUID;
static uint32_t m_currentPage;
static uint8_t m_hasItemText;
+327 -21
View File
@@ -1,4 +1,5 @@
#include "KnowledgeBase.h"
#include <cstdlib>
#include "Engine/Source/Base/DynamicString.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "Engine/Source/Os/TimeManager.h"
@@ -17,7 +18,8 @@ CKBSetup g_KnowledgeBaseSetup;
// STATIC: 0x00BEA7F8
CKBPage* CKBPage::s_pLoadingQueue_Head;
// INLINED
// VERIFY: 17635375 auto
// OFFSET: 0x00550AE0
CKBPage::CKBPage() {
this->m_state = 0;
this->m_data = nullptr;
@@ -106,7 +108,7 @@ bool CKBPage::LoadingCallback(void* param, const char* data, uint32_t size, bool
return true;
}
// VERIFY: b649a859 auto
// VERIFY: ec9f19a2 auto
// OFFSET: 0x00550E10
int32_t CKBSetup::BeginLoading(int32_t numArticles, int32_t pageNumber) {
if (this->m_state == 1 || this->m_inQueue) {
@@ -132,11 +134,11 @@ int32_t CKBSetup::BeginLoading(int32_t numArticles, int32_t pageNumber) {
return 0;
}
this->unk_0050 = -1;
this->unk_0054 = 0;
this->unk_005C = 0;
this->unk_0064 = 0;
this->unk_006C = 0;
this->m_currentCategory = -1;
this->m_languages.m_node = nullptr;
this->m_categories.m_node = nullptr;
this->m_subCategories.m_node = nullptr;
this->m_articleHeaders.m_node = nullptr;
this->m_state = 1;
this->m_loadingNext = CKBPage::s_pLoadingQueue_Head;
CKBPage::s_pLoadingQueue_Head = this;
@@ -145,7 +147,7 @@ int32_t CKBSetup::BeginLoading(int32_t numArticles, int32_t pageNumber) {
}
// VERIFY: 772164f4 auto
// OFFSET: 0x005526D0
// OFFSET: [0x00550B10, 0x005526D0]
CKBPage::~CKBPage() {
if (this->m_tree) {
XMLTree_Free(this->m_tree);
@@ -159,30 +161,334 @@ CKBPage::~CKBPage() {
}
}
// VERIFY: 14b81430 auto
// OFFSET: 0x005EEB70
void CKBPage::_ComputeCachedData() {
}
// VERIFY: 8bb4a93d auto
// OFFSET: 0x00550B60
int32_t CKBPage::_BeginLoading() {
this->m_state = 1;
this->m_loadingNext = CKBPage::s_pLoadingQueue_Head;
CKBPage::s_pLoadingQueue_Head = this;
this->m_inQueue = 1;
return 1;
}
// VERIFY: de149e18 manual
// OFFSET: 0x00550D10
XMLNode* CKBPage::_GetRoot(CKBIterator& iterator) {
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
iterator.m_node = root;
iterator.m_index = 0;
}
return root;
}
// VERIFY: bb9406ad auto
// OFFSET: [0x00550D40, 0x00551010]
int32_t CKBPage::_GetInt(XMLNode* node, const char* attribute) const {
if (this->m_state != 2 || !this->m_tree || !node) {
return 0;
}
const char* value = node->GetAttributeByName(attribute);
return value ? atol(value) : 0;
}
// VERIFY: 24e29a0d auto
// OFFSET: 0x00550D80
const char* CKBPage::_GetBodyString(XMLNode* node) const {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
return node->m_body;
}
// VERIFY: c12a4731 auto
// OFFSET: 0x00550DA0
bool CKBPage::_GetBodyBool(const char* element, const char* child) const {
const char* body = this->_GetBodyString(element, child);
return body && !SStrCmpI(body, "true", STORM_MAX_STR);
}
// VERIFY: 9b5ccfb5 manual
// OFFSET: [0x005510B0, 0x005512B0]
bool CKBPage::_GetBool(XMLNode* node, const char* attribute) const {
if (this->m_state != 2 || !this->m_tree || !node) {
return false;
}
const char* value = node->GetAttributeByName(attribute);
return value && !SStrCmpI(value, "true", STORM_MAX_STR);
}
// VERIFY: d61059d6 manual
// OFFSET: 0x00551300
int32_t CKBPage::_GetInt(const char* element, const char* attribute) const {
if (this->m_state != 2 || !this->m_tree) {
return 0;
}
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (!root) {
return 0;
}
XMLNode* node = root->GetChildByName(element);
if (!node) {
return 0;
}
const char* value = node->GetAttributeByName(attribute);
return value ? atol(value) : 0;
}
// INLINED
const char* CKBPage::_GetBodyString(const char* element, const char* child) const {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (!root) {
return nullptr;
}
XMLNode* node = root->GetChildByName(element);
if (!node) {
return nullptr;
}
node = node->GetChildByName(child);
return node ? node->m_body : nullptr;
}
// VERIFY: 58d9c09c manual
// OFFSET: [0x00551550, 0x005515A0]
int32_t CKBPage::_GetBodyInt(const char* element, const char* child) const {
const char* body = this->_GetBodyString(element, child);
return body ? atol(body) : 0;
}
// VERIFY: 8c81adf5 manual
// OFFSET: 0x00550F50
XMLNode* CKBSetup::GetLanguage(int32_t index) {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
if (!this->m_languages.m_node) {
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* languages = root->GetChildByName("Languages");
if (languages) {
this->m_languages.m_node = languages->m_child;
this->m_languages.m_index = 0;
}
}
}
this->m_languages.GoTo(index);
return this->m_languages.m_node;
}
// VERIFY: 6baf22c5 manual
// OFFSET: 0x00550FB0
XMLNode* CKBSetup::GetCategoryNode(int32_t index) {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
if (!this->m_categories.m_node) {
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* categories = root->GetChildByName("Categories");
if (categories) {
this->m_categories.m_node = categories->m_child;
this->m_categories.m_index = 0;
}
}
}
this->m_categories.GoTo(index);
return this->m_categories.m_node;
}
// VERIFY: 80098012 manual
// OFFSET: 0x00551050
XMLNode* CKBSetup::GetArticleHeader(int32_t index) {
if (this->m_state != 2 || !this->m_tree) {
return nullptr;
}
if (!this->m_articleHeaders.m_node) {
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* headers = root->GetChildByName("ArticleHeaders");
if (headers) {
this->m_articleHeaders.m_node = headers->m_child;
this->m_articleHeaders.m_index = 0;
}
}
}
this->m_articleHeaders.GoTo(index);
return this->m_articleHeaders.m_node;
}
// VERIFY: 34a727b3 manual
// OFFSET: 0x00551100
void CKBSetup::_ComputeCachedData() {
XMLNode* node = nullptr;
XMLNode* root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* languages = root->GetChildByName("Languages");
if (languages) {
node = languages->m_child;
this->m_articleHeaders.m_node = node;
this->m_articleHeaders.m_index = 0;
}
}
for (this->m_numLanguages = 0; node; node = node->m_next) {
this->m_numLanguages++;
}
root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* categories = root->GetChildByName("Categories");
if (categories) {
node = categories->m_child;
this->m_articleHeaders.m_node = node;
this->m_articleHeaders.m_index = 0;
}
}
for (this->m_numCategories = 0; node; node = node->m_next) {
this->m_numCategories++;
}
this->m_numSubCategories = 0;
root = XMLTree_GetRoot(this->m_tree);
if (root) {
XMLNode* headers = root->GetChildByName("ArticleHeaders");
if (headers) {
node = headers->m_child;
this->m_articleHeaders.m_node = node;
this->m_articleHeaders.m_index = 0;
}
}
for (this->m_numArticleHeaders = 0; node; node = node->m_next) {
this->m_numArticleHeaders++;
}
}
// VERIFY: 63e48dff auto
// OFFSET: 0x005511E0
void CKBSetup::GetCategory(int32_t category) {
this->m_subCategories.m_node = nullptr;
this->m_subCategories.m_index = 0;
this->m_numSubCategories = 0;
this->m_currentCategory = -1;
XMLNode* node = this->GetCategoryNode(category);
if (!node) {
return;
}
XMLNode* subCategories = node->GetChildByName("SubCategories");
if (!subCategories) {
return;
}
XMLNode* child = subCategories->m_child;
if (!child) {
return;
}
this->m_currentCategory = category;
this->m_subCategories.m_node = child;
do {
this->m_numSubCategories++;
child = child->m_next;
} while (child);
}
// VERIFY: a20cef53 manual
// OFFSET: 0x005520B0
XMLNode* CKBSetup::GetSubCategory(int32_t category, int32_t subCategory) {
if (this->m_state != 2 || !this->m_tree || category < 0) {
return nullptr;
}
if (this->m_currentCategory != category || !this->m_subCategories.m_node) {
this->GetCategory(category);
}
this->m_subCategories.GoTo(subCategory);
return this->m_subCategories.m_node;
}
// VERIFY: f258e870 auto
// OFFSET: 0x00552100
void CKBSetup::_SendSuccessEvent() {
if (CGGameUI::m_initialized) {
FrameScript_SignalEvent(SCRIPT_EVENT_KNOWLEDGE_BASE_SETUP_LOAD_SUCCESS, nullptr);
}
}
// VERIFY: f1e62326 auto
// OFFSET: 0x005EEB70
void CKBPage::_SendSuccessEvent() {
}
// VERIFY: 5d3a5e30 auto
// OFFSET: 0x005EEB70
void CKBPage::_SendFailureEvent() {
}
// INLINED
CKBSetup::CKBSetup() {
this->unk_0040 = 0;
this->unk_0044 = 0;
this->unk_0048 = 0;
this->unk_004C = 0;
this->unk_0050 = -1;
this->unk_0054 = 0;
this->unk_0058 = 0;
this->unk_005C = 0;
this->unk_0060 = 0;
this->unk_0064 = 0;
this->unk_0068 = 0;
this->unk_006C = 0;
this->unk_0070 = 0;
this->m_numLanguages = 0;
this->m_numCategories = 0;
this->m_numSubCategories = 0;
this->m_numArticleHeaders = 0;
this->m_currentCategory = -1;
this->m_languages.m_node = nullptr;
this->m_languages.m_index = 0;
this->m_categories.m_node = nullptr;
this->m_categories.m_index = 0;
this->m_subCategories.m_node = nullptr;
this->m_subCategories.m_index = 0;
this->m_articleHeaders.m_node = nullptr;
this->m_articleHeaders.m_index = 0;
}
// VERIFY: 1b2d7a48 manual
+25 -24
View File
@@ -5,8 +5,10 @@
#include <cstdint>
#include "Engine/Source/Os/OsURLDownload.h"
#include "Engine/Source/Storm/Source/SLock.h"
#include "WoW/Source/Ui/CKBIterator.h"
class CDynamicString;
class XMLNode;
struct XMLTree;
struct lua_State;
@@ -44,26 +46,36 @@ class CKBPage {
virtual void _ComputeCachedData();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
int32_t _BeginLoading();
XMLNode* _GetRoot(CKBIterator& iterator);
int32_t _GetInt(XMLNode* node, const char* attribute) const;
int32_t _GetInt(const char* element, const char* attribute) const;
bool _GetBool(XMLNode* node, const char* attribute) const;
const char* _GetBodyString(XMLNode* node) const;
const char* _GetBodyString(const char* element, const char* child) const;
bool _GetBodyBool(const char* element, const char* child) const;
int32_t _GetBodyInt(const char* element, const char* child) const;
};
class CKBSetup : public CKBPage {
public:
/* 0040 */ int32_t unk_0040;
/* 0044 */ int32_t unk_0044;
/* 0048 */ uint32_t unk_0048;
/* 004C */ int32_t unk_004C;
/* 0050 */ int32_t unk_0050;
/* 0054 */ uint32_t unk_0054;
/* 0058 */ uint32_t unk_0058;
/* 005C */ uint32_t unk_005C;
/* 0060 */ uint32_t unk_0060;
/* 0064 */ uint32_t unk_0064;
/* 0068 */ uint32_t unk_0068;
/* 006C */ uint32_t unk_006C;
/* 0070 */ uint32_t unk_0070;
/* 0040 */ int32_t m_numLanguages;
/* 0044 */ int32_t m_numCategories;
/* 0048 */ int32_t m_numSubCategories;
/* 004C */ int32_t m_numArticleHeaders;
/* 0050 */ int32_t m_currentCategory;
/* 0054 */ CKBIterator m_languages;
/* 005C */ CKBIterator m_categories;
/* 0064 */ CKBIterator m_subCategories;
/* 006C */ CKBIterator m_articleHeaders;
CKBSetup();
int32_t BeginLoading(int32_t numArticles, int32_t pageNumber);
XMLNode* GetLanguage(int32_t index);
XMLNode* GetCategoryNode(int32_t index);
XMLNode* GetArticleHeader(int32_t index);
void GetCategory(int32_t category);
XMLNode* GetSubCategory(int32_t category, int32_t subCategory);
virtual void _ComputeCachedData();
virtual void _SendSuccessEvent();
virtual void _SendFailureEvent();
@@ -71,17 +83,6 @@ class CKBSetup : public CKBPage {
extern CKBSetup g_KnowledgeBaseSetup;
int32_t Script_KBSetup_GetLanguageData(lua_State* L);
int32_t Script_KBSetup_GetCategoryData(lua_State* L);
int32_t Script_KBSetup_GetSubCategoryCount(lua_State* L);
int32_t Script_KBSetup_GetSubCategoryData(lua_State* L);
int32_t Script_KBSetup_GetArticleHeaderData(lua_State* L);
int32_t Script_KBSetup_GetTotalArticleCount(lua_State* L);
int32_t Script_KBQuery_BeginLoading(lua_State* L);
int32_t Script_KBQuery_GetArticleHeaderData(lua_State* L);
int32_t Script_KBQuery_GetTotalArticleCount(lua_State* L);
int32_t Script_KBArticle_BeginLoading(lua_State* L);
int32_t Script_KBArticle_GetData(lua_State* L);
const char* KnowledgeBaseGetURLForLocale();
void KnowledgeBase_RegisterScriptFunctions();
void KnowledgeBase_UnregisterScriptFunctions();
+224 -8
View File
@@ -8,6 +8,8 @@
#include "WoW/Source/Ui/CKBQuery.h"
#include "WoW/Source/Ui/CKBArticle.h"
#include "Engine/Source/lua-5.1/src/lauxlib.h"
#include "Engine/Source/FrameXML/XMLTree.h"
#include "Engine/Source/Storm/H/storm.h"
// VERIFY: 9e42057a auto
// OFFSET: 0x00551FB0
@@ -60,50 +62,264 @@ static int32_t Script_KBArticle_IsLoaded(lua_State* L) {
return 1;
}
// VERIFY: 755e1b76 auto
// VERIFY: 3bb58cb3 auto
// OFFSET: 0x00551790
static int32_t Script_KBSetup_GetLanguageCount(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
return luaL_error(L, "KBSetup_GetLanguageCount() failed because setup is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseSetup.unk_0040);
lua_pushnumber(L, g_KnowledgeBaseSetup.m_numLanguages);
return 1;
}
// VERIFY: 4a05c9da auto
// VERIFY: 453300cc auto
// OFFSET: 0x005518C0
static int32_t Script_KBSetup_GetCategoryCount(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
return luaL_error(L, "KBSetup_GetCategoryCount() failed because setup is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseSetup.unk_0044);
lua_pushnumber(L, g_KnowledgeBaseSetup.m_numCategories);
return 1;
}
// VERIFY: e7e8714f auto
// VERIFY: 039b02dc auto
// OFFSET: 0x005519F0
static int32_t Script_KBSetup_GetArticleHeaderCount(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
return luaL_error(L, "KBSetup_GetArticleHeaderCount() failed because setup is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseSetup.unk_004C);
lua_pushnumber(L, g_KnowledgeBaseSetup.m_numArticleHeaders);
return 1;
}
// VERIFY: 6c7bcdb3 auto
// VERIFY: 516cbb9d auto
// OFFSET: 0x00551BC0
static int32_t Script_KBQuery_GetArticleHeaderCount(lua_State* L) {
if (g_KnowledgeBaseQuery.m_state != 2) {
return luaL_error(L, "KBQuery_GetArticleHeaderCount() failed because query is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseQuery.unk_0040);
lua_pushnumber(L, g_KnowledgeBaseQuery.m_numArticleHeaders);
return 1;
}
// VERIFY: 8c822b85 manual
// OFFSET: 0x005517D0
static int32_t Script_KBSetup_GetLanguageData(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetLanguageData() failed because setup is not loaded");
}
XMLNode* node = g_KnowledgeBaseSetup.GetLanguage(static_cast<int32_t>(lua_tonumber(L, 1)) - 1);
if (!node) {
luaL_error(L, "KBSetup_GetLanguageData() called with invalid category index");
}
lua_pushnumber(L, g_KnowledgeBaseSetup._GetInt(node, "id"));
lua_pushstring(L, g_KnowledgeBaseSetup.m_state == 2 && g_KnowledgeBaseSetup.m_tree ? node->GetAttributeByName("caption") : nullptr);
return 2;
}
// VERIFY: 3a3144f9 manual
// OFFSET: 0x00551900
static int32_t Script_KBSetup_GetCategoryData(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetCategoryData() failed because setup is not loaded");
}
XMLNode* node = g_KnowledgeBaseSetup.GetCategoryNode(static_cast<int32_t>(lua_tonumber(L, 1)) - 1);
if (!node) {
luaL_error(L, "KBSetup_GetCategoryData() called with invalid category index");
}
lua_pushnumber(L, g_KnowledgeBaseSetup._GetInt(node, "id"));
lua_pushstring(L, g_KnowledgeBaseSetup.m_state == 2 && g_KnowledgeBaseSetup.m_tree ? node->GetAttributeByName("caption") : nullptr);
return 2;
}
// VERIFY: 52004c77 manual
// OFFSET: 0x00551A30
static int32_t Script_KBSetup_GetArticleHeaderData(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetArticleHeaderData() failed because setup is not loaded");
}
XMLNode* node = g_KnowledgeBaseSetup.GetArticleHeader(static_cast<int32_t>(lua_tonumber(L, 1)) - 1);
if (!node) {
luaL_error(L, "KBSetup_GetArticleHeaderData() called with invalid article header index");
}
lua_pushnumber(L, g_KnowledgeBaseSetup._GetInt(node, "id"));
lua_pushstring(L, g_KnowledgeBaseSetup.m_state == 2 && g_KnowledgeBaseSetup.m_tree ? node->GetAttributeByName("subject") : nullptr);
lua_pushboolean(L, g_KnowledgeBaseSetup._GetBool(node, "hotIssue"));
lua_pushboolean(L, g_KnowledgeBaseSetup._GetBool(node, "updated"));
return 4;
}
// VERIFY: 620ab044 auto
// OFFSET: 0x00551B40
static int32_t Script_KBSetup_GetTotalArticleCount(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetTotalArticleCount() failed because setup is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseSetup._GetInt("ArticleHeaders", "articleCount"));
return 1;
}
// VERIFY: 0efd23c7 manual
// OFFSET: 0x00551C00
static int32_t Script_KBQuery_GetArticleHeaderData(lua_State* L) {
if (g_KnowledgeBaseQuery.m_state != 2) {
luaL_error(L, "KBQuery_GetArticleHeaderData() failed because query is not loaded");
}
XMLNode* node = g_KnowledgeBaseQuery.GetArticleHeader(static_cast<int32_t>(lua_tonumber(L, 1)) - 1);
if (!node) {
luaL_error(L, "KBQuery_GetArticleHeaderData() called with invalid article header index");
}
lua_pushnumber(L, g_KnowledgeBaseQuery._GetInt(node, "id"));
lua_pushstring(L, g_KnowledgeBaseQuery.m_state == 2 && g_KnowledgeBaseQuery.m_tree ? node->GetAttributeByName("subject") : nullptr);
lua_pushboolean(L, g_KnowledgeBaseQuery._GetBool(node, "hotIssue"));
lua_pushboolean(L, g_KnowledgeBaseQuery._GetBool(node, "updated"));
return 4;
}
// VERIFY: cee4ac95 auto
// OFFSET: 0x00551D10
static int32_t Script_KBQuery_GetTotalArticleCount(lua_State* L) {
if (g_KnowledgeBaseQuery.m_state != 2) {
luaL_error(L, "KBQuery_GetTotalArticleCount() failed because query is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseQuery._GetInt("ArticleHeaders", "articleCount"));
return 1;
}
// VERIFY: f4fc784c auto
// OFFSET: 0x00551D60
static int32_t Script_KBArticle_BeginLoading(lua_State* L) {
int32_t articleId = static_cast<int32_t>(lua_tonumber(L, 1));
int32_t searchType = static_cast<int32_t>(lua_tonumber(L, 2));
g_KnowledgeBaseArticle.BeginLoading(articleId, searchType);
return 0;
}
// VERIFY: e8f7141c manual
// OFFSET: 0x00551DD0
static int32_t Script_KBArticle_GetData(lua_State* L) {
if (g_KnowledgeBaseArticle.m_state != 2) {
luaL_error(L, "KBArticle_GetData() failed because article is not loaded");
}
lua_pushnumber(L, g_KnowledgeBaseArticle._GetBodyInt("Article", "id"));
lua_pushstring(L, g_KnowledgeBaseArticle._GetBodyString("Article", "subject"));
lua_pushstring(L, g_KnowledgeBaseArticle._GetBodyString("Article", "subjectAlt"));
lua_pushstring(L, g_KnowledgeBaseArticle._GetBodyString("Article", "ArticleText"));
lua_pushstring(L, g_KnowledgeBaseArticle._GetBodyString("Article", "keyword"));
lua_pushnumber(L, g_KnowledgeBaseArticle._GetBodyInt("Article", "languageId"));
lua_pushboolean(L, g_KnowledgeBaseArticle._GetBodyBool("Article", "hotIssue"));
return 7;
}
// VERIFY: f2eea941 manual
// OFFSET: 0x005523A0
static int32_t Script_KBSetup_GetSubCategoryCount(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetSubCategoryCount() failed because setup is not loaded");
}
double category = lua_tonumber(L, 1);
int32_t count;
if (g_KnowledgeBaseSetup.m_currentCategory == category - 1.0) {
count = g_KnowledgeBaseSetup.m_numSubCategories;
} else if (g_KnowledgeBaseSetup.m_state == 2 && g_KnowledgeBaseSetup.m_tree) {
g_KnowledgeBaseSetup.GetCategory(static_cast<int32_t>(category - 1.0));
count = g_KnowledgeBaseSetup.m_numSubCategories;
} else {
count = 0;
}
lua_pushnumber(L, count);
return 1;
}
// VERIFY: 3092339c manual
// OFFSET: 0x00552440
static int32_t Script_KBSetup_GetSubCategoryData(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBSetup_GetSubCategoryData() failed because setup is not loaded");
}
int32_t subCategory = static_cast<int32_t>(lua_tonumber(L, 2)) - 1;
int32_t category = static_cast<int32_t>(lua_tonumber(L, 1) - 1.0);
XMLNode* node = g_KnowledgeBaseSetup.GetSubCategory(category, subCategory);
if (!node) {
luaL_error(L, "KBSetup_GetSubCategoryData() called with invalid category or sub category index");
}
lua_pushnumber(L, g_KnowledgeBaseSetup._GetInt(node, "id"));
lua_pushstring(L, g_KnowledgeBaseSetup.m_state == 2 && g_KnowledgeBaseSetup.m_tree ? node->GetAttributeByName("caption") : nullptr);
return 2;
}
// VERIFY: 6c845c8e manual
// OFFSET: 0x00552580
static int32_t Script_KBQuery_BeginLoading(lua_State* L) {
if (g_KnowledgeBaseSetup.m_state != 2) {
luaL_error(L, "KBQuery_BeginLoading() failed because setup is not loaded");
}
const char* query = lua_tolstring(L, 1, nullptr);
if (!query) {
luaL_error(L, "KBQuery_BeginLoading() called with a null string for search query");
}
if (SStrLen(query) > 128) {
luaL_error(L, "KBQuery_BeginLoading() called with a string > 128 bytes for search query");
}
int32_t category = static_cast<int32_t>(lua_tonumber(L, 2));
int32_t subCategory = static_cast<int32_t>(lua_tonumber(L, 3));
int32_t numArticles = static_cast<int32_t>(lua_tonumber(L, 4));
int32_t pageNumber = static_cast<int32_t>(lua_tonumber(L, 5));
int32_t categoryId = -1;
if (subCategory || category) {
XMLNode* node;
if (subCategory) {
if (!category) {
luaL_error(L, "KBQuery_BeginLoading() called with subcategory without category");
}
node = g_KnowledgeBaseSetup.GetSubCategory(category - 1, subCategory - 1);
} else {
node = g_KnowledgeBaseSetup.GetCategoryNode(category - 1);
}
if (!node) {
luaL_error(L, "KBSetup_GetCategoryData() called with invalid category index");
}
categoryId = g_KnowledgeBaseSetup._GetInt(node, "id");
}
g_KnowledgeBaseQuery.BeginLoading(query, categoryId, numArticles, pageNumber);
return 0;
}
// STATIC: 0x00ACD488
static FrameScript_Method s_apMethodMap[] = {
{ "KBSetup_BeginLoading", &Script_KBSetup_BeginLoading },
+32
View File
@@ -1482,3 +1482,35 @@ void CGMailInfo::ShutdownGame() {
ClientServices::ClearMessageHandler(SMSG_RECEIVED_MAIL);
ClientServices::ClearMessageHandler(SMSG_SHOW_MAILBOX);
}
// VERIFY: ffc9f0e4 auto
// OFFSET: 0x00571730
void CGMailInfo::CloseMail(bool leavingWorld) {
CGMailInfo::ClearSendMail(false);
if (leavingWorld) {
CGMailInfo::m_object = WOWGUID{ 0 };
CGMailInfo::m_numInboxItems = 0;
CGMailInfo::m_totalInboxItems = 0;
CGMailInfo::m_autoLooting = nullptr;
} else if (CGMailInfo::m_object.m_guid) {
CGGameUI::ClearInteractTarget(CGMailInfo::m_object, 0);
CGMailInfo::m_object = WOWGUID{ 0 };
CGMailInfo::m_autoLooting = nullptr;
FrameScript_SignalEvent(SCRIPT_EVENT_MAIL_CLOSED, nullptr);
if (CGMailInfo::m_doPendingQuery) {
CGMailInfo::QueryNextMailTime();
}
}
}
// VERIFY: 6fccb8fb manual
// OFFSET: 0x00571BE0
void CGMailInfo::LeaveWorld() {
CGMailInfo::CloseMail(true);
for (uint32_t i = 0; i < CGMailInfo::m_stationeries.Count(); i++) {
g_itemDBCache.CancelCallback(CGMailInfo::m_stationeries.m_data[i]->m_itemID, StationeryItemCallback, nullptr);
}
}
+1
View File
@@ -87,6 +87,7 @@ class CGMailInfo {
static void EnterWorld();
static void InitializeGame();
static void ShutdownGame();
static void LeaveWorld();
static void UpdatePendingMail(float elapsed);
static uint32_t m_sendMoney;
static uint32_t m_sendCOD;
+74
View File
@@ -26,6 +26,7 @@
#include "WoW/Source/Ui/ScriptEvents.h"
#include "WoW/Source/Ui/Types.h"
#include <cmath>
#include <cfloat>
#include <cstring>
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
#include "Engine/Source/FrameScript/FrameScript.h"
@@ -871,6 +872,31 @@ void DisplayQuestPoint(float x, float y, int32_t importance, const char* name) {
s_closestPOIsChanged = 1;
}
// VERIFY: e9f5e6ef auto
// OFFSET: 0x007F4870
void MinimapSetDynamicPOI(int32_t index, int32_t flags, float x, float y, int32_t icon, int32_t importance, const char* name) {
s_dynamicPOIs[index].m_flags = flags;
s_dynamicPOIs[index].m_pos[0] = x;
s_dynamicPOIs[index].m_icon[0] = icon;
s_dynamicPOIs[index].m_continentID = s_mapId;
s_dynamicPOIs[index].m_pos[1] = y;
s_dynamicPOIs[index].m_importance = importance;
SStrCopy(s_dynamicPOINames[index], name, sizeof(s_dynamicPOINames[index]));
if (index == 1) {
s_worldMapRefreshTime = static_cast<uint32_t>(time(nullptr)) + 480;
if (CGWorldMap::m_currentOrphanZone == -1) {
CGWorldMap::SetMap(CGWorldMap::m_currentContinent, CGWorldMap::m_currentZone, CGWorldMap::m_currentOrphanZone);
} else {
CGWorldMap::SetMap(CGWorldMap::m_currentContinent, CGWorldMap::m_currentOrphanZone, CGWorldMap::m_currentDungeonMap);
}
}
UpdatePointsOfInterest();
s_closestPOIsChanged = 1;
}
// VERIFY: 3a8b6454 auto
// OFFSET: 0x007F4990
void MinimapSetCorpsePOI(float x, float y) {
@@ -946,6 +972,24 @@ static void LoadMD5Names() {
SFile::Unload(data);
}
// VERIFY: 446a7368 auto
// OFFSET: 0x007F4E50
void MinimapShutdown() {
s_playerPosition.x = FLT_MAX;
s_playerPosition.z = FLT_MAX;
s_playerPosition.y = FLT_MAX;
s_tileMaxY = -1;
s_tileMinY = -1;
s_mapId = -1;
s_tileMaxX = -1;
s_tileMinX = -1;
s_mapObjId = 0;
s_mapObjGroup = 0;
s_mapObjAreaGroup = -1;
s_updateFlags = 0;
s_md5Names.InternalClear(0);
}
// VERIFY: 885c45ba manual
// OFFSET: 0x007F6730
void MinimapInitialize(int32_t mapId) {
@@ -2586,6 +2630,36 @@ void CGMinimapFrame::RenderOverlay(const C44Matrix& rotation) {
}
}
// VERIFY: 596d6a8a manual
// OFFSET: 0x0057FBD0
void CGMinimapFrame::LeaveWorld() {
MinimapShutdown();
for (uint32_t i = 0; i < 256; i++) {
if (s_tiles[i].m_texture) {
HandleClose(reinterpret_cast<HOBJECT>(s_tiles[i].m_texture));
s_tiles[i].m_texture = nullptr;
}
s_tiles[i].m_flags = 0;
s_tiles[i].m_x = -1;
s_tiles[i].m_y = -1;
}
if (s_indoor.m_texture) {
HandleClose(reinterpret_cast<HOBJECT>(s_indoor.m_texture));
}
s_indoor.m_texture = nullptr;
s_poiInfo.Clear();
for (uint32_t i = 0; i < 23; i++) {
s_objInfo[i].Clear();
}
s_unkBEBA40 = 0;
}
// VERIFY: 5b02e890 manual
// OFFSET: 0x0057FF70
void CGMinimapFrame::RenderGroupBlips(const C44Matrix& rotation) {
+3
View File
@@ -137,6 +137,7 @@ class CGMinimapFrame : public CSimpleFrame {
public:
static void EnterWorld();
static void ShutdownGame();
static void LeaveWorld();
static CDataAllocator s_minimapHeap;
static void SetPingPosition(const WOWGUID& guid, const C2Vector& position);
static void MinimapTextureCallback(EGxTexCommand command, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipLevel, void* userArg, uint32_t& texelStrideInBytes, const void*& texels);
@@ -222,6 +223,8 @@ float MinimapGetViewRadius();
AreaPOIRec* MinimapGetGossipPoi();
void UpdatePointsOfInterest();
void RefreshWorldStatePOIs(uint32_t state);
void MinimapShutdown();
void MinimapSetDynamicPOI(int32_t index, int32_t flags, float x, float y, int32_t icon, int32_t importance, const char* name);
void MinimapSetCorpsePOI(float x, float y);
void MinimapSetSpiritHealerPOI(float x, float y);
+102
View File
@@ -26,6 +26,11 @@
#include "WoW/Source/Ui/Types.h"
#include "Engine/Source/Os/Time.h"
#include <ctime>
#include "WoW/Source/LoadingScreen.h"
#include "WoW/Source/Ui/ChatFrame.h"
#include "WoW/Source/DB/Rec/MapDifficultyRec.h"
#include "Engine/Source/ConsoleBase/IConsole.h"
#include "Engine/Source/Storm/H/storm.h"
// STATIC: 0x00BD1948
WOWGUID CGPartyInfo::m_members[4];
@@ -929,3 +934,100 @@ void CGPartyInfo::ShutdownGame() {
ClientServices::ClearMessageHandler(SMSG_CHANGE_PLAYER_DIFFICULTY_RESULT);
ConsoleCommandUnregister("changePlayerDifficulty");
}
// VERIFY: c2ece242 auto
// OFFSET: 0x0052C460
int32_t Packet_SMSG_PLAYER_DIFFICULTY_CHANGE(void* param, NETMESSAGE msgId, uint32_t time, CDataStore* msg) {
uint32_t result;
uint8_t difficulty;
uint32_t value;
char duration[1024];
char token[64];
msg->Get(result);
switch (result) {
case 0:
msg->Get(difficulty);
CGPartyInfo::m_dynamicDifficulty = difficulty;
break;
case 1:
msg->Get(value);
CGTooltip::GetDurationString(duration, sizeof(duration), 1000 * value, "INT_SPELL_DURATION", nullptr, 1, 0);
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_COOLDOWN_S, duration);
break;
case 2:
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_WORLDSTATE);
break;
case 3:
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_ENCOUNTER);
break;
case 4:
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_COMBAT);
break;
case 5:
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_PLAYER_BUSY);
break;
case 6:
msg->Get(value);
CGPartyInfo::unk_BD1984 = value + static_cast<uint32_t>(::time(nullptr));
LoadingScreenEnable(CGGameUI::m_iCurrentMapID, false);
break;
case 7:
CGGameUI::DisplayError(ERR_DIFFICULTY_CHANGE_ALREADY_STARTED);
break;
case 8: {
msg->Get(value);
MapDifficultyRec* rec = g_mapDifficultyDB.GetRecord(value);
if (rec && rec->m_message) {
CGChat::AddChatMessage(rec->m_message, 0, nullptr, 0, nullptr, nullptr, nullptr, WOWGUID(), 0, WOWGUID(), 0, false, nullptr);
}
break;
}
case 9:
LoadingScreenDisable();
ConsoleWrite("Changed difficulty successfully", DEFAULT_COLOR);
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_DIFFICULTY_CHANGED, nullptr);
SStrPrintf(token, sizeof(token), "PLAYER_DIFFICULTY%d", CGPartyInfo::m_dynamicDifficulty + 1);
CGGameUI::DisplayError(ERR_PLAYER_DIFFICULTY_CHANGED_S, FrameScript_GetText(token, -1, GENDER_NOT_APPLICABLE));
break;
}
return 1;
}
// VERIFY: 940f24d5 manual
// OFFSET: 0x0052D060
int32_t CCommand_SetDifficulty(const char* command, const char* arguments) {
uint32_t difficulty = SStrToInt(arguments);
if (difficulty > 1) {
ConsoleWrite("Invalid difficulty", ERROR_COLOR);
return 1;
}
WDataStore msg;
msg.Put(static_cast<uint32_t>(CMSG_CHANGEPLAYER_DIFFICULTY));
msg.Put(difficulty);
msg.Finalize();
ClientServices::Send2(&msg);
return 1;
}
// VERIFY: a24a260e manual
// OFFSET: 0x0052D1E0
void CGPartyInfo::LeaveWorld() {
if (ClntObjMgrGetActivePlayerObj()) {
CGPlayer_C::DeclineGroup();
}
}
+1
View File
@@ -55,6 +55,7 @@ struct PartyReadyCheckInfo {
class CGPartyInfo {
public:
static void ChangeRaidDifficulty(int32_t heroic);
static void LeaveWorld();
static uint32_t m_memberRoles[4];
static uint8_t m_memberAssignments[4];
static uint32_t unk_BD1984;
+11
View File
@@ -1227,3 +1227,14 @@ void CGPetInfo::ShutdownGame() {
ClientServices::ClearMessageHandler(SMSG_PET_UPDATE_COMBO_POINTS);
ClientServices::ClearMessageHandler(SMSG_PET_GUIDS);
}
// VERIFY: 92931bd9 auto
// OFFSET: 0x005D3360
void CGPetInfo::LeaveWorld() {
int32_t possessSpell = CGPetInfo::m_possessSpell;
CGPetInfo::m_possessSpell = 0;
if (possessSpell) {
FrameScript_SignalEvent(SCRIPT_EVENT_UPDATE_BONUS_ACTIONBAR, nullptr);
}
}
+1
View File
@@ -13,6 +13,7 @@ class CGPetInfo {
public:
static void InitializeGame();
static void ShutdownGame();
static void LeaveWorld();
static void FindPossessedSpell();
static WOWGUID GetPet(uint32_t index);
static uint32_t* FindSpellByID(int32_t spellId);
+18
View File
@@ -16,6 +16,7 @@
#include "WoW/Source/DB/Rec/QuestFactionRewardRec.h"
#include "WoW/Source/Ui/ReputationInfo.h"
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
#include "WoW/Source/Game/GameClient/NameCache.h"
#include "WoW/Source/Object/ItemStats.h"
#include "WoW/Source/Object/ObjectClient/Item_C.h"
#include "WoW/Source/Object/ObjectClient/Unit_C.h"
@@ -899,3 +900,20 @@ void CGQuestInfo::EnterWorld() {
CGQuestInfo::ClearState();
CGQuestInfo::ClearQuestItems();
}
// VERIFY: 8b9ea6e9 auto
// OFFSET: 0x0058BC50
void CGQuestInfo::ConfirmAcceptQuest(int32_t questId, const char* title, const WOWGUID* guid) {
CGQuestInfo::m_pendingQuest = questId;
NameCache* name = g_nameDBCache.GetRecord(guid->m_guid, WOWGUID{ 0 }, nullptr, nullptr, false);
if (name) {
FrameScript_SignalEvent(SCRIPT_EVENT_QUEST_ACCEPT_CONFIRM, "%s%s", name->m_name, title);
}
}
// VERIFY: 5ae7745b auto
// OFFSET: 0x0058DD30
void CGQuestInfo::LeaveWorld() {
CGQuestInfo::QuestGiverFinished(0, CGQuestInfo::m_currentQuest, 1);
}
+1
View File
@@ -80,6 +80,7 @@ class CGQuestInfo {
static uint32_t m_pendingQuest;
static void ConfirmAcceptQuest(int32_t questId, const char* title, const WOWGUID* guid);
static void LeaveWorld();
static int32_t m_canComplete;
static void AddQuest(int32_t questId, const char* title, int32_t level, int32_t flags, int32_t turnIn, int32_t repeatable);
static void AddQuestInProgress(int32_t questId, const char* title, int32_t level, int32_t flags, int32_t repeatable);
+2 -2
View File
@@ -2236,7 +2236,7 @@ void CGQuestLog::SaveTrackedQuests() {
// STATIC: 0x00AD1264
static int32_t s_poiOverlapIterations = 20;
// VERIFY: c2014316 manual
// VERIFY: 0b11702f manual
// OFFSET: 0x005E2EB0
void CGQuestLog::UpdatePOIIcons() {
if (!g_questPOICVar->m_intValue) {
@@ -2355,7 +2355,7 @@ void CGQuestLog::UpdatePOIIcons() {
if (CGWorldMap::m_currentContinent < 0) {
zoneId = CGWorldMap::m_currentOrphanZone;
} else {
WorldMapContinent* continent = &CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo* continent = &CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
zoneId = CGWorldMap::m_currentZone < 0 ? continent->m_areaID : continent->m_zones.m_data[CGWorldMap::m_currentZone];
}
+8
View File
@@ -1294,3 +1294,11 @@ void CGRaidInfo::ShutdownGame() {
ClientKillTimer(CGRaidInfo::m_readyCheckTimer, CGRaidInfo::ProcessReadyCheckTimer, "ProcessReadyCheckTimer");
}
}
// VERIFY: 7980cdfb auto
// OFFSET: 0x00573670
int32_t CGRaidInfo::ProcessReadyCheckTimer(const void* data, void* param) {
CGRaidInfo::m_readyCheckTimer = 0;
CGRaidInfo::CheckReadyCheckTime();
return 1;
}
+91
View File
@@ -6,6 +6,10 @@
#include "WoW/Source/Magic/MagicClient/Spell_C.h"
#include "WoW/Source/Object/ObjectClient/Player_C.h"
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
#include "Engine/Source/Base/CDataStore.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "WoW/Source/Ui/SpellBookFrame.h"
#include "WoW/Source/Ui/Types.h"
// STATIC: 0x00C24304
int32_t CGRuneInfo::m_runes[8];
@@ -339,3 +343,90 @@ void CGRuneInfo::ComputeRuneRechargeTime(int32_t index, float progress) {
CGRuneInfo::m_runeCooldowns[index] = 0;
}
}
// VERIFY: 4de899c0 auto
// OFFSET: 0x005EE020
void CGRuneInfo::ConvertRune(uint8_t rune, uint8_t type) {
CGRuneInfo::m_runes[rune] = type;
FrameScript_SignalEvent(SCRIPT_EVENT_RUNE_TYPE_UPDATE, "%d", rune + 1);
CGSpellBook::UpdateUsable();
}
// VERIFY: c2cf4661 manual
// OFFSET: 0x005EE240
void CGRuneInfo::SetPredictedRunes(uint8_t available, uint8_t used, const uint8_t* cooldowns) {
if (!ClntObjMgrGetActivePlayerObj()) {
return;
}
CGRuneInfo::m_predictedRunes = used;
for (int32_t i = 0; i < 8; i++) {
int32_t bit = 1 << i;
if ((available & bit) && !(used & bit)) {
if (!CGRuneInfo::GetRuneLastUsedTime(i)) {
float progress = 0.0f;
if (cooldowns) {
progress = cooldowns[i] * 0.0039215689f;
if (progress > 1.0f) {
progress = 1.0f;
}
}
CGRuneInfo::m_runeLastUsed[i] = OsGetAsyncTimeMs() - static_cast<int32_t>(10000.0f * progress);
CGRuneInfo::ComputeRuneRechargeTime(i, progress);
FrameScript_SignalEvent(SCRIPT_EVENT_RUNE_POWER_UPDATE, "%d%b", i + 1, 0);
}
} else if ((!(available & bit) && (used & bit)) || ((CGRuneInfo::m_predictedRunes & bit) && CGRuneInfo::GetRuneLastUsedTime(i))) {
CGRuneInfo::m_runeLastUsed[i] = 0;
CGRuneInfo::m_runeCooldowns[i] = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_RUNE_POWER_UPDATE, "%d%b", i + 1, 1);
}
}
CGSpellBook::UpdateUsable();
}
// VERIFY: ff3c5eda auto
// OFFSET: 0x005EE440
void CGRuneInfo::ResyncRunes(CDataStore* msg) {
msg->Get(CGRuneInfo::m_numRunes);
for (int32_t i = 0; i < static_cast<int32_t>(CGRuneInfo::m_numRunes); i++) {
uint8_t type;
msg->Get(type);
CGRuneInfo::m_runes[i] = type;
CGRuneInfo::m_baseRunes[i] = type;
uint8_t cooldown;
msg->Get(cooldown);
float progress = cooldown * 0.0039215689f;
if (progress > 1.0f) {
progress = 1.0f;
}
CGRuneInfo::m_runeLastUsed[i] = OsGetAsyncTimeMs() - static_cast<int32_t>(10000.0f * progress);
CGRuneInfo::ComputeRuneRechargeTime(i, progress);
FrameScript_SignalEvent(SCRIPT_EVENT_RUNE_POWER_UPDATE, "%d%b", i + 1, 0);
}
}
// VERIFY: a086b4eb auto
// OFFSET: 0x005EE520
void CGRuneInfo::AddRunePower(CDataStore* msg) {
uint32_t runes;
msg->Get(runes);
for (int32_t i = 0; i < static_cast<int32_t>(CGRuneInfo::m_numRunes); i++) {
if (((1 << i) & runes) && !((1 << i) & CGRuneInfo::m_predictedRunes)) {
CGRuneInfo::m_runeLastUsed[i] = OsGetAsyncTimeMs() - 10000;
CGRuneInfo::ComputeRuneRechargeTime(i, 1.0f);
FrameScript_SignalEvent(SCRIPT_EVENT_RUNE_POWER_UPDATE, "%d%b", i + 1, 0);
}
}
FrameScript_SignalEvent(SCRIPT_EVENT_ACTIONBAR_UPDATE_COOLDOWN, nullptr);
}
+519 -8
View File
@@ -8,6 +8,17 @@
#include "WoW/Source/WowSvcs/WowSvcsClient/ClientServices.h"
#include "WoW/Source/Object/ObjectClient/Item_C.h"
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
#include "WoW/Source/DB/DBClient/DBCacheInstances.h"
#include "WoW/Source/DB/DBClient/DBClient.h"
#include "WoW/Source/DB/Rec/ItemLimitCategoryRec.h"
#include "WoW/Source/Object/ItemStats.h"
#include "WoW/Source/Object/ObjectClient/Bag_C.h"
#include "WoW/Source/Object/ObjectClient/Player_C.h"
#include "WoW/Source/SoundInterface/SoundInterface2.h"
#include "WoW/Source/Ui/AuctionHouse.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/WowSvcs/WowSvcsClient/FriendList.h"
// STATIC: 0x00BFA680
WOWGUID CGTradeInfo::m_enchantingItem;
@@ -201,16 +212,16 @@ int32_t CGTradeInfo::SetPlayerItem(uint32_t slot, WOWGUID item, WOWGUID containe
return 1;
}
// VERIFY: da0e456c auto
// VERIFY: 9d5cff16 auto
// OFFSET: 0x00703CB0
uint32_t CGTradeInfo::GetPlayerTradeMoney() {
return CGTradeInfo::m_playerTrade.m_money;
return CGTradeInfo::m_playerTrade.m_money[0];
}
// VERIFY: c776083d auto
// VERIFY: 37c94e9a auto
// OFFSET: 0x00703CC0
uint32_t CGTradeInfo::GetTargetTradeMoney() {
return CGTradeInfo::m_playerTrade.m_targetMoney;
return CGTradeInfo::m_playerTrade.m_money[1];
}
// VERIFY: b09af206 manual
@@ -229,19 +240,519 @@ bool CGTradeInfo::IsItemBeingTraded(WOWGUID item) {
return false;
}
// VERIFY: e66b37a5 manual
// VERIFY: 82403266 manual
// OFFSET: 0x00704320
void CGTradeInfo::RemoveMoney(uint32_t amount) {
if (!amount || amount > CGTradeInfo::m_playerTrade.m_money) {
if (!amount || amount > CGTradeInfo::m_playerTrade.m_money[0]) {
return;
}
uint32_t money = CGTradeInfo::m_playerTrade.m_money - amount;
uint32_t money = CGTradeInfo::m_playerTrade.m_money[0] - amount;
CDataStore msg;
msg.Put(static_cast<uint32_t>(CMSG_SET_TRADE_GOLD));
msg.Put(money);
s_clientStateIndex++;
msg.Finalize();
CGTradeInfo::m_playerTrade.m_money = money;
CGTradeInfo::m_playerTrade.m_money[0] = money;
ClientServices::Send2(&msg);
}
// VERIFY: 369a38df auto
// OFFSET: 0x00586390
static void SetTargetAccepted(int32_t accepted) {
if (CGTradeInfo::m_targetAccepted != accepted) {
CGTradeInfo::m_targetAccepted = accepted;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_ACCEPT_UPDATE, "%d%d", CGTradeInfo::m_playerAccepted, accepted);
}
}
// VERIFY: c3d04d8c auto
// OFFSET: 0x00586410
void CGTradeInfo::DenyPlayerItem(int32_t slot) {
if (slot == 255) {
CGTradeInfo::unk_BFA670 = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_TRADE_MONEY, nullptr);
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_MONEY, nullptr);
return;
}
CGGameUI::UnlockItem(CGTradeInfo::m_playerItems[slot]);
CGTradeInfo::m_playerItems[slot] = WOWGUID();
CGTradeInfo::unk_BFA5E8[slot] = WOWGUID();
CGTradeInfo::unk_BFA5DC[slot] = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_PLAYER_ITEM_CHANGED, "%d", slot + 1);
}
// VERIFY: aaae39b8 manual
// OFFSET: 0x005864A0
void CGTradeInfo::UnlockTradeItems() {
for (uint32_t i = 0; i < 7; i++) {
if (CGTradeInfo::m_playerItems[i]) {
CGGameUI::UnlockItem(CGTradeInfo::m_playerItems[i]);
}
}
}
// VERIFY: 001d35c0 auto
// OFFSET: 0x00586520
int32_t CGTradeInfo::GetGameError(int32_t error, int32_t target) {
switch (error) {
case 4:
return target ? ERR_TRADE_BAG_FULL : ERR_TRADE_TARGET_BAG_FULL;
case 17:
return target ? ERR_TRADE_TARGET_MAX_COUNT_EXCEEDED : ERR_TRADE_MAX_COUNT_EXCEEDED;
case 28:
return target ? ERR_MAX_VALUE : ERR_SPELL_FAILED_REAGENTS_GENERIC;
case 84:
return target ? ERR_TRADE_TARGET_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS : ERR_ITEM_MAX_LIMIT_CATEGORY_COUNT_EXCEEDED_IS;
default:
return GetDisplayErrorByInventoryError(error);
}
}
// VERIFY: fa685c0b auto
// OFFSET: 0x00586930
void CGTradeInfo::PlayerAccept() {
if (CGGameUI::CanPerformAction(7) && CGTradeInfo::m_playerAccepted) {
CGTradeInfo::m_playerAccepted = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_ACCEPT_UPDATE, "%d%d", 0, CGTradeInfo::m_targetAccepted);
Trade_C_UnacceptTrade();
}
if (CGTradeInfo::m_targetAccepted) {
CGTradeInfo::m_targetAccepted = 0;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_ACCEPT_UPDATE, "%d%d", CGTradeInfo::m_playerAccepted, 0);
}
}
// VERIFY: 5320b972 manual
// OFFSET: 0x00586AA0
void CGTradeInfo::RemovePlayerItem(WOWGUID item) {
if (!item) {
return;
}
for (uint32_t i = 0; i < 7; i++) {
if (CGTradeInfo::m_playerItems[i] == item) {
CGTradeInfo::SetPlayerItem(i, WOWGUID(), WOWGUID(), 0);
return;
}
}
}
// VERIFY: 617d1e5d auto
// OFFSET: 0x00586B50
void CGTradeInfo::AddCursorItem(int32_t bound) {
WOWGUID item;
WOWGUID container;
uint32_t slot;
CGGameUI::GetCursorItem(item, container, slot);
if (!item) {
return;
}
int32_t index = -1;
if (bound) {
if (CGTradeInfo::m_playerItems[6]) {
return;
}
index = 6;
} else {
for (int32_t i = 0; i < 6; i++) {
if (CGTradeInfo::m_playerItems[i] == item) {
return;
}
if (index == -1 && !CGTradeInfo::m_playerItems[i]) {
index = i;
}
}
if (index == -1) {
return;
}
}
if (CGTradeInfo::SetPlayerItem(index, item, container, static_cast<uint8_t>(slot))) {
CGGameUI::ClearCursor(0, 1);
}
}
// VERIFY: 65a17914 auto
// OFFSET: 0x00586C00
void CGTradeInfo::SetEnchantingItem(CGItem_C* item) {
if (CGTradeInfo::m_enchantingItem) {
CGGameUI::UnlockItem(CGTradeInfo::m_enchantingItem);
CGTradeInfo::m_enchantingItem = WOWGUID();
}
if (item) {
WOWGUID none = WOWGUID();
item->UseItem(&none, 0);
CGGameUI::LockItem(item->m_obj->m_guid);
CGTradeInfo::m_enchantingItem = item->m_obj->m_guid;
}
}
// VERIFY: 8e40c12a manual
// OFFSET: 0x00586DC0
void CGTradeInfo::OnTradeUpdated(const TRADE_ITEM* items) {
CGTradeInfo::PlayerAccept();
for (int32_t i = 0; i < 7; i++) {
const TRADE_ITEM& item = items[i];
int32_t socketsChanged = 0;
for (uint32_t j = 0; j < 3; j++) {
if (CGTradeInfo::m_targetSocketEnchants[i][j] != item.m_socketEnchants[j]) {
socketsChanged = 1;
break;
}
}
if (CGTradeInfo::m_targetItemID[i] == item.m_itemID && CGTradeInfo::m_targetCount[i] == item.m_count && CGTradeInfo::m_targetEnchant[i] == item.m_enchant && !socketsChanged && CGTradeInfo::m_targetCreator[i] == item.m_creator && CGTradeInfo::m_targetWrapped[i] == item.m_wrapped && CGTradeInfo::m_targetGiftCreator[i] == item.m_giftCreator && CGTradeInfo::m_targetSpellCharges[i] == item.m_spellCharges && CGTradeInfo::m_targetSuffixFactor[i] == item.m_suffixFactor && CGTradeInfo::m_targetRandomPropertyID[i] == item.m_randomPropertyID && CGTradeInfo::m_targetLockID[i] == item.m_lockID && CGTradeInfo::m_targetMaxDurability[i] == item.m_maxDurability && CGTradeInfo::m_targetDurability[i] == item.m_durability) {
continue;
}
CGTradeInfo::m_targetItemID[i] = item.m_itemID;
CGTradeInfo::m_targetCount[i] = item.m_count;
CGTradeInfo::m_targetEnchant[i] = item.m_enchant;
CGTradeInfo::m_targetSocketEnchants[i][0] = item.m_socketEnchants[0];
CGTradeInfo::m_targetSocketEnchants[i][1] = item.m_socketEnchants[1];
CGTradeInfo::m_targetSocketEnchants[i][2] = item.m_socketEnchants[2];
CGTradeInfo::m_targetCreator[i] = item.m_creator;
CGTradeInfo::m_targetWrapped[i] = item.m_wrapped;
CGTradeInfo::m_targetLockID[i] = item.m_lockID;
CGTradeInfo::m_targetGiftCreator[i] = item.m_giftCreator;
CGTradeInfo::m_targetSpellCharges[i] = item.m_spellCharges;
CGTradeInfo::m_targetSuffixFactor[i] = item.m_suffixFactor;
CGTradeInfo::m_targetRandomPropertyID[i] = item.m_randomPropertyID;
CGTradeInfo::m_targetMaxDurability[i] = item.m_maxDurability;
CGTradeInfo::m_targetDurability[i] = item.m_durability;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_TARGET_ITEM_CHANGED, "%d", i + 1);
if (i == 6 && CGTradeInfo::m_enchantingItem) {
CGGameUI::UnlockItem(CGTradeInfo::m_enchantingItem);
CGTradeInfo::m_enchantingItem = WOWGUID();
}
}
if (CGTradeInfo::unk_BFA668 != Trade_C_GetEnchantSpell(0)) {
CGTradeInfo::unk_BFA668 = Trade_C_GetEnchantSpell(0);
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_TARGET_ITEM_CHANGED, "%d", 7);
}
if (CGTradeInfo::unk_BFA66C != Trade_C_GetEnchantSpell(1)) {
CGTradeInfo::unk_BFA66C = Trade_C_GetEnchantSpell(1);
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_PLAYER_ITEM_CHANGED, "%d", 7);
}
if (CGTradeInfo::unk_BFA670 != static_cast<int32_t>(CGTradeInfo::GetPlayerTradeMoney())) {
CGTradeInfo::unk_BFA670 = CGTradeInfo::GetPlayerTradeMoney();
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_TRADE_MONEY, nullptr);
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_MONEY, nullptr);
}
if (CGTradeInfo::unk_BFA674 != static_cast<int32_t>(CGTradeInfo::GetTargetTradeMoney())) {
CGTradeInfo::unk_BFA674 = CGTradeInfo::GetTargetTradeMoney();
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_MONEY_CHANGED, nullptr);
}
}
// VERIFY: c3a090dc auto
// OFFSET: 0x005870A0
void CGTradeInfo::SetTradePartner(WOWGUID partner, int32_t a2) {
if (!partner) {
if (CGTradeInfo::m_tradingPlayer) {
if (CGTradeInfo::m_enchantingItem) {
CGGameUI::UnlockItem(CGTradeInfo::m_enchantingItem);
CGTradeInfo::m_enchantingItem = WOWGUID();
}
CGTradeInfo::m_supressMoneyEvent = a2;
CGGameUI::ClearInteractTarget(CGTradeInfo::m_tradingPlayer, 0);
CGTradeInfo::m_tradingPlayer = WOWGUID();
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_CLOSED, nullptr);
}
Trade_C_CancelTrade();
return;
}
CGGameUI::SetInteractTarget(partner);
CGTradeInfo::m_tradingPlayer = partner;
CGTradeInfo::m_playerAccepted = 0;
CGTradeInfo::m_targetAccepted = 0;
CGTradeInfo::unk_BFA668 = 0;
CGTradeInfo::unk_BFA66C = 0;
CGTradeInfo::unk_BFA670 = 0;
CGTradeInfo::unk_BFA674 = 0;
CGTradeInfo::m_supressMoneyEvent = 0;
for (uint32_t i = 0; i < 7; i++) {
CGTradeInfo::m_targetEnchant[i] = 0;
CGTradeInfo::m_targetCount[i] = 0;
CGTradeInfo::m_targetItemID[i] = 0;
CGTradeInfo::unk_BFA5DC[i] = 0;
CGTradeInfo::unk_BFA5E8[i] = WOWGUID();
CGTradeInfo::m_playerItems[i] = WOWGUID();
}
if (Trade_C_UseCursorItem()) {
if (CGGameUI::m_cursorMoney) {
if (CGTradeInfo::AddMoney(CGGameUI::m_cursorMoney)) {
CGGameUI::ClearCursor(1, 0);
CGTradeInfo::unk_BFA670 = CGTradeInfo::GetPlayerTradeMoney();
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_TRADE_MONEY, nullptr);
FrameScript_SignalEvent(SCRIPT_EVENT_PLAYER_MONEY, nullptr);
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_SHOW, nullptr);
return;
}
} else {
WOWGUID item;
WOWGUID container;
uint32_t slot;
CGGameUI::GetCursorItem(item, container, slot);
if (item && container) {
uint32_t index = 0;
CGItem_C* object = static_cast<CGItem_C*>(ClntObjMgrObjectPtr(item, TYPEMASK_ITEM, __FILE__, __LINE__));
if (object && object->IsBound()) {
index = 6;
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_POTENTIAL_BIND_ENCHANT, "%b", !object->IsBoundForTrade());
}
Trade_C_AddItem(item, container, static_cast<uint8_t>(slot), static_cast<uint8_t>(index));
CGGameUI::ClearCursor(0, 1);
CGTradeInfo::m_playerItems[index] = item;
CGTradeInfo::unk_BFA5E8[index] = container;
CGTradeInfo::unk_BFA5DC[index] = static_cast<uint8_t>(slot);
}
}
}
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_SHOW, nullptr);
}
// VERIFY: 15291c4e auto
// OFFSET: 0x005873E0
void CGTradeInfo::HandleTradeMessage(int32_t status, int32_t bagResult, int32_t target, int32_t itemId, uint8_t slot) {
switch (status) {
case 0:
case 5:
if (Trade_C_IsTradeRequested()) {
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(Trade_C_GetTradeTarget(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (unit) {
CGGameUI::DisplayError(ERR_PLAYER_BUSY_S, unit->GetUnitName(nullptr, 1));
}
}
break;
case 1:
if (!Trade_C_IsTradeRequested()) {
if (FriendList::s_friendList->IsIgnored(Trade_C_GetTradeTarget(), true)) {
Trade_C_PlayerIgnored();
} else {
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(Trade_C_GetTradeTarget(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (unit) {
if (unit->IsDeadOrGhost() || CGGameUI::m_inCinematic || !CGGameUI::m_hasControl || CGAuctionHouse::m_auctioneer) {
Trade_C_PlayerBusy();
} else if (CVar::Lookup("BlockTrades")->m_intValue) {
Trade_C_PlayerBusy();
CGGameUI::DisplayError(ERR_TRADE_BLOCKED_S, unit->GetUnitName(nullptr, 1));
} else {
Trade_C_BeginTrade();
}
}
}
}
break;
case 2:
CGTradeInfo::SetTradePartner(Trade_C_GetTradeTarget(), 0);
break;
case 3:
FrameScript_SignalEvent(SCRIPT_EVENT_TRADE_REQUEST_CANCEL, nullptr);
CGTradeInfo::UnlockTradeItems();
CGTradeInfo::SetTradePartner(WOWGUID(), 0);
CGGameUI::DisplayError(ERR_TRADE_CANCELLED);
break;
case 4:
SetTargetAccepted(1);
break;
case 6:
CGGameUI::DisplayError(ERR_GENERIC_NO_TARGET);
break;
case 7:
CGTradeInfo::PlayerAccept();
break;
case 8:
CGTradeInfo::UnlockTradeItems();
CGTradeInfo::SetTradePartner(WOWGUID(), 1);
CGGameUI::DisplayError(ERR_TRADE_COMPLETE);
break;
case 9:
SetTargetAccepted(0);
break;
case 10:
CGGameUI::DisplayError(ERR_TRADE_TOO_FAR);
break;
case 11:
CGGameUI::DisplayError(ERR_PLAYER_WRONG_FACTION);
break;
case 12:
CGTradeInfo::UnlockTradeItems();
if (bagResult == 84 && itemId) {
WOWGUID none = WOWGUID();
ItemStats_C* stats = g_itemDBCache.GetRecord(itemId, none, nullptr, nullptr, false);
if (stats) {
ItemLimitCategoryRec* category = g_itemLimitCategoryDB.GetRecord(stats->m_itemLimitCategory);
if (category) {
CGGameUI::DisplayError(static_cast<UIErrors>(CGTradeInfo::GetGameError(84, target)), category->m_quantity, category->m_name);
}
}
} else {
CGGameUI::DisplayError(static_cast<UIErrors>(CGTradeInfo::GetGameError(bagResult, target)));
}
CGTradeInfo::SetTradePartner(WOWGUID(), 0);
break;
case 14:
if (Trade_C_IsTradeRequested()) {
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(Trade_C_GetTradeTarget(), TYPEMASK_PLAYER, __FILE__, __LINE__));
if (unit) {
CGGameUI::DisplayError(ERR_IGNORING_YOU_S, unit->GetUnitName(nullptr, 1));
}
}
break;
case 15:
CGGameUI::DisplayError(ERR_GENERIC_STUNNED);
break;
case 16:
CGGameUI::DisplayError(ERR_TARGET_STUNNED);
break;
case 17:
CGGameUI::DisplayError(ERR_PLAYER_DEAD);
break;
case 18:
CGGameUI::DisplayError(ERR_TRADE_TARGET_DEAD);
break;
case 19:
CGGameUI::DisplayError(ERR_LOGGING_OUT);
break;
case 20:
CGGameUI::DisplayError(ERR_TARGET_LOGGING_OUT);
break;
case 21:
CGGameUI::DisplayError(ERR_RESTRICTED_ACCOUNT);
break;
case 22:
CGGameUI::DisplayError(ERR_TRADE_WRONG_REALM);
CGTradeInfo::DenyPlayerItem(slot);
break;
case 23:
CGGameUI::DisplayError(ERR_TRADE_NOT_ON_TAPLIST);
CGTradeInfo::DenyPlayerItem(slot);
break;
}
}
// VERIFY: bbebe902 manual
// OFFSET: 0x005877B0
bool CGTradeInfo::AddPlayerItem(WOWGUID item, WOWGUID container, uint8_t slot) {
CGItem_C* object = static_cast<CGItem_C*>(ClntObjMgrObjectPtr(item, TYPEMASK_ITEM, __FILE__, __LINE__));
uint32_t index = 0;
if (!object) {
return false;
}
if (object->IsBound()) {
WOWGUID none = WOWGUID();
ItemStats_C* stats = g_itemDBCache.GetRecord(object->m_obj->m_entryID, none, nullptr, nullptr, false);
if (stats && stats->m_bonding == 4) {
CGGameUI::DisplayError(ERR_TRADE_QUEST_ITEM);
return false;
}
if (CGTradeInfo::m_playerItems[6]) {
return false;
}
index = 6;
} else {
while (CGTradeInfo::m_playerItems[index]) {
if (++index >= 6) {
return false;
}
}
}
if (object->m_obj->m_type & TYPEMASK_CONTAINER) {
const CGBag_C* bag = object->GetBag();
if (bag) {
if (bag->GetNumItems()) {
CGGameUI::DisplayError(ERR_TRADE_BAG);
return false;
}
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (static_cast<uint32_t>(player->GetBag()->FindItemSlot(object) - 19) <= 3) {
CGGameUI::DisplayError(ERR_TRADE_EQUIPPED_BAG);
return false;
}
}
}
CGTradeInfo::SetPlayerItem(index, item, container, slot);
CGGameUI::LockItem(item);
SndInterfacePlayItemSound(1, object);
return true;
}
// VERIFY: 20baf230 manual
// OFFSET: 0x005880C0
void CGTradeInfo::LeaveWorld() {
CGTradeInfo::UnlockTradeItems();
CGTradeInfo::SetTradePartner(WOWGUID(), 0);
Trade_C_CancelTrade();
}
+31 -4
View File
@@ -9,9 +9,28 @@ class CGItem_C;
struct lua_State;
struct PlayerTradeState {
/* 0000 */ uint32_t unk_0000[3];
/* 000C */ uint32_t m_money;
/* 0010 */ uint32_t m_targetMoney;
/* 0000 */ uint32_t m_tradeId;
/* 0004 */ uint32_t m_stateIndex[2];
/* 000C */ uint32_t m_money[2];
};
struct TRADE_ITEM {
/* 0000 */ int32_t m_itemID;
/* 0004 */ int32_t m_displayID;
/* 0008 */ int32_t m_count;
/* 000C */ int32_t m_enchant;
/* 0010 */ int32_t m_socketEnchants[3];
/* 001C */ uint32_t unk_001C;
/* 0020 */ WOWGUID m_creator;
/* 0028 */ int32_t m_wrapped;
/* 002C */ uint32_t unk_002C;
/* 0030 */ WOWGUID m_giftCreator;
/* 0038 */ int32_t m_spellCharges;
/* 003C */ int32_t m_suffixFactor;
/* 0040 */ int32_t m_randomPropertyID;
/* 0044 */ int32_t m_lockID;
/* 0048 */ int32_t m_maxDurability;
/* 004C */ int32_t m_durability;
};
class CGTradeInfo {
@@ -19,7 +38,7 @@ class CGTradeInfo {
static void SetTradePartner(WOWGUID partner, int32_t a2);
static void SetEnchantingItem(CGItem_C* item);
static bool IsItemBeingTraded(WOWGUID item);
static void AddPlayerItem(WOWGUID item, WOWGUID container, uint32_t slot);
static bool AddPlayerItem(WOWGUID item, WOWGUID container, uint8_t slot);
static WOWGUID m_enchantingItem;
static void EnterWorld();
static uint32_t GetPlayerTradeMoney();
@@ -59,6 +78,14 @@ class CGTradeInfo {
static void UpdatePlayerItem(WOWGUID guid);
static void AddCursorItem(int32_t bound);
static void InitiateTrade(WOWGUID guid, int32_t a2);
static void UnlockTradeItems();
static void DenyPlayerItem(int32_t slot);
static int32_t GetGameError(int32_t error, int32_t target);
static void PlayerAccept();
static void RemovePlayerItem(WOWGUID item);
static void OnTradeUpdated(const TRADE_ITEM* items);
static void HandleTradeMessage(int32_t status, int32_t bagResult, int32_t target, int32_t itemId, uint8_t slot);
static void LeaveWorld();
};
void TradeInfoRegisterScriptFunctions();
+637
View File
@@ -1,4 +1,641 @@
#include "UIMacroOptions.h"
#include <cstring>
#include "Engine/Source/Frame/CSimpleButton.h"
#include "Engine/Source/Frame/CSimpleTop.h"
#include "Engine/Source/FrameScript/FrameScript.h"
#include "Engine/Source/Os/TimeManager.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/DB/DBClient/DBClient.h"
#include "WoW/Source/DB/Rec/CreatureFamilyRec.h"
#include "WoW/Source/DB/Rec/SpellRec.h"
#include "WoW/Source/DB/Rec/VehicleSeatRec.h"
#include "WoW/Source/Object/ObjectClient/Player_C.h"
#include "WoW/Source/Object/ObjectClient/Unit_C.h"
#include "WoW/Source/Object/ObjectClient/Vehicle_C.h"
#include "WoW/Source/ObjectMgrClient/ObjectMgrClient.h"
#include "WoW/Source/UIUtil/Tooltip.h"
#include "WoW/Source/Ui/ActionBarFrame.h"
#include "WoW/Source/Ui/GameUI.h"
#include "WoW/Source/Ui/MacroConditions.h"
#include "WoW/Source/Ui/MacroSubstring.h"
#include "WoW/Source/Ui/PartyFrame.h"
#include "WoW/Source/Ui/PetInfo.h"
#include "WoW/Source/Ui/RaidInfo.h"
#include "WoW/Source/Ui/TalentInfo.h"
#include "WoW/Source/Ui/UIBindings.h"
#include "WoW/Source/Ui/UIMacros.h"
void InitializeMacroOptions() {
}
// VERIFY: a046a90a auto
// OFFSET: 0x005EED70
int32_t EvaluateExists(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGObject_C* object = ClntObjMgrObjectPtr(*unit, TYPEMASK_OBJECT, __FILE__, __LINE__);
int32_t exists = (object && object->CanBeTargetted()) || CGGameUI::IsRaidMemberOrPet(*unit);
if (args->m_count) {
return exists == args->m_data->ToNumber();
}
return exists;
}
// VERIFY: 44e9953c auto
// OFFSET: 0x005EEDE0
int32_t EvaluateParty(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
int32_t party = CGPartyInfo::IsPlayerOrPetInParty(*unit);
if (args->m_count) {
return party == args->m_data->ToNumber();
}
return party;
}
// VERIFY: e207a633 auto
// OFFSET: 0x005EEE20
int32_t EvaluateRaid(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
int32_t raid = CGPartyInfo::IsPlayerOrPetInParty(*unit) || CGRaidInfo::IsPlayerOrPetInRaid(*unit);
if (args->m_count) {
return raid == args->m_data->ToNumber();
}
return raid;
}
// VERIFY: efb4b366 manual
// OFFSET: 0x005EEE70
int32_t EvaluateFlyable(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(*unit, TYPEMASK_UNIT, __FILE__, __LINE__));
bool flyable = player ? player->IsInFlyableZone(1) : IsInFlyableArea() != 0;
if (args->m_count) {
return flyable == args->m_data->ToNumber();
}
return flyable;
}
// VERIFY: 21b64279 manual
// OFFSET: 0x005EEED0
int32_t EvaluateGroup(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
if (!args->m_count) {
return CGPartyInfo::GetNumPartyMembers() || CGRaidInfo::m_numMembers;
}
for (uint32_t i = args->m_count; i; i--) {
MacroSubstring& arg = args->m_data[i - 1];
if (arg == "party") {
return CGPartyInfo::GetNumPartyMembers() != 0;
}
if (arg == "raid") {
return CGRaidInfo::m_numMembers != 0;
}
}
return 0;
}
// VERIFY: 4dbe7b4a manual
// OFFSET: 0x005EF0D0
int32_t EvaluateButton(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
const char* button = CSimpleTop::s_instance->m_mouseButtonName;
const char* macroButton = CGUIMacros::m_macroRunning;
if (!button && !macroButton) {
button = "LeftButton";
}
if (!args->m_count) {
return 0;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
char name[1024];
if (*arg.m_start >= '0' && *arg.m_start <= '9') {
uint32_t index = 0;
for (const char* c = arg.m_start; c < arg.m_end && *c >= '0' && *c <= '9'; c++) {
index = *c + 10 * index - '0';
}
SStrCopy(name, GetMouseButtonName(IndexToMouseButton(index)), sizeof(name));
} else {
uint32_t length = arg.m_end - arg.m_start;
if (length > 1023) {
length = 1023;
}
memcpy(name, arg.m_start, length);
name[length] = '\0';
}
if ((button && !SStrCmpUTF8I(name, button, 0x7FFFFFFF)) || (macroButton && !SStrCmpUTF8I(name, macroButton, 0x7FFFFFFF))) {
return 1;
}
}
return 0;
}
// VERIFY: ecd36a2e manual
// OFFSET: 0x005EF200
int32_t EvaluateActionBar(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
if (!args->m_count) {
return 0;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
uint32_t page = 0;
for (const char* c = arg.m_start; c < arg.m_end && *c >= '0' && *c <= '9'; c++) {
page = *c + 10 * page - '0';
}
if (page == CGActionBar::m_currentPage + 1) {
return 1;
}
}
return 0;
}
// VERIFY: a88db050 manual
// OFFSET: 0x005EF270
int32_t EvaluateBonusBar(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
if (!args->m_count) {
return 0;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
int32_t offset = 0;
for (const char* c = arg.m_start; c < arg.m_end && *c >= '0' && *c <= '9'; c++) {
offset = *c + 10 * offset - '0';
}
if (offset == CGActionBar::m_bonusBarOffset) {
return 1;
}
}
return 0;
}
// VERIFY: fd102a98 manual
// OFFSET: 0x005EF2E0
int32_t EvaluateSpec(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
uint32_t group = CGTalentInfo::GetActiveTalentGroup(0) + 1;
if (!args->m_count) {
return 0;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
uint32_t spec = 0;
for (const char* c = arg.m_start; c < arg.m_end && *c >= '0' && *c <= '9'; c++) {
spec = *c + 10 * spec - '0';
}
if (spec == group) {
return 1;
}
}
return 0;
}
// VERIFY: c6220e35 auto
// OFFSET: 0x005EF360
static VehicleSeatRec* GetVehicleSeatRec(const WOWGUID* guid) {
CGUnit_C* unit = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(*guid, TYPEMASK_UNIT, __FILE__, __LINE__));
if (unit) {
if (!unit->HasVehicleTransport()) {
return nullptr;
}
WOWGUID transportGuid;
transportGuid.m_guid = unit->GetTransportGUID();
if (!transportGuid) {
return nullptr;
}
CGUnit_C* transport = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(transportGuid, TYPEMASK_UNIT, __FILE__, __LINE__));
if (!transport || !transport->m_vehicle) {
return nullptr;
}
return transport->m_vehicle->GetVehicleSeatRec(unit->m_movementData.m_transportSeat);
}
CGPartyMemberState* state = CGPartyMemberStateRepository::GetState(*guid);
if (state && state->m_vehicleSeatId > 0) {
return g_vehicleSeatDB.GetRecord(state->m_vehicleSeatId);
}
return nullptr;
}
// VERIFY: 21442e4c auto
// OFFSET: 0x005EF430
int32_t EvaluateVehicleUI(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
WOWGUID guid = ClntObjMgrGetActivePlayer();
VehicleSeatRec* seat = GetVehicleSeatRec(&guid);
if (seat) {
return seat->m_flags & 0x20000000;
}
return 0;
}
// VERIFY: d471b39f auto
// OFFSET: 0x005EF470
int32_t EvaluateUnitHasVehicleUI(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
VehicleSeatRec* seat = GetVehicleSeatRec(unit);
if (seat) {
return seat->m_flags & 0x20000000;
}
return 0;
}
// VERIFY: 4bc45a8e manual
// OFFSET: 0x005EF490
int32_t EvaluateCursor(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
if (!CSimpleTop::s_instance->m_allowProtectedActions) {
return 0;
}
const char* type;
switch (CGGameUI::m_cursorItemType) {
case 1:
case 7:
case 9:
case 11:
type = "item";
break;
case 2:
type = "money";
break;
case 3:
type = "spell";
break;
case 5:
type = "merchant";
break;
case 8:
type = "macro";
break;
case 12:
type = "guildbankmoney";
break;
case 13:
type = "equipmentset";
break;
default:
return 0;
}
if (!args->m_count) {
return 1;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
char text[1024];
uint32_t length = arg.m_end - arg.m_start;
if (length > 1023) {
length = 1023;
}
memcpy(text, arg.m_start, length);
text[length] = '\0';
if (!SStrCmpI(text, type, 0x7FFFFFFF)) {
return 1;
}
}
return 0;
}
// VERIFY: 70e118bd manual
// OFFSET: 0x005EF710
int32_t EvaluateCombat(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t combat;
if (player && (player->m_unit->m_unitFieldFlags & 0x80000)) {
combat = 1;
} else {
CGUnit_C* pet = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(CGPetInfo::GetPet(0), TYPEMASK_UNIT, __FILE__, __LINE__));
combat = pet && (pet->m_unit->m_unitFieldFlags & 0x80000);
}
if (args->m_count) {
return combat == args->m_data->ToNumber();
}
return combat;
}
// VERIFY: 606170a1 auto
// OFFSET: 0x005EF7B0
int32_t EvaluateHelp(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
CGUnit_C* target = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(*unit, TYPEMASK_UNIT, __FILE__, __LINE__));
int32_t help = player && target && player->CanAssist(target, false);
if (args->m_count) {
return help == args->m_data->ToNumber();
}
return help;
}
// VERIFY: 2f3abe7a auto
// OFFSET: 0x005EF830
int32_t EvaluateHarm(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
CGUnit_C* target = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(*unit, TYPEMASK_UNIT, __FILE__, __LINE__));
int32_t harm = player && target && player->CanAttack(target);
if (args->m_count) {
return harm == args->m_data->ToNumber();
}
return harm;
}
// VERIFY: 6e6f1e87 manual
// OFFSET: 0x005EF8B0
int32_t EvaluateDead(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGUnit_C* object = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(*unit, TYPEMASK_UNIT, __FILE__, __LINE__));
int32_t dead;
if (object) {
if (object->m_unit->m_unitFieldHealth <= 0) {
dead = 1;
} else if ((object->m_unit->m_unitDynamicFlags & 0x20) && !CGGameUI::IsRaidMemberOrPet(object->m_obj->m_guid)) {
dead = 1;
} else if ((object->m_obj->m_type & TYPEMASK_PLAYER) && (static_cast<CGPlayer_C*>(object)->m_player->m_playerFlags & 0x10)) {
dead = 1;
} else {
dead = 0;
}
} else {
CGPartyMemberState* state = CGPartyMemberStateRepository::GetState(*unit);
dead = state ? (state->m_flags & 0xC) : 0;
}
if (args->m_count) {
return dead == args->m_data->ToNumber();
}
return dead;
}
// VERIFY: 06e51fae manual
// OFFSET: 0x005EF980
int32_t EvaluateIndoors(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t indoors = player && !player->IsOutdoors();
if (args->m_count) {
return indoors == args->m_data->ToNumber();
}
return indoors;
}
// VERIFY: 1feef5e1 manual
// OFFSET: 0x005EF9E0
int32_t EvaluateOutdoors(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t outdoors = player && player->IsOutdoors();
if (args->m_count) {
return outdoors == args->m_data->ToNumber();
}
return outdoors;
}
// VERIFY: 96f9b74e manual
// OFFSET: 0x005EFA40
int32_t EvaluateSwimming(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t swimming = player && (player->m_clientFlags & 0x200000);
if (args->m_count) {
return swimming == args->m_data->ToNumber();
}
return swimming;
}
// VERIFY: b5e8db05 manual
// OFFSET: 0x005EFAA0
int32_t EvaluateFlying(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t flying = player && (player->m_movement->m_flags & 0x2000000);
if (args->m_count) {
return flying == args->m_data->ToNumber();
}
return flying;
}
// VERIFY: 8a66275e manual
// OFFSET: 0x005EFB00
int32_t EvaluateMounted(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t mounted = player && player->m_mountDisplayId > 0 && !(player->m_clientFlags & 0x10000000);
if (args->m_count) {
return mounted == args->m_data->ToNumber();
}
return mounted;
}
// VERIFY: 53625612 manual
// OFFSET: 0x005EFB70
int32_t EvaluateStealth(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
int32_t stealth = player && (player->m_unit->m_unitFieldBytes1[2] & 0x2);
if (args->m_count) {
return stealth == args->m_data->ToNumber();
}
return stealth;
}
// VERIFY: bf238021 manual
// OFFSET: 0x005EFBD0
int32_t EvaluatePet(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (!player) {
return 0;
}
const WOWGUID* petGuid = player->m_unit->m_unitFieldCharm.m_guid ? &player->m_unit->m_unitFieldCharm : &player->m_unit->m_unitFieldSummon;
CGUnit_C* pet = static_cast<CGUnit_C*>(ClntObjMgrObjectPtr(*petGuid, TYPEMASK_UNIT, __FILE__, __LINE__));
if (!pet) {
return 0;
}
if (!args->m_count) {
return 1;
}
char name[1024] = "";
char family[1024] = "";
SStrCopy(name, pet->GetUnitName(nullptr, 1), sizeof(name));
uint32_t familyId = pet->GetCreatureFamily();
if (familyId) {
CreatureFamilyRec* rec = g_creatureFamilyDB.GetRecord(familyId);
if (rec) {
SStrCopy(family, rec->m_name, sizeof(family));
}
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
char text[1024];
uint32_t length = arg.m_end - arg.m_start;
if (length > 1023) {
length = 1023;
}
memcpy(text, arg.m_start, length);
text[length] = '\0';
if (!SStrCmpUTF8I(text, name, 0x7FFFFFFF) || !SStrCmpUTF8I(text, family, 0x7FFFFFFF)) {
return 1;
}
}
return 0;
}
// VERIFY: 0657ba53 manual
// OFFSET: 0x005EFD70
int32_t EvaluateEquipped(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (!player) {
return 0;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
char text[1024];
uint32_t length = arg.m_end - arg.m_start;
if (length > 1023) {
length = 1023;
}
memcpy(text, arg.m_start, length);
text[length] = '\0';
int32_t inventoryType = -1;
for (int32_t j = 0; j < 29; j++) {
if (!SStrCmpI(text, s_inventoryTypeTokens[j], 0x7FFFFFFF) || !SStrCmpUTF8I(text, FrameScript_GetText(s_inventoryTypeTokens[j], -1, GENDER_NOT_APPLICABLE), 0x7FFFFFFF)) {
inventoryType = j;
break;
}
}
WOWGUID container;
uint32_t slot;
CGItem_C* item;
if (inventoryType > 0) {
item = player->m_bag.FindItem(&CanEquipInSlotCallback, &inventoryType, container, slot, 1);
} else {
item = player->m_bag.FindItem(&FindItemClassTypeCallback, text, container, slot, 1);
}
if (item) {
return 1;
}
}
return 0;
}
// VERIFY: 84436a9f manual
// OFFSET: 0x005EFEB0
int32_t EvaluateChanneling(const WOWGUID* unit, const TSGrowableArray<MacroSubstring>* args) {
CGPlayer_C* player = ClntObjMgrGetActivePlayerObj();
if (!player) {
return 0;
}
uint32_t now = OsGetAsyncTimeMs();
SpellRec spell;
if (!g_spellDB.GetRecord(player->m_channelSpellId, &spell) || static_cast<int32_t>(now - player->m_channelEndTime) >= 0) {
return 0;
}
if (!args->m_count) {
return 1;
}
for (uint32_t i = args->m_count; i; i--) {
const MacroSubstring& arg = args->m_data[i - 1];
char text[1024];
uint32_t length = arg.m_end - arg.m_start;
if (length > 1023) {
length = 1023;
}
memcpy(text, arg.m_start, length);
text[length] = '\0';
if (!SStrCmpUTF8I(text, spell.m_name, 0x7FFFFFFF)) {
return 1;
}
}
return 0;
}
+77 -1
View File
@@ -292,6 +292,82 @@ void CGWorldFrame::GetCameraPosition(C3Vector* position) {
*position = CGWorldFrame::s_currentWorldFrame->m_camera->m_position;
}
// VERIFY: 1fde8745 auto
// OFFSET: 0x004F66C0
void CGWorldFrame::OnLayerTrackTerrain(const HITTESTRESULT& result) {
if (!Spell_C_IsTargeting() || !Spell_C_CanTargetTerrain()) {
CursorResetMode();
this->HandleSpriteTrack(WOWGUID());
return;
}
s_spellShadowPos = result.m_point;
CTerrainClickEvent evt;
evt.m_point = s_spellShadowPos;
evt.m_guid = WOWGUID();
if ((result.m_guid.m_guid & 0xF000000000000000ull) == 0x1000000000000000ull && (result.m_guid.m_guid & 0x0FF0000000000000ull) == 0x0FC0000000000000ull) {
CGObject_C* transport = ClntObjMgrObjectPtr(result.m_guid, TYPEMASK_OBJECT, __FILE__, __LINE__);
if (transport) {
evt.m_guid = result.m_guid;
s_spellShadowPos *= transport->GetMatrix();
}
}
Spell_C_SetCursorWorldObjectPosition(s_spellShadowPos);
switch (Spell_C_HandleTerrainRay(evt, true)) {
case 0: {
s_spellShadowStyle = 0;
float radius = Spell_C_GetSpellRadius();
s_spellShadowSize = radius > 20.0f ? 20.0f : Spell_C_GetSpellRadius();
CursorSetMode(2);
break;
}
case 1:
s_spellShadowStyle = 1;
s_spellShadowSize = 0.0f;
CursorSetMode(28);
break;
case 2:
s_spellShadowStyle = 3;
s_spellShadowSize = 0.0f;
CursorSetMode(28);
break;
}
CMapEntity* entity = Spell_C_GetSpellWorldObject();
if (!entity) {
return;
}
CM2Model* model = Spell_C_GetCursorWorldObjectModel();
CAaBox box;
box.b = C3Vector(0.0f, 0.0f, 0.0f);
box.t = C3Vector(0.0f, 0.0f, 0.0f);
CAaSphere sphere = { { 0.0f, 0.0f, 0.0f }, 0.0f };
C3Vector center = { 0.0f, 0.0f, 0.0f };
if (model->IsLoaded(0, 0)) {
box = model->GetBoundingBox();
sphere = model->GetBoundingSphere();
center = sphere.c;
}
C44Matrix matrix;
const C3Vector& position = Spell_C_GetCursorWorldObjectPosition();
matrix.d0 = position.x;
matrix.d1 = position.y;
matrix.d2 = position.z;
matrix.RotateAroundZ(Spell_C_GetCursorWorldObjectFacing());
CMap::ObjectUpdate(entity, matrix, box, sphere, center, false, 0xFFFFFFFF);
World::ObjectSetHidden(entity, s_spellShadowStyle != 0);
}
// VERIFY: 364a9bc8 auto
// OFFSET: 0x004F6680
void CGWorldFrame::GetCameraFacing(C3Vector* facing) {
@@ -2411,7 +2487,7 @@ int32_t CGWorldFrame::SpellEffectEnumProc(void* param, uint32_t flags, uint64_t
}
// VERIFY: 57ad68af manual
// OFFSET: 0x004FA390
// OFFSET: [0x004FA390, 0x004FAF60]
CGWorldFrame::~CGWorldFrame() {
EventUnregisterEx(EVENT_ID_IDLE, CGWorldFrame::Update, this, 0xFFFFFFFF);
EventSetMouseMode(MOUSE_MODE_NORMAL, 0);
+46 -25
View File
@@ -64,7 +64,7 @@ int32_t CGWorldMap::m_currentDungeonMap = -1;
int32_t CGWorldMap::m_currentOrphanZone = -1;
// STATIC: 0x00BE8F08
TSFixedArray<WorldMapContinent> CGWorldMap::m_continents;
TSFixedArray<WorldMapContinentInfo> CGWorldMap::m_continents;
// STATIC: 0x00BE8F14
TSGrowableArray<WorldMapLandmarkInfo> CGWorldMap::m_landmarks;
@@ -105,7 +105,7 @@ static int32_t QSortZones(const void* a, const void* b) {
return 0;
}
// VERIFY: df6fb7b8 manual
// VERIFY: 0c51c054 manual
// OFFSET: 0x00547EB0
void CGWorldMap::InitializeGame() {
uint32_t numAreas = g_worldMapAreaDB.m_numRecords;
@@ -130,7 +130,7 @@ void CGWorldMap::InitializeGame() {
continue;
}
WorldMapContinent* continent = &CGWorldMap::m_continents.m_data[continentIndex];
WorldMapContinentInfo* continent = &CGWorldMap::m_continents.m_data[continentIndex];
continent->m_mapID = area->m_mapID;
continent->m_areaID = area->m_id;
@@ -298,14 +298,14 @@ void CGWorldMap::InitializeGame() {
CGWorldMap::m_overlays.SetCount(32);
}
// VERIFY: 23c6a265 manual
// VERIFY: fbeb32e6 manual
// OFFSET: 0x00543770
int32_t CGWorldMap::GetCurrentAreaID() {
if (CGWorldMap::m_currentContinent < 0) {
return CGWorldMap::m_currentOrphanZone;
}
WorldMapContinent& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
if (CGWorldMap::m_currentZone < 0) {
return continent.m_areaID;
@@ -324,14 +324,14 @@ uint32_t CGWorldMap::GetNumZones(uint32_t continent) {
return CGWorldMap::m_continents.m_data[continent].m_zones.m_count;
}
// VERIFY: 3796269a manual
// VERIFY: e30bfe4c manual
// OFFSET: 0x00543860
int32_t CGWorldMap::GetZoneID(uint32_t continent, uint32_t zone) {
if (continent >= CGWorldMap::m_continents.m_count) {
return -1;
}
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
if (zone >= entry.m_zones.m_count) {
return -1;
@@ -438,7 +438,22 @@ WorldMapContinentRec* CGWorldMap::GetContinentRec(int32_t mapID) {
return nullptr;
}
// VERIFY: ef7cf11a manual
// VERIFY: a18ad447 auto
// OFFSET: 0x005440E0
bool CGWorldMap::GetContinentPosition(float x, float y, int32_t mapID, float* mapX, float* mapY) {
WorldMapContinentRec* rec = CGWorldMap::GetContinentRec(mapID);
if (!rec) {
return false;
}
float top = rec->m_continentOffset[1] * 0.023952097f + 0.5f - x * 0.000044910183f * rec->m_scale;
*mapX = rec->m_continentOffset[0] * 0.015968064f + 0.5f - y * 0.00002994012f * rec->m_scale;
*mapY = 1.0f - top;
return true;
}
// VERIFY: 3cedc975 manual
// OFFSET: 0x00544140
bool CGWorldMap::GetWorldPosition(const C3Vector& position, int32_t mapID, float* x, float* y, bool* outland, bool noClamp, int32_t dungeonMapID) {
*x = 0.0f;
@@ -473,7 +488,7 @@ bool CGWorldMap::GetWorldPosition(const C3Vector& position, int32_t mapID, float
return false;
}
WorldMapContinent& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
if (newMapID != continent.m_mapID) {
return false;
@@ -573,7 +588,7 @@ void CGWorldMap::GetPOIPosition(const AreaPOIRec* poi, float* x, float* y) {
}
}
// VERIFY: 616ba432 manual
// VERIFY: 0da742b3 manual
// OFFSET: 0x00546310
void CGWorldMap::SetMap(uint32_t continent, uint32_t zone, int32_t dungeonMap) {
if (continent < CGWorldMap::m_continents.m_count) {
@@ -661,7 +676,7 @@ void CGWorldMap::SetMap(uint32_t continent, uint32_t zone, int32_t dungeonMap) {
if (CGWorldMap::m_currentContinent < 0) {
mapAreaID = CGWorldMap::m_currentOrphanZone;
} else {
WorldMapContinent& current = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo& current = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
mapAreaID = CGWorldMap::m_currentZone < 0 ? current.m_areaID : current.m_zones.m_data[CGWorldMap::m_currentZone];
}
@@ -692,7 +707,7 @@ void CGWorldMap::SetMap(uint32_t continent, uint32_t zone, int32_t dungeonMap) {
FrameScript_SignalEvent(SCRIPT_EVENT_WORLD_MAP_UPDATE, nullptr);
}
// VERIFY: e1776515 manual
// VERIFY: 6566cbff manual
// OFFSET: 0x00547170
void CGWorldMap::SetMapToCurrentZone(int32_t debug) {
CGPlayer_C* player = static_cast<CGPlayer_C*>(ClntObjMgrObjectPtr(ClntObjMgrGetActivePlayer(), TYPEMASK_PLAYER, __FILE__, __LINE__));
@@ -797,7 +812,7 @@ void CGWorldMap::SetMapToCurrentZone(int32_t debug) {
double gridY = 0.5 - mapY * 0.000029296876;
if (gridX >= 0.0 && gridX < 1.0 && gridY >= 0.0 && gridY < 1.0) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
uint32_t zoneArea = entry.m_zoneMap[static_cast<int32_t>(gridX * 128.0)][static_cast<int32_t>(gridY * 128.0)];
uint32_t numZones = CGWorldMap::GetNumZones(continent);
@@ -819,7 +834,7 @@ void CGWorldMap::SetMapToCurrentZone(int32_t debug) {
}
}
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
int32_t zone = -1;
for (uint32_t i = 0; i < entry.m_zones.m_count; i++) {
@@ -954,7 +969,7 @@ void CGWorldMap::UpdateArrowFrames() {
}
}
// VERIFY: 46e10d7a manual
// VERIFY: 5c3545ab auto
// OFFSET: 0x00546190
int32_t CGWorldMap::GetNumDungeonLevels() {
int32_t count = 0;
@@ -965,7 +980,7 @@ int32_t CGWorldMap::GetNumDungeonLevels() {
}
if (CGWorldMap::m_currentContinent >= 0) {
WorldMapContinent& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo& continent = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
int32_t zone = CGWorldMap::m_currentZone < 0 ? continent.m_areaID : continent.m_zones.m_data[CGWorldMap::m_currentZone];
if (zone != CGWorldMap::m_currentOrphanZone) {
@@ -1151,7 +1166,7 @@ int32_t CGWorldMap::GetMapAreaFromPos(float x, float y) {
return CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent].m_zoneMap[static_cast<int32_t>(gridY * 128.0)][static_cast<int32_t>(gridX * 128.0)];
}
// VERIFY: 41ac249f manual
// VERIFY: adfb1fcc manual
// OFFSET: 0x00544420
int32_t CGWorldMap::GetMapHighlight(float x, float y) {
int32_t continent = CGWorldMap::m_currentContinent;
@@ -1171,7 +1186,7 @@ int32_t CGWorldMap::GetMapHighlight(float x, float y) {
}
for (uint32_t i = 0; i < CGWorldMap::m_continents.m_count; i++) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[i];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[i];
if (entry.unk_10024 && x >= entry.unk_10018 && x <= entry.unk_10020 && entry.unk_10014 <= y && entry.unk_1001C >= y) {
return entry.m_areaID;
@@ -1181,14 +1196,14 @@ int32_t CGWorldMap::GetMapHighlight(float x, float y) {
return 0;
}
// VERIFY: a4d7c462 auto
// VERIFY: 92e61c2c auto
// OFFSET: 0x005438A0
const char* CGWorldMap::GetZoneName(uint32_t continent, uint32_t zone) {
if (continent >= CGWorldMap::m_continents.m_count) {
return nullptr;
}
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
if (zone >= entry.m_zones.m_count) {
return nullptr;
@@ -1270,7 +1285,7 @@ void CGWorldMap::ClearArrowFrames() {
}
}
// VERIFY: 8f17368a manual
// VERIFY: 1acf1385 manual
// OFFSET: 0x00547A70
void CGWorldMap::SetDungeonLevel(int32_t level) {
if (CGWorldMap::m_currentOrphanZone < 0) {
@@ -1278,7 +1293,7 @@ void CGWorldMap::SetDungeonLevel(int32_t level) {
}
if (CGWorldMap::m_currentContinent >= 0) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[CGWorldMap::m_currentContinent];
int32_t zoneArea = CGWorldMap::m_currentZone < 0 ? entry.m_areaID : entry.m_zones.m_data[CGWorldMap::m_currentZone];
if (zoneArea != CGWorldMap::m_currentOrphanZone) {
@@ -1339,7 +1354,7 @@ void CGWorldMap::ShutdownGame() {
CGWorldMap::m_orphanZones.Clear();
}
// VERIFY: a323fb54 manual
// VERIFY: 51645fdc manual
// OFFSET: 0x005468F0
void CGWorldMap::ProcessClick(float x, float y) {
uint32_t continent = CGWorldMap::m_currentContinent;
@@ -1350,7 +1365,7 @@ void CGWorldMap::ProcessClick(float x, float y) {
if (continent == static_cast<uint32_t>(-1)) {
for (uint32_t i = 0; i < CGWorldMap::m_continents.Count(); i++) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[i];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[i];
if (entry.unk_10024 && x >= entry.unk_10018 && x <= entry.unk_10020 && entry.unk_10014 <= y && entry.unk_1001C >= y) {
CGWorldMap::SetMap(i, -1, -1);
@@ -1368,7 +1383,7 @@ void CGWorldMap::ProcessClick(float x, float y) {
}
for (uint32_t zone = 0; continent < CGWorldMap::m_continents.Count(); zone++) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
if (zone >= entry.m_zones.Count()) {
break;
@@ -1417,3 +1432,9 @@ bool WorldMapTransformPosition(int32_t mapID, float x, float y, int32_t* outMapI
return false;
}
// VERIFY: 1e793a0b auto
// OFFSET: 0x00547150
void CGWorldMap::LeaveWorld() {
ClntObjMgrUnsetObjMirrorHandler(ClntObjMgrGetActivePlayer(), ID_PLAYER, 0xDF4, PlayerExploredZonesUpdateHandler, nullptr);
}
+6 -4
View File
@@ -35,7 +35,7 @@ struct DebugElement {
/* 0068 */ int32_t unk_0068;
};
struct WorldMapContinent {
struct WorldMapContinentInfo {
/* 00000 */ int32_t m_mapID;
/* 00004 */ int32_t m_areaID;
/* 00008 */ TSFixedArray<int32_t> m_zones;
@@ -46,7 +46,7 @@ struct WorldMapContinent {
/* 10020 */ float unk_10020;
/* 10024 */ int32_t unk_10024;
WorldMapContinent();
WorldMapContinentInfo();
};
struct WorldMapLandmarkInfo {
@@ -67,7 +67,7 @@ class CGWorldMap {
static int32_t m_currentZone;
static int32_t m_currentDungeonMap;
static int32_t m_currentOrphanZone;
static TSFixedArray<WorldMapContinent> m_continents;
static TSFixedArray<WorldMapContinentInfo> m_continents;
static TSGrowableArray<WorldMapLandmarkInfo> m_landmarks;
static TSGrowableArray<int32_t> m_overlays;
static TSFixedArray<int32_t> m_orphanZones;
@@ -81,6 +81,8 @@ class CGWorldMap {
static void ProcessClick(float x, float y);
static void SetDungeonLevel(int32_t level);
static void EnterWorld();
static void LeaveWorld();
static bool GetContinentPosition(float x, float y, int32_t mapID, float* mapX, float* mapY);
static void InitializeGame();
static void ShutdownGame();
static void ClearArrowFrames();
@@ -109,7 +111,7 @@ void WorldMapRegisterScriptFunctions();
void WorldMapUnregisterScriptFunctions();
// INLINED
inline WorldMapContinent::WorldMapContinent() {
inline WorldMapContinentInfo::WorldMapContinentInfo() {
this->unk_10014 = 0.0f;
this->unk_10018 = 0.0f;
this->unk_1001C = 0.0f;
+4 -4
View File
@@ -925,7 +925,7 @@ static int32_t Script_UpdateWorldMapArrowFrames(lua_State* L) {
return 0;
}
// VERIFY: d8fa6699 manual
// VERIFY: ab8c4937 manual
// OFFSET: 0x00546A90
static int32_t Script_ZoomOut(lua_State* L) {
int32_t parent;
@@ -973,7 +973,7 @@ static int32_t Script_ZoomOut(lua_State* L) {
}
for (uint32_t continent = 0; continent < CGWorldMap::m_continents.Count(); continent++) {
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
if (entry.m_mapID != parentArea->m_mapID) {
continue;
@@ -990,7 +990,7 @@ static int32_t Script_ZoomOut(lua_State* L) {
return 0;
}
// VERIFY: d5b636f3 manual
// VERIFY: 1bf5645d manual
// OFFSET: 0x00546C50
static int32_t Script_SetMapByID(lua_State* L) {
if (!lua_isnumber(L, 1)) {
@@ -1011,7 +1011,7 @@ static int32_t Script_SetMapByID(lua_State* L) {
displayMapID = area->m_mapID;
}
WorldMapContinent& entry = CGWorldMap::m_continents.m_data[continent];
WorldMapContinentInfo& entry = CGWorldMap::m_continents.m_data[continent];
if (entry.m_mapID != displayMapID) {
continue;