Main.cpp

#include "plugin.h"
#include <vector>
#include <filesystem>

using namespace plugin;
using namespace std;

uintptr_t gWndProc = 0;
uintptr_t gFullscreenAddr = 0;

LONG GetWindowedWindowStyle() {
    return WS_VISIBLE | WS_MINIMIZEBOX | WS_POPUP;
}

LONG GetWindowedClassStyle() {
    return CS_DBLCLKS | CS_CLASSDC;
}

bool &IsFullscreen() {
    static bool isFullscreen = false;
    return isFullscreen;
}

void EnableDPIAwareness() {
    HMODULE hShcore = LoadLibraryA("Shcore.dll");
    if (hShcore) {
        typedef HRESULT(WINAPI *SetDpiAwarenessFunc)(int);
        SetDpiAwarenessFunc SetProcessDpiAwareness = (SetDpiAwarenessFunc)GetProcAddress(hShcore, "SetProcessDpiAwareness");
        if (SetProcessDpiAwareness)
            SetProcessDpiAwareness(1);
        FreeLibrary(hShcore);
    }
    else {
        HMODULE hUser32 = LoadLibraryA("User32.dll");
        if (hUser32) {
            typedef BOOL(WINAPI *SetDPIAwareFunc)();
            SetDPIAwareFunc SetProcessDPIAware = (SetDPIAwareFunc)GetProcAddress(hUser32, "SetProcessDPIAware");
            if (SetProcessDPIAware)
                SetProcessDPIAware();
            FreeLibrary(hUser32);
        }
    }
}

struct WindowRect {
    int X, Y, Width, Height;
};

WindowRect &InitialWindowRect() {
    static WindowRect initialWindowRect;
    return initialWindowRect;
}

WindowRect CalcWindowRect(int X, int Y, int Width, int Height, bool StoreInitialRect) {
    WindowRect rect;
    rect.X = X;
    rect.Y = Y;
    rect.Width = Width;
    rect.Height = Height;
    auto screenW = GetSystemMetrics(SM_CXMAXIMIZED);
    auto screenH = GetSystemMetrics(SM_CYMAXIMIZED);
    if (rect.Width < (screenW - 100) && rect.Height < (screenH - 100)) {
        rect.X = screenW / 2 - rect.Width / 2;
        rect.Y = screenH / 2 - rect.Height / 2;
    }
    else {
        rect.X = 0;
        rect.Y = 0;
        rect.Height -= 1;
    }
    if (StoreInitialRect) {
        static bool storedInitialRect = false;
        if (!storedInitialRect) {
            InitialWindowRect() = rect;
            storedInitialRect = true;
        }
    }
    return rect;
}

HWND __stdcall MyCreateWindowExA(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int Width, int Height, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam) {
    IsFullscreen() = dwStyle != GetWindowedWindowStyle();
    if (!IsFullscreen()) {
        EnableDPIAwareness();
        auto rect = CalcWindowRect(X, Y, Width, Height, true);
        HWND hWnd = CreateWindowExA(dwExStyle, lpClassName, lpWindowName, GetWindowedWindowStyle(),
            rect.X, rect.Y, rect.Width, rect.Height, hWndParent, hMenu, hInstance, lpParam);
        SetWindowPos(hWnd, HWND_NOTOPMOST, rect.X, rect.Y, rect.Width, rect.Height, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
        return hWnd;
    }
    return CreateWindowExA(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, Width, Height, hWndParent, hMenu, hInstance, lpParam);
}

char MyCreateWindowExA_14_restore[6];
uintptr_t CreateWindowRestoreAddr = 0;

HWND __stdcall MyCreateWindowExA_14(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int Width, int Height, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam) {
    if (CreateWindowRestoreAddr)
        patch::MemCpy(CreateWindowRestoreAddr, MyCreateWindowExA_14_restore, 6);
    if (*(uint32_t *)gFullscreenAddr == 0) {
        EnableDPIAwareness();
        auto rect = CalcWindowRect(X, Y, Width, Height, true);
        HWND hWnd = CreateWindowExA(dwExStyle, lpClassName, lpWindowName, GetWindowedWindowStyle(),
            rect.X, rect.Y, rect.Width, rect.Height, hWndParent, hMenu, hInstance, lpParam);
        SetWindowPos(hWnd, HWND_NOTOPMOST, rect.X, rect.Y, rect.Width, rect.Height, SWP_FRAMECHANGED | SWP_SHOWWINDOW);
        return hWnd;
    }
    return CreateWindowExA(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, Width, Height, hWndParent, hMenu, hInstance, lpParam);
}

LONG __stdcall MySetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong) {
    if (!IsFullscreen())
        return SetWindowLongA(hWnd, nIndex, GetWindowedWindowStyle());
    return SetWindowLongA(hWnd, nIndex, dwNewLong);
}

HWND __stdcall MyCreateWindowExA_10(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle, int X, int Y, int Width, int Height, HWND hWndParent, HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam) {
    EnableDPIAwareness();
    return CreateWindowExA(dwExStyle, lpClassName, lpWindowName, dwStyle, X, Y, Width, Height, hWndParent, hMenu, hInstance, lpParam);
}

LONG __stdcall MySetWindowLong_10(HWND hWnd, int nIndex, LONG dwNewLong) {
    IsFullscreen() = true;
    if (dwNewLong == 0x10CF0000) {
        dwNewLong = GetWindowedWindowStyle();
        IsFullscreen() = false;
    }
    return SetWindowLongA(hWnd, nIndex, dwNewLong);
}

BOOL __stdcall MyMoveWindow(HWND hWnd, int X, int Y, int Width, int Height, BOOL bRepaint) {
    auto rect = CalcWindowRect(X, Y, Width, Height, true);
    return MoveWindow(hWnd, rect.X, rect.Y, rect.Width, rect.Height, bRepaint);
}

BOOL __stdcall MyAdjustWindowRect(LPRECT lpRect, DWORD dwStyle, BOOL bMenu) {
    return AdjustWindowRect(lpRect, GetWindowedWindowStyle(), bMenu);
}

int __stdcall MyWndProc(HWND hWnd, UINT uCmd, WPARAM wParam, LPARAM lParam) {
    bool isWindowed = false;
    if (gFullscreenAddr)
        isWindowed = *(uint32_t *)gFullscreenAddr == 0;
    else
        isWindowed = !IsFullscreen();
    if (isWindowed) {
        static POINT ptStart;
        static POINT ptOffset;
        static BOOL bDragging = FALSE;
        static const unsigned int BORDERLESS_MOVEBAR_HEIGHT = 20;
        if (uCmd == WM_LBUTTONDOWN) {
            if (!bDragging) {
                GetCursorPos(&ptStart);
                RECT rect;
                GetWindowRect(hWnd, &rect);
                ptOffset.x = ptStart.x - rect.left;
                ptOffset.y = ptStart.y - rect.top;
                if (ptStart.y <= (rect.top + BORDERLESS_MOVEBAR_HEIGHT)) {
                    bDragging = TRUE;
                    SetCapture(hWnd);
                }
            }
        }
        else if (uCmd == WM_MOUSEMOVE) {
            if (bDragging) {
                POINT pt;
                GetCursorPos(&pt);
                int dx = pt.x - ptStart.x;
                int dy = pt.y - ptStart.y;
                RECT rect;
                GetWindowRect(hWnd, &rect);
                MoveWindow(hWnd, rect.left + dx, rect.top + dy, rect.right - rect.left, rect.bottom - rect.top, TRUE);
                ptStart = pt;
            }
        }
        else if (uCmd == WM_LBUTTONUP) {
            bDragging = FALSE;
            ReleaseCapture();
        }
        else if (uCmd == WM_LBUTTONDBLCLK) {
            POINT pt;
            GetCursorPos(&pt);
            ScreenToClient(hWnd, &pt);
            RECT rect;
            GetClientRect(hWnd, &rect);
            if (pt.y <= BORDERLESS_MOVEBAR_HEIGHT) {
                MoveWindow(hWnd, InitialWindowRect().X, InitialWindowRect().Y,
                    InitialWindowRect().Width, InitialWindowRect().Height, TRUE);
            }
        }
    }
    return CallMethodAndReturnDynGlobal<int>(gWndProc, 0, hWnd, uCmd, wParam, lParam);
}

void NopWinapiMethod(uintptr_t address, uint32_t numParams) {
    patch::SetUChar(address, 0x83);
    patch::SetUChar(address + 1, 0xC4);
    patch::SetUChar(address + 2, numParams * 4);
    patch::Nop(address + 3, 3);
}

int MyPrintf(const char *Format, ...) {
    return 0;
}

class FifaBorderlessMode {
public:
    FifaBorderlessMode() {
        if (!CheckPluginName(Magic<'B','o','r','d','e','r','l','e','s','s','M','o','d','e','.','a','s','i'>()))
            return;
        auto v = FIFA::GetAppVersion();
        switch (v.id()) {
        case ID_FIFA14_1700:
            patch::SetUInt(0x14DC296 + 3, GetWindowedClassStyle());
            patch::SetUInt(0x14DC2F3 + 1, GetWindowedWindowStyle());
            CreateWindowRestoreAddr = 0x14DC382;
            patch::MemCpy(MyCreateWindowExA_14_restore, CreateWindowRestoreAddr, 6);
            patch::Nop(0x14DC382, 1);
            patch::RedirectCall(0x14DC382 + 1, MyCreateWindowExA_14);
            gWndProc = patch::SetPointer(0x14DC28F + 3, MyWndProc);
            gFullscreenAddr = 0x49EAAFC;
            break;
        case ID_FIFA14_1400_3DM:
            patch::SetUInt(0x14E6876 + 3, GetWindowedClassStyle());
            patch::SetUInt(0x14E68D3 + 1, GetWindowedWindowStyle());
            //CreateWindowRestoreAddr = 0x14E6962;
            //patch::MemCpy(MyCreateWindowExA_14_restore, CreateWindowRestoreAddr, 6);
            //patch::Nop(0x14E6962, 1);
            //patch::RedirectCall(0x14E6962 + 1, MyCreateWindowExA_14);
            gWndProc = patch::SetPointer(0x14E686F + 3, MyWndProc);
            patch::SetPointer(0x3BD5A68, MyCreateWindowExA);
            gFullscreenAddr = 0x4994ACC;
            break;
        case ID_FIFA13_1700_RLD:
            patch::SetUInt(0x12A517D + 3, GetWindowedClassStyle());
            patch::SetUInt(0x12A51DA + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0x12A5269, MyCreateWindowExA);
            patch::Nop(0x12A5269 + 5, 1);
            patch::RedirectCall(0x12A3A3E, MySetWindowLong);
            patch::Nop(0x12A3A3E + 5, 1);
            gWndProc = patch::GetUInt(0x12A5176 + 3);
            patch::SetPointer(0x12A5176 + 3, MyWndProc);
            break;
        case ID_FIFA13_1800:
            patch::SetUInt(0x12A21FD + 3, GetWindowedClassStyle());
            patch::SetUInt(0x12A225A + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0x12A22E9, MyCreateWindowExA);
            patch::Nop(0x12A22E9 + 5, 1);
            patch::RedirectCall(0x12A0ABE, MySetWindowLong);
            patch::Nop(0x12A0ABE + 5, 1);
            gWndProc = patch::GetUInt(0x12A21F6 + 3);
            patch::SetPointer(0x12A21F6 + 3, MyWndProc);
            break;
        case ID_FIFA12_1700:
            patch::SetUInt(0xB9E92B + 4, GetWindowedClassStyle());
            patch::SetUInt(0xB9E997 + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0x1650648, MyCreateWindowExA);
            patch::Nop(0x1650648 + 5, 1);
            gWndProc = patch::GetUInt(0xB9E923 + 4);
            patch::SetPointer(0xB9E923 + 4, MyWndProc);
            patch::Nop(0xE55D45, 6);
            break;
        case ID_FIFA12_1500_SKD:
            patch::SetUInt(0xB9CB1B + 4, GetWindowedClassStyle());
            patch::SetUInt(0xB9CB87 + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0xB9CC27, MyCreateWindowExA);
            patch::Nop(0xB9CC27 + 5, 1);
            gWndProc = patch::GetUInt(0xB9CB13 + 4);
            patch::SetPointer(0xB9CB13 + 4, MyWndProc);
            patch::Nop(0xE52745, 6);
            break;
        case ID_FIFA12_1000_RLD:
            patch::SetUInt(0x51CF14 + 4, GetWindowedClassStyle());
            patch::SetUInt(0x51CF80 + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0x51D020, MyCreateWindowExA);
            patch::Nop(0x51D020 + 5, 1);
            gWndProc = patch::GetUInt(0x51CF0C + 4);
            patch::SetPointer(0x51CF0C + 4, MyWndProc);
            patch::Nop(0x80C7E5, 6);
            break;
        case ID_FIFA11_1010_FLT:
        case ID_FIFA11_1010:
            patch::SetUInt(0x8EA752 + 4, GetWindowedClassStyle());
            patch::SetUInt(0x8EA7BD + 1, GetWindowedWindowStyle());
            patch::RedirectCall(0x8EA856, MyCreateWindowExA);
            patch::Nop(0x8EA856 + 5, 1);
            gWndProc = patch::GetUInt(0x8EA74A + 4);
            patch::SetPointer(0x8EA74A + 4, MyWndProc);
            break;
        case ID_FIFA09_1200_RZR:
            //patch::SetUChar(0x6208BA + 2, GetWindowedClassStyle());
            //patch::RedirectCall(0x620939, MyCreateWindowExA_10);
            //patch::Nop(0x620939 + 5, 1);
            //patch::RedirectCall(0x61F7E0, MySetWindowLong_10);
            //patch::Nop(0x61F7E0 + 5, 1);
            //patch::RedirectCall(0x61F816, MyMoveWindow);
            //patch::Nop(0x61F816 + 5, 1);
            //patch::RedirectCall(0x61F7EE, MyAdjustWindowRect);
            //patch::Nop(0x61F7EE + 5, 1);
            //NopWinapiMethod(0x61F8F9, 2);
            //NopWinapiMethod(0x61F96B, 2);
            //patch::Nop(0x62CD13, 26);
            ////gWndProc = patch::SetPointer(0x620878 + 4, MyWndProc);
            break;
        }
    }
} fifaBorderlessMode;