OLTimer.cpp

#include <windows.h>
#include <shlobj.h>
#include <comdef.h>
#include <Wbemidl.h>
#include <iostream>
#include <chrono>
#include <thread>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <string>
#include <filesystem>

#pragma comment(lib, "wbemuuid.lib")
#pragma comment(lib, "shell32.lib")

std::wstring formatDuration(long long seconds) {
    long long d = seconds / 86400;
    long long h = (seconds % 86400) / 3600;
    long long m = (seconds % 3600) / 60;
    long long s = seconds % 60;

    std::wstringstream ss;
    ss << std::setw(2) << std::setfill(L'0') << d << L":"
        << std::setw(2) << std::setfill(L'0') << h << L":"
        << std::setw(2) << std::setfill(L'0') << m << L":"
        << std::setw(2) << std::setfill(L'0') << s;
    return ss.str();
}

std::wstring getSaveFilePath() {
    wchar_t* localAppData = nullptr;
    if (SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, NULL, &localAppData) != S_OK) {
        return L"";
    }
    std::filesystem::path savePath = localAppData;
    CoTaskMemFree(localAppData);

    savePath /= L"OLTimer";
    std::filesystem::create_directories(savePath);

    savePath /= L"OLGameTime.txt";
    return savePath.wstring();
}

long long loadSavedTime() {
    std::wstring path = getSaveFilePath();
    std::wifstream file(path);
    long long total = 0;
    if (file) {
        file >> total;
    }
    return total;
}

void saveTime(long long totalSeconds) {
    std::wstring path = getSaveFilePath();
    std::wofstream file(path, std::ios::trunc);
    if (file) {
        file << totalSeconds;
    }
}

bool isProcessRunning(IWbemServices* pSvc, const std::wstring& processName) {
    IEnumWbemClassObject* pEnumerator = nullptr;
    std::wstring query = L"SELECT Name FROM Win32_Process WHERE Name='" + processName + L"'";

    HRESULT hres = pSvc->ExecQuery(
        bstr_t("WQL"),
        bstr_t(query.c_str()),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        NULL, &pEnumerator);

    if (FAILED(hres) || !pEnumerator) return false;

    IWbemClassObject* pclsObj = nullptr;
    ULONG uReturn = 0;
    bool found = false;

    if (pEnumerator->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn) == S_OK && uReturn) {
        found = true;
        pclsObj->Release();
    }

    pEnumerator->Release();
    return found;
}

int main() {
    HRESULT hres;
    hres = CoInitializeEx(0, COINIT_MULTITHREADED);
    if (FAILED(hres)) return 1;

    hres = CoInitializeSecurity(
        NULL, -1, NULL, NULL,
        RPC_C_AUTHN_LEVEL_DEFAULT,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL, EOAC_NONE, NULL);

    if (FAILED(hres) && hres != RPC_E_TOO_LATE) {
        CoUninitialize();
        return 1;
    }

    IWbemLocator* pLoc = nullptr;
    hres = CoCreateInstance(
        CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
        IID_IWbemLocator, (LPVOID*)&pLoc);

    if (FAILED(hres)) {
        CoUninitialize();
        return 1;
    }

    IWbemServices* pSvc = nullptr;
    hres = pLoc->ConnectServer(
        _bstr_t(L"ROOT\\CIMV2"),
        NULL, NULL, 0, NULL, 0, 0, &pSvc);

    if (FAILED(hres)) {
        pLoc->Release();
        CoUninitialize();
        return 1;
    }

    hres = CoSetProxyBlanket(
        pSvc, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
        RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL, EOAC_NONE);

    if (FAILED(hres)) {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return 1;
    }

    IEnumWbemClassObject* pEnumCreate = nullptr;
    IEnumWbemClassObject* pEnumDelete = nullptr;

    hres = pSvc->ExecNotificationQuery(
        bstr_t("WQL"),
        bstr_t("SELECT * FROM __InstanceCreationEvent "
            "WITHIN 1 WHERE TargetInstance ISA 'Win32_Process' "
            "AND TargetInstance.Name = 'OLGame.exe'"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        NULL, &pEnumCreate);

    if (FAILED(hres)) {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return 1;
    }

    hres = pSvc->ExecNotificationQuery(
        bstr_t("WQL"),
        bstr_t("SELECT * FROM __InstanceDeletionEvent "
            "WITHIN 1 WHERE TargetInstance ISA 'Win32_Process' "
            "AND TargetInstance.Name = 'OLGame.exe'"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        NULL, &pEnumDelete);

    if (FAILED(hres)) {
        pEnumCreate->Release();
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return 1;
    }

    std::wcout << L"Monitoring Outlast...\n";

    bool running = false;
    std::chrono::steady_clock::time_point startTime;
    long long totalTime = loadSavedTime();

    if (isProcessRunning(pSvc, L"OLGame.exe")) {
        std::wcout << L"ALREADY RUNNING Outlast\n";
        running = true;
        startTime = std::chrono::steady_clock::now();
    }

    while (true) {
        IWbemClassObject* pObj = nullptr;
        ULONG uReturn = 0;

        if (pEnumCreate->Next(1000, 1, &pObj, &uReturn) == S_OK && uReturn) {
            std::wcout << L"STARTED Outlast\n";
            running = true;
            startTime = std::chrono::steady_clock::now();
            pObj->Release();
        }

        if (pEnumDelete->Next(1000, 1, &pObj, &uReturn) == S_OK && uReturn) {
            if (running) {
                auto endTime = std::chrono::steady_clock::now();
                auto duration = std::chrono::duration_cast<std::chrono::seconds>(endTime - startTime).count();
                totalTime += duration;
                running = false;
                std::wcout << L"\nCLOSED Outlast\n";
            }
            pObj->Release();
        }

        long long currentSession = 0;
        if (running) {
            auto now = std::chrono::steady_clock::now();
            currentSession = std::chrono::duration_cast<std::chrono::seconds>(now - startTime).count();
        }

        saveTime(totalTime + currentSession);

        if (running) {
            std::wcout << L"\rSession: " << formatDuration(currentSession)
                << L" | Total: " << formatDuration(totalTime + currentSession)
                << L"   " << std::flush;
        }
        else {
            std::wcout << L"\rTotal: " << formatDuration(totalTime) << L"   " << std::flush;
        }

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    pEnumCreate->Release();
    pEnumDelete->Release();
    pSvc->Release();
    pLoc->Release();
    CoUninitialize();

    return 0;
}