Исходник Always square in-game radar

[Wonderful]

Не безумная особенность, но, возможно, кто-то найдет ее полезной, и Вы также можете делать другие радиолокационные манипуляции таким образом (скрывая приманки, показывая всех игроков и т. д.).

                    ; void __thiscall SFHudRadar::ProcessInput(void *this)
55                  push    ebp
8B EC               mov     ebp, esp
83 E4 F8            and     esp, 0FFFFFFF8h
51                  push    ecx
56                  push    esi
8B F1               mov     esi, ecx
E8 41 A8 FF FF      call    SFHudRadar__LazyCreateGoalIcons
8B CE               mov     ecx, esi
E8 7A B8 FF FF      call    SFHudRadar__LazyCreatePlayerIcons
8B CE               mov     ecx, esi
E8 43 FD FF FF      call    SFHudRadar__ApplySpectatorModes
8B CE               mov     ecx, esi
E8 FC DC FF FF      call    SFHudRadar__PositionRadarViewpoint
8B CE               mov     ecx, esi
E8 C5 E1 FF FF      call    SFHudRadar__PlaceGoalIcons
8B CE               mov     ecx, esi
E8 8E F0 FF FF      call    SFHudRadar__PlacePlayers
8B CE               mov     ecx, esi
E8 17 E9 FF FF      call    SFHudRadar__PlaceHostages
8B CE               mov     ecx, esi
E8 D0 FE FF FF      call    SFHudRadar__UpdateDecoys
8B CE               mov     ecx, esi
E8 29 EF FF FF      call    SFHudRadar__UpdateAllDefusers
8B CE               mov     ecx, esi
E8 82 F8 FF FF      call    SFHudRadar__UpdateMiscIcons
8B CE               mov     ecx, esi
E8 6B D5 FF FF      call    SFHudRadar__SetupIconsFromStates
5E                  pop     esi
8B E5               mov     esp, ebp
5D                  pop     ebp
C3                  retn

SFHudRadar::ApplySpectatorModes calls at the end SFHudRadar::SwitchRadarToRound.

void __thiscall SFHudRadar::SwitchRadarToRound(void *this, bool bRound)
{
    ...
 
    this1 = this;
    if ( *((_BYTE *)this + 0xC) && *((_BYTE *)this + 0x14B10) & 2 )
    {
        ... doing stuff ...
    }

void __fastcall HudRadar_ProcessInput_hook(SFHudRadar* radar) {
    // SFHudRadar::ProcessInput calls 11 functions without parameters in order.
    // We call them by ourselves and run our code in between.
 
    // Calculate address of first function offset from ProcessInput bytecode
    uintptr_t addr = reinterpret_cast<uintptr_t>(hooks->HudRadar_old) + 0xB;
 
    for (int i = 0; i < 11; i++) {
        // 0xE8 is relative call, we need to calculate absolute function address.
        int funcOffset = *reinterpret_cast<int*>(addr);
        auto current = reinterpret_cast<void(__thiscall*)(void*)>(addr + funcOffset + 4);
 
        if (i == 2 && Visuals::enableRadarSquared) { // ApplySpectatorModes
            uint8_t tmp = radar->flag;
            radar->flag = 0;                         // Prevent SwitchRadarToRound being called in ApplySpectatorModes.
            current(radar);
            radar->flag = tmp;
            radar->SwitchRadarToRound(false);        // Now switch to square.
        } else {
            current(radar);
        }
 
        addr += 0x7;
    }
}

SFHudRadar* hudRadar = static_cast<SFHudRadar*>(g_HUD.FindElement("SFHudRadar"));

struct CHudElement {
    DVMethod(void(), ProcessInput, StaticVIndex<9>); // void(__thiscall*)(SFHudRadar* this0)
};
 
struct SFHudRadar : CHudElement {
    DVar(byte, flag, StaticOffset<0xC>);
 
    // void(__thiscall*)(SFHudRadar* this0, bool round)
    DMethod(void(bool round), SwitchRadarToRound, PatternPtr<modules::client, patterns::SFHudRadar_SwitchRadarToRound>);
};

"SFHudRadar_SwitchRadarToRound": {
    "pattern": "55 8B EC 56 8B F1 80 7E 0C 00 0F 84",
    "extra": 0,
    "mode_read": false,
    "mode_subtract": true,
    "offset": 0
},
"g_HUD": {
    "pattern": "B9 ? ? ? ? 0F 94 C0 0F B6 C0 50 68",
    "extra": 1,
    "mode_read": true,
    "mode_subtract": true,
    "offset": 0
}