Added Host UI for adding player usernames to a roster, implemented HTTP request to Mojang API to fetch UUIDs, added display names and roster persistence for settings.json.

LNXSeus · LNXSeus · commit dcd666b3f637 · 2026-04-06T03:06:12.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -62,6 +62,7 @@ set(SOURCE_FILES
         "source/temp_creator.cpp"
         "source/temp_creator_utils.cpp"
         "source/template_scanner.cpp"
+        "source/mojang_api.cpp"
         "source/update_checker.cpp"
         "source/logger.cpp"
         "source/dialog_utils.cpp"
diff --git a/source/mojang_api.cpp b/source/mojang_api.cpp
@@ -0,0 +1,97 @@
+// Copyright (c) 2026 LNXSeus. All Rights Reserved.
+//
+// This project is proprietary software. You are granted a license to use the software as-is.
+// You may not copy, distribute, modify, reverse-engineer, maintain a fork, or use this software
+// or its source code in any way without the express written permission of the copyright holder.
+//
+// Created by Linus on 06.04.2026.
+//
+
+#include "mojang_api.h"
+#include "logger.h"
+#include <cJSON.h>
+#include <curl/curl.h>
+#include <string>
+#include <cstring>
+#include <cstdio>
+
+// Path to the CA certificate bundle (same as update_checker.cpp)
+#define CERT_BUNDLE_PATH "resources/ca_certificates/cacert.pem"
+
+// Callback function for libcurl to write received data into a std::string
+static size_t mojang_write_callback(void *contents, size_t size, size_t nmemb, std::string *s) {
+    size_t new_length = size * nmemb;
+    try {
+        s->append((char *) contents, new_length);
+    } catch (std::bad_alloc &) {
+        return 0;
+    }
+    return new_length;
+}
+
+// Formats a raw 32-char UUID into the hyphenated form: 8-4-4-4-12
+static void format_uuid_with_hyphens(const char *raw, char *out, size_t out_len) {
+    snprintf(out, out_len, "%.8s-%.4s-%.4s-%.4s-%.12s",
+             raw, raw + 8, raw + 12, raw + 16, raw + 20);
+}
+
+bool mojang_fetch_uuid(const char *username, char *out_uuid, size_t uuid_max_len) {
+    if (!username || username[0] == '\0' || !out_uuid || uuid_max_len < 37) {
+        return false;
+    }
+    out_uuid[0] = '\0';
+
+    // Build the API URL
+    char url[256];
+    snprintf(url, sizeof(url), "https://api.mojang.com/users/profiles/minecraft/%s", username);
+
+    CURL *curl = curl_easy_init();
+    if (!curl) {
+        log_message(LOG_ERROR, "[MOJANG API] Failed to initialize curl.\n");
+        return false;
+    }
+
+    std::string read_buffer;
+    bool success = false;
+
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "Advancely/1.0");
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mojang_write_callback);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &read_buffer);
+    curl_easy_setopt(curl, CURLOPT_CAINFO, CERT_BUNDLE_PATH);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L); // 10 second timeout
+
+    CURLcode res = curl_easy_perform(curl);
+    if (res == CURLE_OK) {
+        long http_code = 0;
+        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
+
+        if (http_code == 200) {
+            cJSON *json = cJSON_Parse(read_buffer.c_str());
+            if (json) {
+                const cJSON *id_json = cJSON_GetObjectItem(json, "id");
+                if (cJSON_IsString(id_json) && id_json->valuestring && strlen(id_json->valuestring) == 32) {
+                    format_uuid_with_hyphens(id_json->valuestring, out_uuid, uuid_max_len);
+                    log_message(LOG_INFO, "[MOJANG API] Fetched UUID for '%s': %s\n", username, out_uuid);
+                    success = true;
+                } else {
+                    log_message(LOG_ERROR, "[MOJANG API] Unexpected 'id' field in response for '%s'.\n", username);
+                }
+                cJSON_Delete(json);
+            } else {
+                log_message(LOG_ERROR, "[MOJANG API] Failed to parse JSON response for '%s'.\n", username);
+            }
+        } else if (http_code == 404) {
+            log_message(LOG_INFO, "[MOJANG API] Player '%s' not found (404).\n", username);
+        } else {
+            log_message(LOG_ERROR, "[MOJANG API] Unexpected HTTP status %ld for '%s'.\n", http_code, username);
+        }
+    } else {
+        log_message(LOG_ERROR, "[MOJANG API] curl_easy_perform() failed for '%s': %s\n",
+                    username, curl_easy_strerror(res));
+    }
+
+    curl_easy_cleanup(curl);
+    return success;
+}
diff --git a/source/mojang_api.h b/source/mojang_api.h
@@ -0,0 +1,37 @@
+// Copyright (c) 2026 LNXSeus. All Rights Reserved.
+//
+// This project is proprietary software. You are granted a license to use the software as-is.
+// You may not copy, distribute, modify, reverse-engineer, maintain a fork, or use this software
+// or its source code in any way without the express written permission of the copyright holder.
+//
+// Created by Linus on 06.04.2026.
+//
+
+#ifndef MOJANG_API_H
+#define MOJANG_API_H
+
+#include <cstddef> // For size_t
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Fetches a Minecraft player's UUID from the Mojang API.
+ *
+ * Sends a GET request to https://api.mojang.com/users/profiles/minecraft/<username>
+ * and parses the UUID from the JSON response. The returned UUID is formatted with
+ * hyphens (e.g., "069a79f4-44e9-4726-a5be-fca90e38aaf5").
+ *
+ * @param username The Minecraft username to look up.
+ * @param out_uuid Buffer to store the resulting UUID string (with hyphens).
+ * @param uuid_max_len Size of the out_uuid buffer (should be at least 48).
+ * @return true if the UUID was successfully fetched, false on error or if the player doesn't exist.
+ */
+bool mojang_fetch_uuid(const char *username, char *out_uuid, size_t uuid_max_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //MOJANG_API_H
diff --git a/source/settings.cpp b/source/settings.cpp
@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "dialog_utils.h"
+#include "mojang_api.h"
 #include "settings_utils.h" // ImGui imported through this
 #include "global_event_handler.h" // For global variables
 #include "path_utils.h" // For path_exists()
@@ -124,10 +125,20 @@ static bool are_settings_different(const AppSettings *a, const AppSettings *b) {
         a->network_mode != b->network_mode ||
         a->coop_goal_logic != b->coop_goal_logic ||
         strcmp(a->host_port, b->host_port) != 0 ||
-        strcmp(a->receiver_invite_code, b->receiver_invite_code) != 0) {
+        strcmp(a->receiver_invite_code, b->receiver_invite_code) != 0 ||
+        a->coop_player_count != b->coop_player_count) {
         return true;
     }
 
+    // Compare player roster
+    for (int i = 0; i < a->coop_player_count; ++i) {
+        if (strcmp(a->coop_players[i].username, b->coop_players[i].username) != 0 ||
+            strcmp(a->coop_players[i].uuid, b->coop_players[i].uuid) != 0 ||
+            strcmp(a->coop_players[i].display_name, b->coop_players[i].display_name) != 0) {
+            return true;
+        }
+    }
+
     // Compare hotkeys separately
     if (a->hotkey_count != b->hotkey_count) return true;
     for (int i = 0; i < a->hotkey_count; ++i) {
@@ -2340,6 +2351,125 @@ ImGui::SetTooltip("%s", tooltip_buffer); \
                 ImGui::Separator();
                 ImGui::Spacing();
 
+                // --- Player Roster ---
+                ImGui::Text("Player Roster");
+                ImGui::TextDisabled("Add Minecraft usernames to track. UUIDs are fetched automatically.");
+                ImGui::Spacing();
+
+                // Add player input
+                static char new_username[64] = "";
+                static char roster_status_msg[256] = "";
+                static bool roster_status_is_error = false;
+
+                ImGui::SetNextItemWidth(200.0f);
+                ImGui::InputText("##new_username", new_username, sizeof(new_username));
+                ImGui::SameLine();
+                bool can_add = new_username[0] != '\0' && temp_settings.coop_player_count < MAX_COOP_PLAYERS;
+                if (!can_add) ImGui::BeginDisabled();
+                if (ImGui::Button("Add Player")) {
+                    // Check for duplicate username
+                    bool duplicate = false;
+                    for (int i = 0; i < temp_settings.coop_player_count; i++) {
+                        if (strcmp(temp_settings.coop_players[i].username, new_username) == 0) {
+                            duplicate = true;
+                            break;
+                        }
+                    }
+                    if (duplicate) {
+                        snprintf(roster_status_msg, sizeof(roster_status_msg),
+                                 "Player '%s' is already in the roster.", new_username);
+                        roster_status_is_error = true;
+                    } else {
+                        char fetched_uuid[48] = "";
+                        bool fetched = mojang_fetch_uuid(new_username, fetched_uuid, sizeof(fetched_uuid));
+                        if (fetched) {
+                            CoopPlayer *p = &temp_settings.coop_players[temp_settings.coop_player_count];
+                            memset(p, 0, sizeof(CoopPlayer));
+                            strncpy(p->username, new_username, sizeof(p->username) - 1);
+                            strncpy(p->uuid, fetched_uuid, sizeof(p->uuid) - 1);
+                            p->display_name[0] = '\0';
+                            temp_settings.coop_player_count++;
+                            snprintf(roster_status_msg, sizeof(roster_status_msg),
+                                     "Added '%s' (UUID: %s)", new_username, fetched_uuid);
+                            roster_status_is_error = false;
+                            new_username[0] = '\0';
+                        } else {
+                            snprintf(roster_status_msg, sizeof(roster_status_msg),
+                                     "Could not find player '%s'.\n"
+                                     "Check the username.", new_username);
+                            roster_status_is_error = true;
+                        }
+                    }
+                }
+                if (!can_add) ImGui::EndDisabled();
+
+                if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) {
+                    char tooltip_buf[256];
+                    if (temp_settings.coop_player_count >= MAX_COOP_PLAYERS) {
+                        snprintf(tooltip_buf, sizeof(tooltip_buf), "Roster is full (%d players max).", MAX_COOP_PLAYERS);
+                    } else {
+                        snprintf(tooltip_buf, sizeof(tooltip_buf),
+                                 "Type a Minecraft username and click to fetch their UUID\n"
+                                 "from the Mojang API and add them to the roster.");
+                    }
+                    ImGui::SetTooltip("%s", tooltip_buf);
+                }
+
+                // Status message
+                if (roster_status_msg[0] != '\0') {
+                    if (roster_status_is_error)
+                        ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "%s", roster_status_msg);
+                    else
+                        ImGui::TextColored(ImVec4(0.4f, 1.0f, 0.4f, 1.0f), "%s", roster_status_msg);
+                }
+
+                ImGui::Spacing();
+
+                // Player list
+                int remove_index = -1;
+                for (int i = 0; i < temp_settings.coop_player_count; i++) {
+                    ImGui::PushID(i + 1000); // Offset to avoid ID conflicts with goal logic
+                    CoopPlayer *p = &temp_settings.coop_players[i];
+
+                    // Display name (editable)
+                    ImGui::SetNextItemWidth(120.0f);
+                    char display_label[128];
+                    snprintf(display_label, sizeof(display_label), "##display_%d", i);
+                    ImGui::InputTextWithHint(display_label, "Display Name", p->display_name, sizeof(p->display_name));
+                    if (ImGui::IsItemHovered()) {
+                        char tooltip_buf[256];
+                        snprintf(tooltip_buf, sizeof(tooltip_buf),
+                                 "Custom display name (leave empty to use '%s').\n"
+                                 "UUID: %s",
+                                 p->username, p->uuid);
+                        ImGui::SetTooltip("%s", tooltip_buf);
+                    }
+
+                    ImGui::SameLine();
+                    ImGui::TextDisabled("%s", p->username);
+
+                    ImGui::SameLine();
+                    if (ImGui::SmallButton("Remove")) {
+                        remove_index = i;
+                    }
+
+                    ImGui::PopID();
+                }
+
+                // Handle removal
+                if (remove_index >= 0) {
+                    for (int i = remove_index; i < temp_settings.coop_player_count - 1; i++) {
+                        temp_settings.coop_players[i] = temp_settings.coop_players[i + 1];
+                    }
+                    temp_settings.coop_player_count--;
+                    memset(&temp_settings.coop_players[temp_settings.coop_player_count], 0, sizeof(CoopPlayer));
+                    roster_status_msg[0] = '\0';
+                }
+
+                ImGui::Spacing();
+                ImGui::Separator();
+                ImGui::Spacing();
+
                 // Invite Code Generation (placeholder - will be functional with networking)
                 ImGui::Text("Invite Code");
                 ImGui::TextDisabled("Generate an invite code to share with receivers.");
diff --git a/source/settings_utils.cpp b/source/settings_utils.cpp
@@ -437,6 +437,8 @@ void settings_set_defaults(AppSettings *settings) {
     strncpy(settings->host_port, DEFAULT_HOST_PORT, sizeof(settings->host_port) - 1);
     settings->host_port[sizeof(settings->host_port) - 1] = '\0';
     settings->receiver_invite_code[0] = '\0';
+    settings->coop_player_count = 0;
+    memset(settings->coop_players, 0, sizeof(settings->coop_players));
 }
 
 bool settings_load(AppSettings *settings) {
@@ -1110,6 +1112,32 @@ bool settings_load(AppSettings *settings) {
         } else {
             settings->receiver_invite_code[0] = '\0';
         }
+
+        // Load player roster
+        const cJSON *roster_json = cJSON_GetObjectItem(coop_settings, "player_roster");
+        settings->coop_player_count = 0;
+        if (cJSON_IsArray(roster_json)) {
+            cJSON *player_item;
+            cJSON_ArrayForEach(player_item, roster_json) {
+                if (settings->coop_player_count >= MAX_COOP_PLAYERS) break;
+                CoopPlayer *p = &settings->coop_players[settings->coop_player_count];
+                memset(p, 0, sizeof(CoopPlayer));
+
+                const cJSON *uname = cJSON_GetObjectItem(player_item, "username");
+                if (uname && cJSON_IsString(uname)) {
+                    strncpy(p->username, uname->valuestring, sizeof(p->username) - 1);
+                }
+                const cJSON *uid = cJSON_GetObjectItem(player_item, "uuid");
+                if (uid && cJSON_IsString(uid)) {
+                    strncpy(p->uuid, uid->valuestring, sizeof(p->uuid) - 1);
+                }
+                const cJSON *dname = cJSON_GetObjectItem(player_item, "display_name");
+                if (dname && cJSON_IsString(dname)) {
+                    strncpy(p->display_name, dname->valuestring, sizeof(p->display_name) - 1);
+                }
+                settings->coop_player_count++;
+            }
+        }
     } else {
         defaults_were_used = true;
     }
@@ -1312,6 +1340,18 @@ void settings_save(const AppSettings *settings, const TemplateData *td, Settings
         cJSON_AddItemToObject(coop_obj, "host_port", cJSON_CreateString(settings->host_port));
         cJSON_DeleteItemFromObject(coop_obj, "receiver_invite_code");
         cJSON_AddItemToObject(coop_obj, "receiver_invite_code", cJSON_CreateString(settings->receiver_invite_code));
+
+        // Save player roster
+        cJSON_DeleteItemFromObject(coop_obj, "player_roster");
+        cJSON *roster_arr = cJSON_CreateArray();
+        for (int i = 0; i < settings->coop_player_count && i < MAX_COOP_PLAYERS; i++) {
+            cJSON *player_obj = cJSON_CreateObject();
+            cJSON_AddItemToObject(player_obj, "username", cJSON_CreateString(settings->coop_players[i].username));
+            cJSON_AddItemToObject(player_obj, "uuid", cJSON_CreateString(settings->coop_players[i].uuid));
+            cJSON_AddItemToObject(player_obj, "display_name", cJSON_CreateString(settings->coop_players[i].display_name));
+            cJSON_AddItemToArray(roster_arr, player_obj);
+        }
+        cJSON_AddItemToObject(coop_obj, "player_roster", roster_arr);
     }
 
 
diff --git a/source/settings_utils.h b/source/settings_utils.h
@@ -64,6 +64,7 @@ extern const char *TRACKER_SECTION_NAMES[SECTION_COUNT];
 
 #define MAX_WORLD_NOTES 32 // Limit for amount of per-world notes until they delete itself
 #define MAX_HOTKEYS 32 // Limit for amount of hotkeys
+#define MAX_COOP_PLAYERS 32 // Maximum number of players in a co-op session
 
 // DEFAULT values
 #define DEFAULT_ENABLE_OVERLAY false // Stream overlay will be off by default
@@ -147,6 +148,13 @@ extern const char *TRACKER_SECTION_NAMES[SECTION_COUNT];
 
 struct TemplateData;
 
+// A player in the co-op roster (Host tracks these)
+typedef struct {
+    char username[64];      // Minecraft username e.g., Notch
+    char uuid[48];          // UUID from Mojang API (with hyphens, e.g., "069a79f4-44e9-4726-a5be-fca90e38aaf5")
+    char display_name[64];  // Optional custom display name (empty = use username)
+} CoopPlayer;
+
 typedef struct {
     char target_goal[192];
     char increment_key[32];
@@ -319,6 +327,10 @@ struct AppSettings {
     CoopGoalLogic coop_goal_logic; // How to merge progress from multiple players
     char host_port[16]; // The port the host listens on (default "25565" - Force Port Mod)
     char receiver_invite_code[512]; // Base64-encoded connection string pasted by receivers
+
+    // --- Player Roster (Host only) ---
+    int coop_player_count; // Number of players in the roster
+    CoopPlayer coop_players[MAX_COOP_PLAYERS]; // The player roster
 };
 
 
