GMS现代化实时倒计时显示（BUFF持续时间和快捷栏冷却时间）

shawn

本教程为GMS低版本客户端添加了现代化的实时倒计时显示，包括：
1. 右上角Buff图标持续时间倒计时（剩余buff时间）
2. 快捷栏技能CD倒计时（剩余冷却时间）
3. 自动在分钟/秒之间切换，倒计时在≥1分钟时在左下角显示分钟数，<1分钟时在正中间显示秒数

GMS在v233版本Destiny: Remastered版本（2022/6/15）中首次引入了居中的秒数倒计时显示，以下是对比图：
GMSv92现代化效果图：

GMS Reboot v233+对比参考图：


前置说明：
1. Buff图标持续时间倒计时是在kinoko(https://github.com/iw2d/kinoko_client)或者kaentake(https://github.com/iw2d/kaentake)的实现基础上进行修改的。并且下面的代码中有许多类定义、ztl、宏定义都来自于kinoko。因此，如果你没有在使用这两套client edit的话，你可能需要先花点时间引入相关的部分。
2. 代码中的函数地址或类偏移均为v92版本的硬编码作为例子。如果你要迁移到其他版本，需要自行查找对应的地址。当然，如果你有相应版本idb作为参照的话，这不会是什么太难的事。
3. 附件请解压出UIWindow99.img并放到UI.wz或者Data/UI下（取决于是wz客户端还是img客户端），里面是v233+版本的数字图片。

核心原理：
主要包含两个函数的hook：
1. CTemporaryStatView::TEMPORARY_STAT::UpdateShadowIndex，用于显示右上角Buff图标的倒计时阴影
2. CUIStatusBar::CQuickSlot:rawSkillCooltime，用于显示快捷栏技能图标的冷却倒计时阴影
在重写原函数或直接调用原函数后，通过调用客户端的draw_number_by_image方法实现数字绘制

其他细节：
1. 起初在快捷栏绘制的数字会产生叠加，直到下一帧阴影才会重置。CUIStatusBar::CQuickSlot:rawSkillCooltime在v95的pdb中可以看到if ( v21 >= 0 && *v27 != v21 )，说明倒计时阴影只有当下标发生变化时才会copy canvas。因此额外添加了re:atchNop(0x0085136B, 6);跳过了阴影帧下标的检查，这样游戏每帧画面都能刷新技能图标的绘制。
2. 每个技能的冷却时间实际上存放在CWvsContext::m_mSkillCooltimeOver这个哈希表中，通过ZMap<long, long, long>::GetAt方法可以查找哈希表，key是技能ID，value是冷却结束时间戳（以毫秒为单位）。这个时间戳其实是自电脑启动以来经过的毫秒数，即timeGetTime()，由于是DWORD实际上会在49天后loop back，如何修复（或者说缓解）这个漏洞就是另一回事了。
3. 各个类的成员变量偏移可以自行对照v95的pdb寻找，值得注意的是FUNCKEY_MAPPED的nID实际上在0x1偏移处，而不是0x0。所以m_aFuncKeyMappedInfo的偏移是要在对应汇编的那行中额外减去1的。

接下来是代码部分：
CountdownDisplay.h

1. #pragma once
   
2. #include "ztl/ztl.h"
   
3. 
   
4. namespace maple {
   
5. namespace countdown_display {
   
6. 
   
7. // Global countdown display resources (for buff duration and skill cooldown)
   
8. extern IWzPropertyPtr g_pPropSecond;
   
9. extern IWzPropertyPtr g_pPropMinute;
   
10. 
    
11. // Attach hooks
    
12. void Attach();
    
13. 
    
14. }  // namespace countdown_display
    
15. }  // namespace maple
    

复制代码

CountdownDisplay.cpp

1. #include "pch.h"
   
2. #include "mods/CountdownDisplay.h"
   
3. #include "tools/hook.h"
   
4. #include "client/CTemporaryStatView.h"
   
5. #include "client/CUIStatusBar.h"
   
6. 
   
7. namespace maple {
   
8. namespace countdown_display {
   
9. 
   
10. // Global countdown display resources (for buff duration and skill cooldown)
    
11. IWzPropertyPtr g_pPropSecond;
    
12. IWzPropertyPtr g_pPropMinute;
    
13. 
    
14. void Attach() {
    
15.     ATTACH_HOOK(CTemporaryStatView::TEMPORARY_STAT::UpdateShadowIndex,
    
16.                 CTemporaryStatView::TEMPORARY_STAT::UpdateShadowIndex_hook);
    
17. 
    
18.     ATTACH_HOOK(CUIStatusBar::CQuickSlot::DrawSkillCooltime, CUIStatusBar::CQuickSlot::DrawSkillCooltime_hook);
    
19. 
    
20.     // Skip shadow index check in original CUIStatusBar::CQuickSlot::DrawSkillCooltime
    
21.     re::PatchNop(0x0085136B, 6);
    
22. }
    
23. 
    
24. }  // namespace countdown_display
    
25. }  // namespace maple
    

复制代码

CUIStatusBar.h

1. #pragma once
   
2. #include "tools/hook.h"
   
3. #include "ztl/ztl.h"
   
4. #include "client/CWnd.h"
   
5. 
   
6. // Define FUNCKEY_MAPPED and the in-object mapped entry layout.
   
7. #pragma pack(push, 1)
   
8. struct FUNCKEY_MAPPED {
   
9.     uint8_t nType;  // 0x0
   
10.     int32_t nID;    // 0x1
    
11. };
    
12. 
    
13. struct FUNCKEY_MAPPED_ENTRY {
    
14.     FUNCKEY_MAPPED fkm;  // 5 bytes
    
15.     uint8_t pad[3];      // padding to align to 12 bytes
    
16.     int32_t nNumber;     // 4 bytes
    
17. };
    
18. #pragma pack(pop)
    
19. 
    
20. static_assert(sizeof(FUNCKEY_MAPPED) == 0x5);
    
21. static_assert(sizeof(FUNCKEY_MAPPED_ENTRY) == 0xC);
    
22. 
    
23. class CUIStatusBar : public CWnd, public TSingleton<CUIStatusBar, 0x00C33A0C> {
    
24. public:
    
25.     class CQuickSlot {
    
26.     public:
    
27.         // m_aFuncKeyMappedInfo: array of 8 entries, each 12 bytes (FUNCKEY_MAPPED + pad + nNumber)
    
28.         MEMBER_ARRAY_AT(FUNCKEY_MAPPED_ENTRY, 0x15B9 - 1, m_aFuncKeyMappedInfo, 8)  // 00851108  lea ecx, [esi+15B9h] ;
    
29.         MEMBER_AT(IWzGr2DLayerPtr, 0x1618, m_pLayerSkillCooltime)                   // 008510A0  mov ecx, [esi+1618h] ;
    
30.         MEMBER_ARRAY_AT(int, 0x165C, m_aFuncKeyMappedSkillCooltime, 8)              // 00851102  lea edi, [esi+165Ch] ;
    
31. 
    
32.         MEMBER_HOOK(void, 0x00851060, DrawSkillCooltime)
    
33. 
    
34.         inline void GetPosByIndex(int nIdx, int* x, int* y) {
    
35.             reinterpret_cast<void(__thiscall*)(CQuickSlot*, int, int*, int*)>(0x00850490)(this, nIdx, x, y);
    
36.         }
    
37.     };
    
38. };
    

复制代码

CUIStatusBar.cpp

1. #include "pch.h"
   
2. #include "client/CUIStatusBar.h"
   
3. #include "client/CWvsContext.h"
   
4. #include "common/Global.h"
   
5. #include "common/Utility.h"
   
6. #include "mods/CountdownDisplay.h"
   
7. #include "ztl/zmap.h"
   
8. #include "tools/debug.h"
   
9. #include <timeapi.h>
   
10. 
    
11. void CUIStatusBar::CQuickSlot::DrawSkillCooltime_hook() {
    
12.     using namespace maple::countdown_display;
    
13. 
    
14.     DEBUG_LOG("[DrawSkillCooltime_hook] START");
    
15.     DrawSkillCooltime(this);
    
16. 
    
17.     IWzGr2DLayer* m_pInstance = this->m_pLayerSkillCooltime.GetInterfacePtr();
    
18.     IWzCanvasPtr pCanvas = m_pInstance->Getcanvas();
    
19.     auto* entries = this->m_aFuncKeyMappedInfo;
    
20.     CWvsContext* m_pStr = CWvsContext::GetInstance();
    
21. 
    
22.     // Prepare number drawing resources
    
23.     if (!g_pPropMinute) {
    
24.         g_pPropMinute = get_unknown(get_rm()->GetObjectA(Ztl_bstr_t(L"UI/Basic.img/ItemNo")));
    
25.     }
    
26. 
    
27.     if (!g_pPropSecond) {
    
28.         g_pPropSecond = get_unknown(get_rm()->GetObjectA(Ztl_bstr_t(L"UI/UIWindow99.img/SkillCooldownNumber/2")));
    
29.     }
    
30. 
    
31.     DWORD currentTime = timeGetTime();
    
32. 
    
33.     // Iterate through 8 quickslots
    
34.     for (int i = 0; i < 8; ++i) {
    
35.         int nSkillID = entries[i].fkm.nID;
    
36.         if (nSkillID == 0) {
    
37.             continue;
    
38.         }
    
39. 
    
40.         // Get position for this slot
    
41.         int x = 0;
    
42.         int y = 0;
    
43.         this->GetPosByIndex(i, &x, &y);
    
44. 
    
45.         // Query cooldown end time from map
    
46.         DWORD nEndTime = 0;
    
47.         ZMap_GetAt(&m_pStr->m_mSkillCooltimeOver, &nSkillID, (int*)&nEndTime);
    
48. 
    
49.         if (nEndTime <= 0 || nEndTime <= currentTime) {
    
50.             continue;
    
51.         }
    
52. 
    
53.         // Calculate remaining time in milliseconds and draw countdown number
    
54.         int nRemainingMs = (int)(nEndTime - currentTime);
    
55.         draw_countdown_number(pCanvas, x, y, nRemainingMs, g_pPropMinute, g_pPropSecond);
    
56.     }
    
57. 
    
58.     DEBUG_LOG("[DrawSkillCooltime_hook] END");
    
59. }
    

复制代码

CTemporaryStatView.h

1. #pragma once
   
2. #include "tools/hook.h"
   
3. #include "client/CUIToolTip.h"
   
4. #include "common/UINT128.h"
   
5. #include "ztl/ztl.h"
   
6. 
   
7. class CTemporaryStatView {
   
8. public:
   
9.     enum TEMPORARY_STAT_TYPE {
   
10.         TSV_NONE = 0x0,
    
11.         TSV_ITEM = 0x1,
    
12.         TSV_SKILL = 0x2,
    
13.         TSV_ETC = 0x3,
    
14.         TSV_PRIVILEGE = 0x4,
    
15.     };
    
16. 
    
17.     struct TEMPORARY_STAT : public ZRefCounted {
    
18.         unsigned char pad0[0x48 - sizeof(ZRefCounted)];
    
19.         MEMBER_AT(int, 0x1C, nType)
    
20.         MEMBER_AT(int, 0x20, nID)
    
21.         MEMBER_AT(IWzGr2DLayerPtr, 0x2C, pLayer)
    
22.         MEMBER_AT(IWzGr2DLayerPtr, 0x30, pLayerShadow)
    
23.         MEMBER_AT(int, 0x34, nIndexShadow)
    
24.         MEMBER_AT(int, 0x38, bNoShadow)
    
25.         MEMBER_AT(int, 0x3C, tLeft)
    
26.         MEMBER_AT(int, 0x40, tLeftUnit)
    
27. 
    
28.         MEMBER_HOOK(void, 0x0073DB90, UpdateShadowIndex)
    
29.     };
    
30. 
    
31.     ZList<ZRef<TEMPORARY_STAT>> m_lTemporaryStat;
    
32. 
    
33.     CTemporaryStatView() = default;
    
34.     virtual ~CTemporaryStatView() = default;
    
35. };
    
36. 
    
37. static_assert(sizeof(CTemporaryStatView) == 0x18);
    
38. static_assert(offsetof(CTemporaryStatView, m_lTemporaryStat) == 0x4);

复制代码

CTemporaryStatView.cpp

1. #include "pch.h"
   
2. #include "client/CTemporaryStatView.h"
   
3. #include "client/CUIToolTip.h"
   
4. #include "mods/Resolution.h"
   
5. #include "mods/CountdownDisplay.h"
   
6. #include "common/Global.h"
   
7. #include "common/UINT128.h"
   
8. #include "common/Utility.h"
   
9. #include "tools/debug.h"
   
10. 
    
11. using namespace maple::countdown_display;
    
12. 
    
13. void CTemporaryStatView::TEMPORARY_STAT::UpdateShadowIndex_hook() {
    
14.     DEBUG_LOG("[UpdateShadowIndex_hook] START - ID=%d", nID);
    
15.     if (bNoShadow) {
    
16.         return;
    
17.     }
    
18.     int nSeconds = tLeft / 1000;
    
19.     if (nSeconds == nIndexShadow) {
    
20.         return;
    
21.     }
    
22. 
    
23.     DEBUG_LOG("[UpdateShadowIndex_hook] Seconds=%d", nSeconds);
    
24. 
    
25.     // Hijack nIndexShadow to redraw every second
    
26.     nIndexShadow = nSeconds;
    
27.     int nShadowIndex = 0;
    
28.     if (tLeftUnit) {
    
29.         nShadowIndex = tLeft / tLeftUnit;
    
30.         if (nShadowIndex < 0) {
    
31.             nShadowIndex = 0;
    
32.         } else if (nShadowIndex > 15) {
    
33.             nShadowIndex = 15;
    
34.         }
    
35.     }
    
36. 
    
37.     // Remove old canvas
    
38.     pLayerShadow->RemoveCanvas(-2);
    
39. 
    
40.     // Resolve shadow canvas
    
41.     wchar_t sShadowProperty[1024];
    
42.     swprintf_s(sShadowProperty, 1024, L"UI/UIWindow.img/Skill/CoolTime/%d", nShadowIndex);
    
43.     IWzCanvasPtr pShadowCanvas = get_unknown(get_rm()->GetObjectA(Ztl_bstr_t(sShadowProperty)));
    
44. 
    
45.     // Create new canvas, copy shadow
    
46.     IWzCanvasPtr pNewCanvas;
    
47.     PcCreateObject<IWzCanvasPtr>(L"Canvas", pNewCanvas, nullptr);
    
48.     pNewCanvas->Create(32, 32);
    
49.     pNewCanvas->Copy(0, 0, pShadowCanvas);
    
50. 
    
51.     // Draw number on canvas
    
52.     if (!g_pPropMinute) {
    
53.         g_pPropMinute = get_unknown(get_rm()->GetObjectA(Ztl_bstr_t(L"UI/Basic.img/ItemNo")));
    
54.     }
    
55. 
    
56.     if (!g_pPropSecond) {
    
57.         g_pPropSecond = get_unknown(get_rm()->GetObjectA(Ztl_bstr_t(L"UI/UIWindow99.img/SkillCooldownNumber/2")));
    
58.     }
    
59. 
    
60.     draw_countdown_number(pNewCanvas, 0, 0, tLeft, g_pPropMinute, g_pPropSecond);
    
61. 
    
62.     // Insert canvas
    
63.     pLayerShadow->InsertCanvas(pNewCanvas, 500, 210, 64);
    
64.     DEBUG_LOG("[UpdateShadowIndex_hook] END");
    
65. }
    

复制代码

Utility.h

1. #pragma once
   
2. #include "ztl/ztl.h"
   
3. #include <cmath>
   
4. 
   
5. // Helper function to get int32 from IWzProperty variant
   
6. inline int get_int32(Ztl_variant_t& v, int nDefault) {
   
7.     Ztl_variant_t vInt;
   
8.     if (V_VT(&v) == VT_EMPTY || V_VT(&v) == VT_ERROR || FAILED(ZComAPI::ZComVariantChangeType(&vInt, &v, 0, VT_I4))) {
   
9.         return nDefault;
   
10.     } else {
    
11.         return V_I4(&vInt);
    
12.     }
    
13. }
    
14. 
    
15. inline IUnknownPtr get_unknown(Ztl_variant_t& v) {
    
16.     IUnknownPtr result;
    
17.     reinterpret_cast<IUnknownPtr*(__cdecl*)(IUnknownPtr*, Ztl_variant_t*)>(0x00418780)(std::addressof(result), &v);
    
18.     return result;
    
19. }
    
20. 
    
21. inline int draw_number_by_image(IWzCanvasPtr pCanvas, int nLeft, int nTop, int nNo, IWzPropertyPtr pBase,
    
22.                                 int nHorzSpace) {
    
23.     return reinterpret_cast<int(__cdecl*)(IWzCanvasPtr, int, int, int, IWzPropertyPtr, int)>(0x0093EDA0)(
    
24.         pCanvas, nLeft, nTop, nNo, pBase, nHorzSpace);
    
25. }
    
26. 
    
27. // Draws countdown number on canvas based on remaining milliseconds
    
28. // Returns true if successfully drawn, false if out of range
    
29. inline bool draw_countdown_number(IWzCanvasPtr pCanvas, int x, int y, int nMillisecondsLeft, IWzPropertyPtr pPropMinute,
    
30.                                   IWzPropertyPtr pPropSecond) {
    
31.     int nSeconds = static_cast<int>(std::ceil(nMillisecondsLeft / 1000.0));
    
32. 
    
33.     int displayValue;
    
34.     IWzPropertyPtr displayUnit;
    
35.     int nLeft;
    
36.     int nTop;
    
37. 
    
38.     if (nSeconds >= 60) {
    
39.         displayValue = nSeconds / 60;  // Display minutes
    
40.         displayUnit = pPropMinute;
    
41.         nLeft = 2;
    
42.         nTop = 19;
    
43.     } else {
    
44.         displayValue = nSeconds;
    
45.         displayUnit = pPropSecond;
    
46.         if (nSeconds >= 10) {
    
47.             nLeft = 6;
    
48.             nTop = 10;
    
49.         } else {
    
50.             nLeft = 11;
    
51.             nTop = 10;
    
52.         }
    
53.     }
    
54. 
    
55.     if (displayValue <= 0 || displayValue > 999) {
    
56.         return false;
    
57.     }
    
58. 
    
59.     draw_number_by_image(pCanvas, x + nLeft, y + nTop, displayValue, displayUnit, 0);
    
60.     return true;
    
61. }
    

复制代码

zmap.h

1. #pragma once
   
2. 
   
3. // ZMap<long, long, long>::GetAt wrapper
   
4. inline int* ZMap_GetAt(void* pThis, const int* key, int* value) {
   
5.     return reinterpret_cast<int*(__thiscall*)(void*, const int*, int*)>(0x0047A6A0)(pThis, key, value);
   
6. }
   

复制代码

disguisebilly

TETO这套东西是真的好用 用了之后减少好多代码量