config.cpp

#include "config.h"
#include "log.h"

#include <string>

namespace
{
    constexpr int kFullScreenWindow = 1;
    constexpr char kConfigFileName[] = "ultrawide.ini";
    
    constexpr char kUnityWindowClass[] = "UnityWndClass";
    constexpr char kWindowTitle[]      = "UNBEATABLE";

    TargetResolution FromMonitorRect(const RECT& r)
    {
        return { r.right - r.left, r.bottom - r.top, kFullScreenWindow };
    }
    
    TargetResolution PrimaryMonitorResolution()
    {
        return { GetSystemMetrics(SM_CXSCREEN),
                 GetSystemMetrics(SM_CYSCREEN),
                 kFullScreenWindow };
    }
    
    bool TryMonitorResolutionForWindow(HWND hwnd, TargetResolution& out)
    {
        HMONITOR monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
        if (!monitor)
        {
            return false;
        }

        MONITORINFO info{};
        info.cbSize = sizeof(info);
        if (!GetMonitorInfoA(monitor, &info))
        {
            return false;
        }

        out = FromMonitorRect(info.rcMonitor);
        return true;
    }
    
    TargetResolution DetectDisplayResolution()
    {
        HWND hwnd = FindWindowA(kUnityWindowClass, kWindowTitle);

        TargetResolution result{};
        if (hwnd && TryMonitorResolutionForWindow(hwnd, result))
        {
            Logf("Using game window's monitor: %dx%d",
                 result.width, result.height);
            return result;
        }

        result = PrimaryMonitorResolution();
        Logf("Game window not found; using primary monitor: %dx%d",
             result.width, result.height);
        return result;
    }
    
    std::string PathBesideModule(HMODULE selfModule, const char* fileName)
    {
        char modulePath[MAX_PATH]{};
        const DWORD len =
            GetModuleFileNameA(selfModule, modulePath, MAX_PATH);
        if (len == 0 || len == MAX_PATH)
        {
            return {};
        }

        std::string path(modulePath, len);
        const size_t slash = path.find_last_of("\\/");
        if (slash == std::string::npos)
        {
            return {};
        }

        return path.substr(0, slash + 1) + fileName;
    }
    
    int ReadIniInt(const std::string& iniPath, const char* key, int fallback)
    {
        return static_cast<int>(
            GetPrivateProfileIntA("Resolution", key, fallback, iniPath.c_str()));
    }

    bool FileExists(const std::string& path)
    {
        const DWORD attrs = GetFileAttributesA(path.c_str());
        return attrs != INVALID_FILE_ATTRIBUTES &&
               !(attrs & FILE_ATTRIBUTE_DIRECTORY);
    }
}

TargetResolution ResolveTargetResolution(HMODULE selfModule)
{
    const TargetResolution display = DetectDisplayResolution();

    const std::string iniPath = PathBesideModule(selfModule, kConfigFileName);
    if (iniPath.empty() || !FileExists(iniPath))
    {
        Logf("No config file; using detected resolution %dx%d",
             display.width, display.height);
        return display;
    }
    
    const int width  = ReadIniInt(iniPath, "Width", display.width);
    const int height = ReadIniInt(iniPath, "Height", display.height);

    Logf("Loaded config %s: %dx%d", iniPath.c_str(), width, height);
    return { width, height, kFullScreenWindow };
}