uc.launcher.cpp

#include <windows.h>
#include <fstream>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <winhttp.h>

#pragma comment(lib, "winhttp.lib")

// Convert UTF-8 std::string → std::wstring safely
std::wstring toWide(const std::string& input) {
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, NULL, 0);
    std::wstring output(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, input.c_str(), -1, &output[0], size_needed);
    return output;
}

// Convert std::wstring → std::string safely
std::string toNarrow(const std::wstring& input) {
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1, NULL, 0, NULL, NULL);
    std::string output(size_needed, 0);
    WideCharToMultiByte(CP_UTF8, 0, input.c_str(), -1, &output[0], size_needed, NULL, NULL);
    return output;
}

// Parse command line arguments to get appid
std::string getArgValue(const std::string& cmdLine, const std::string& arg) {
    std::istringstream iss(cmdLine);
    std::string token;
    std::string prevToken;
    
    while (iss >> token) {
        // Check for -appid or /appid
        if (token == arg || token == "/" + arg) {
            return prevToken;
        }
        prevToken = token;
    }
    return "";
}

// Simple function to extract appid value
int getAppIdFromArgs(const std::string& cmdLine) {
    std::istringstream iss(cmdLine);
    std::string token;
    
    while (iss >> token) {
        // Look for -appid or /appid
        if (token == "-appid" || token == "/appid") {
            // Next token should be the appid
            if (iss >> token) {
                try {
                    return std::stoi(token);
                } catch (...) {
                    return -1;
                }
            }
        }
    }
    return -1;
}

// HTTP GET request using WinHTTP
std::string httpGet(const std::wstring& url) {
    // Parse URL
    URL_COMPONENTSW urlComp = {};
    urlComp.dwStructSize = sizeof(urlComp);
    
    wchar_t scheme[32] = {};
    wchar_t host[256] = {};
    wchar_t path[1024] = {};
    urlComp.lpszScheme = scheme;
    urlComp.dwSchemeLength = sizeof(scheme) / sizeof(wchar_t);
    urlComp.lpszHostName = host;
    urlComp.dwHostNameLength = sizeof(host) / sizeof(wchar_t);
    urlComp.lpszUrlPath = path;
    urlComp.dwUrlPathLength = sizeof(path) / sizeof(wchar_t);
    
    if (!WinHttpCrackUrl(url.c_str(), url.length(), 0, &urlComp)) {
        return "";
    }
    
    // Use WinHTTP to make the request
    HINTERNET hSession = WinHttpOpen(L"UnionCraxLauncher/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) return "";
    
    HINTERNET hConnect = WinHttpConnect(hSession, host, urlComp.nPort, 0);
    if (!hConnect) {
        WinHttpCloseHandle(hSession);
        return "";
    }
    
    HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", path, NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
    if (!hRequest) {
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return "";
    }
    
    BOOL bResults = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
    if (!bResults) {
        WinHttpCloseHandle(hRequest);
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return "";
    }
    
    bResults = WinHttpReceiveResponse(hRequest, NULL);
    if (!bResults) {
        WinHttpCloseHandle(hRequest);
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return "";
    }
    
    // Read response
    std::string response;
    DWORD dwSize = 0;
    do {
        dwSize = 0;
        if (!WinHttpQueryDataAvailable(hRequest, &dwSize)) break;
        if (dwSize == 0) break;
        
        char* buffer = new char[dwSize + 1];
        ZeroMemory(buffer, dwSize + 1);
        
        DWORD dwDownloaded = 0;
        if (WinHttpReadData(hRequest, buffer, dwSize, &dwDownloaded)) {
            response += buffer;
        }
        delete[] buffer;
    } while (dwSize > 0);
    
    WinHttpCloseHandle(hRequest);
    WinHttpCloseHandle(hConnect);
    WinHttpCloseHandle(hSession);
    
    return response;
}

// Simple JSON value extraction (for basic key-value extraction)
std::string extractJsonField(const std::string& json, const std::string& fieldName) {
    // Look for "fieldName": "value" or "fieldName": value
    std::string searchPattern = "\"" + fieldName + "\":";
    size_t pos = json.find(searchPattern);
    
    if (pos == std::string::npos) {
        // Try with space after colon
        searchPattern = "\"" + fieldName + "\": ";
        pos = json.find(searchPattern);
    }
    
    if (pos == std::string::npos) return "";
    
    pos += searchPattern.length();
    
    // Skip whitespace
    while (pos < json.length() && (json[pos] == ' ' || json[pos] == '\t')) pos++;
    
    if (pos >= json.length()) return "";
    
    // Check if string value
    if (json[pos] == '"') {
        pos++;
        size_t endPos = json.find('"', pos);
        if (endPos == std::string::npos) return "";
        return json.substr(pos, endPos - pos);
    }
    
    // Number or other value
    size_t endPos = pos;
    while (endPos < json.length() && json[endPos] != ',' && json[endPos] != '}' && json[endPos] != ']') endPos++;
    
    std::string value = json.substr(pos, endPos - pos);
    // Trim whitespace
    value.erase(remove_if(value.begin(), value.end(), ::isspace), value.end());
    return value;
}

// Find game entry by appid in JSON array
std::string findGameByAppId(const std::string& json, int appid) {
    // Look for objects that contain "appid": <appid>
    std::string searchAppId = "\"appid\":";
    size_t pos = 0;
    
    while (true) {
        pos = json.find(searchAppId, pos);
        if (pos == std::string::npos) break;
        
        // Check if the number after appid matches
        size_t numStart = pos + searchAppId.length();
        while (numStart < json.length() && (json[numStart] == ' ' || json[numStart] == '\t')) numStart++;
        
        // Extract the number
        size_t numEnd = numStart;
        while (numEnd < json.length() && isdigit(json[numEnd])) numEnd++;
        
        if (numEnd > numStart) {
            std::string numStr = json.substr(numStart, numEnd - numStart);
            try {
                int foundAppId = std::stoi(numStr);
                if (foundAppId == appid) {
                    // Found the right appid, now find the enclosing object
                    // Go backwards to find the opening {
                    size_t objStart = pos;
                    while (objStart > 0 && json[objStart] != '{') objStart--;
                    
                    // Go forward to find the closing }
                    size_t objEnd = numEnd;
                    int braceCount = 0;
                    bool inString = false;
                    while (objEnd < json.length()) {
                        char c = json[objEnd];
                        if (c == '"' && (objEnd == 0 || json[objEnd-1] != '\\')) {
                            inString = !inString;
                        } else if (!inString) {
                            if (c == '{') braceCount++;
                            else if (c == '}') {
                                braceCount--;
                                if (braceCount == 0) break;
                            }
                        }
                        objEnd++;
                    }
                    
                    return json.substr(objStart, objEnd - objStart + 1);
                }
            } catch (...) {
                // Invalid number, continue
            }
        }
        pos = numEnd;
    }
    
    return "";
}

// Write INI file
bool writeIniFile(const std::string& path, const std::string& gameExe, const std::string& workingDir, const std::string& launchArgs) {
    std::ofstream file(path);
    if (!file.is_open()) return false;
    
    file << "[Launcher]" << std::endl;
    file << "# Path to the game executable (required)" << std::endl;
    file << "# Can be absolute path or relative to the launcher's directory" << std::endl;
    file << "gameExe=" << gameExe << std::endl;
    file << std::endl;
    file << "# Working directory for the game (optional)" << std::endl;
    file << "# If not specified, the launcher's directory will be used" << std::endl;
    file << "# Can be absolute path or relative to the launcher's directory" << std::endl;
    file << "workingDir=" << workingDir << std::endl;
    file << std::endl;
    file << "# Command line arguments to pass to the game (optional)" << std::endl;
    file << "# Separate multiple arguments with spaces" << std::endl;
    file << "launchArgs=" << launchArgs << std::endl;
    
    file.close();
    return true;
}

bool fileExists(const std::string& filePath) {
    std::ifstream file(filePath);
    return file.good();
}

// Get string from INI file (Windows API wrapper)
std::string getIniString(const std::string& iniPath, const std::string& section, const std::string& key, const std::string& defaultValue) {
    wchar_t buffer[4096] = {};
    std::wstring wIniPath = toWide(iniPath);
    std::wstring wSection = toWide(section);
    std::wstring wKey = toWide(key);
    
    DWORD result = GetPrivateProfileStringW(
        wSection.c_str(),
        wKey.c_str(),
        toWide(defaultValue).c_str(),
        buffer,
        sizeof(buffer) / sizeof(wchar_t),
        wIniPath.c_str()
    );
    
    return toNarrow(buffer);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // Get the command line as string
    std::string cmdLine(lpCmdLine);
    
    // Get the appid from command line arguments
    int appId = getAppIdFromArgs(cmdLine);
    
    if (appId <= 0) {
        MessageBoxA(NULL,
            "Usage: uc.launcher.exe -appid <appid>\n\n"
            "Example: uc.launcher.exe -appid 4310\n\n"
            "This will load <appid>.ini (e.g., 4310.ini) or fetch from the server if it doesn't exist.",
            "Game Launcher Error", MB_OK | MB_ICONERROR);
        return 1;
    }
    
    // Get the directory where the launcher is located
    char buffer[MAX_PATH];
    GetModuleFileNameA(NULL, buffer, MAX_PATH);

    std::string currentPath(buffer);
    size_t pos = currentPath.find_last_of("\\/");
    std::string exeDir = (pos != std::string::npos) ? currentPath.substr(0, pos) : ".";

    // Build INI path based on appid
    std::string iniPath = exeDir + "\\" + std::to_string(appId) + ".ini";

    // Check if INI file exists
    if (!fileExists(iniPath)) {
        // Try to fetch from API
        MessageBoxA(NULL,
            ("INI file not found for appid " + std::to_string(appId) + ".\n"
            "Attempting to fetch game data from server...").c_str(),
            "Game Launcher", MB_OK | MB_ICONINFORMATION);
        
        std::wstring apiUrlW = L"https://union-crax.xyz/api/games";
        
        std::string response = httpGet(apiUrlW);
        
        if (response.empty()) {
            MessageBoxA(NULL,
                ("Failed to fetch game data from server.\n\n"
                "Please check your internet connection and try again, or create " + std::to_string(appId) + ".ini manually.").c_str(),
                "Game Launcher Error", MB_OK | MB_ICONERROR);
            return 1;
        }
        
        // Find the game by appid in the JSON response
        std::string gameJson = findGameByAppId(response, appId);
        
        if (gameJson.empty()) {
            MessageBoxA(NULL,
                ("Game with appid " + std::to_string(appId) + " not found on the server.\n\n"
                "Please verify the appid is correct.").c_str(),
                "Game Launcher Error", MB_OK | MB_ICONERROR);
            return 1;
        }
        
        // Extract game configuration from JSON
        // These field names need to match the API response
        std::string gameExe = extractJsonField(gameJson, "exe");
        std::string workingDir = extractJsonField(gameJson, "workingDir");
        std::string launchArgs = extractJsonField(gameJson, "launchArgs");
        
        // If fields are empty, try alternate names
        if (gameExe.empty()) gameExe = extractJsonField(gameJson, "gameExe");
        if (workingDir.empty()) workingDir = extractJsonField(gameJson, "working_directory");
        if (workingDir.empty()) workingDir = ".";
        
        if (gameExe.empty()) {
            MessageBoxA(NULL,
                ("Game configuration incomplete for appid " + std::to_string(appId) + ".\n\n"
                "The server response is missing required game information.").c_str(),
                "Game Launcher Error", MB_OK | MB_ICONERROR);
            return 1;
        }
        
        // Save the fetched configuration as INI file
        if (!writeIniFile(iniPath, gameExe, workingDir, launchArgs)) {
            MessageBoxA(NULL,
                ("Failed to save configuration file.\n\n"
                "Could not write to: " + iniPath).c_str(),
                "Game Launcher Error", MB_OK | MB_ICONERROR);
            return 1;
        }
        
        MessageBoxA(NULL,
            ("Successfully fetched game data and saved configuration to:\n" + iniPath).c_str(),
            "Game Launcher", MB_OK | MB_ICONINFORMATION);
    }

    // Read configuration from INI file
    std::string exePath = getIniString(iniPath, "Launcher", "gameExe", "");
    std::string workingDir = getIniString(iniPath, "Launcher", "workingDir", ".");
    std::string arguments = getIniString(iniPath, "Launcher", "launchArgs", "");

    // Validate required gameExe
    if (exePath.empty()) {
        MessageBoxA(NULL,
            ("The 'gameExe' setting is missing or empty in " + std::to_string(appId) + ".ini.\n"
            "Please configure the gameExe path relative to the launcher.").c_str(),
            "Game Launcher Error", MB_OK | MB_ICONERROR);
        return 1;
    }

    // Check if the executable exists
    if (!fileExists(exePath)) {
        MessageBoxA(NULL,
            ("Failed to find the game executable:\n" + exePath).c_str(),
            "Game Launcher Error", MB_OK | MB_ICONERROR);
        return 1;
    }

    // Build the full command line
    std::string commandLineStr = "\"" + exePath + "\"";
    
    // Add arguments if specified
    if (!arguments.empty()) {
        commandLineStr += " " + arguments;
    }

    std::wstring cmdW = toWide(commandLineStr);
    std::wstring workingDirW = toWide(workingDir);

    STARTUPINFOW si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    ZeroMemory(&pi, sizeof(pi));
    si.cb = sizeof(si);

    // Launch the game
    BOOL result = CreateProcessW(
        NULL,
        &cmdW[0],             // writable buffer required by WinAPI
        NULL,
        NULL,
        FALSE,
        0,
        NULL,
        workingDirW.empty() ? NULL : workingDirW.c_str(),
        &si,
        &pi
    );

    if (!result) {
        DWORD error = GetLastError();
        MessageBoxA(NULL,
            ("Failed to launch the game.\n"
             "Error code: " + std::to_string(error) + "\n\n"
             "Command: " + commandLineStr + "\n"
             "Working directory: " + workingDir).c_str(),
            "Game Launcher Error",
            MB_OK | MB_ICONERROR);
        return 1;
    }

    // Clean up handles
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    return 0;
}