score-server.cpp

// license:GPLv3+

#include "plugins/MsgPlugin.h"
#include "plugins/LoggingPlugin.h"
#include "plugins/ControllerPlugin.h"
#include "plugins/VPXPlugin.h"
#include "plugins/ScriptablePlugin.h"

#include <string>
#include <vector>
#include <fstream>
#include <filesystem>
#include <cstdint>
#include <sstream>
#include <iomanip>
#include <cstdarg>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
#include <cstring>

// For JSON parsing - using a simple JSON parser approach
#include <map>
#include <set>
#include <algorithm>

// WebSocket support
#ifdef _WIN32
   #define WIN32_LEAN_AND_MEAN
   #undef TEXT
   #include <winsock2.h>
   #include <ws2tcpip.h>
   #pragma comment(lib, "ws2_32.lib")
   typedef int socklen_t;
   #include <windows.h>
   #define SHUT_RDWR SD_BOTH
#else
   #include <sys/types.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <netinet/tcp.h>
   #include <arpa/inet.h>
   #include <unistd.h>
   #include <netdb.h>
   #include <dlfcn.h>
   #include <limits.h>
   typedef int SOCKET;
   #define INVALID_SOCKET -1
   #define SOCKET_ERROR -1
   #define closesocket close
#endif

///////////////////////////////////////////////////////////////////////////////
// Minimal portable UDP sockets
// Derived from https://github.com/simondlevy/CppSockets (MIT licensed)

#ifndef _WIN32
   #define sprintf_s snprintf
#endif

class UdpClientSocket
{
protected:
   SOCKET _sock;
   struct sockaddr_in _si_other {};
   socklen_t _slen = sizeof(_si_other);
   char _message[200];

   bool initWinsock()
   {
      // Winsock initialization is handled by PluginLoad/PluginUnload
      return true;
   }

   void inetPton(const char* host, struct sockaddr_in& saddr_in)
   {
      #ifdef _WIN32
         #ifdef _UNICODE
            InetPtonA(AF_INET, host, &(saddr_in.sin_addr.s_addr));
         #else
            InetPton(AF_INET, host, &(saddr_in.sin_addr.s_addr));
         #endif
      #else
         inet_pton(AF_INET, host, &(saddr_in.sin_addr));
      #endif
   }

public:
   UdpClientSocket(const char* host, const short port)
   {
      _sock = INVALID_SOCKET;
      _message[0] = '\0';

      // Initialize Winsock, returning on failure
      if (!initWinsock())
         return;

      // Create socket
      _sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
      if (_sock == SOCKET_ERROR)
      {
         sprintf_s(_message, sizeof(_message), "socket() failed");
         _sock = INVALID_SOCKET;
         return;
      }

      // Setup address structure
      memset((char*)&_si_other, 0, sizeof(_si_other));
      _si_other.sin_family = AF_INET;
      _si_other.sin_port = htons(port);
      inetPton(host, _si_other);
   }

   ~UdpClientSocket()
   {
      if (_sock != INVALID_SOCKET)
      {
         closesocket(_sock);
      }
   }

   int sendData(const void* buf, size_t len)
   {
      if (_sock == INVALID_SOCKET)
         return -1;
      return sendto(_sock, (const char*)buf, (int)len, 0, (struct sockaddr*)&_si_other, (int)_slen);
   }

   bool isValid() const { return _sock != INVALID_SOCKET; }
   const char* getMessage() const { return _message; }
};

namespace ScoreServer {

const MsgPluginAPI* msgApi = nullptr;
VPXPluginAPI* vpxApi = nullptr;
ScriptablePluginAPI* scriptApi = nullptr;

uint32_t endpointId;
unsigned int getVpxApiId, getScriptApiId, getControllerId, onGameEndId, onGameStartId, onPrepareFrameId;

// Plugin settings
MSGPI_STRING_VAL_SETTING(machineIdProp, "MachineId", "Machine ID", "Unique identifier for this machine", false, "", 256);

// Broadcast mode configuration
const char* broadcastModeLiterals[] = { "WebSocket", "UDP", "Both" };
MSGPI_ENUM_VAL_SETTING(broadcastModeProp, "BroadcastMode", "Broadcast Mode", "Select broadcast method: WebSocket server, UDP endpoint, or Both", false, 1, 3, broadcastModeLiterals, 1);
MSGPI_STRING_VAL_SETTING(udpHostProp, "UdpHost", "UDP Host", "UDP endpoint hostname or IP address (e.g., 192.168.1.100)", false, "", 256);
MSGPI_INT_VAL_SETTING(udpPortProp, "UdpPort", "UDP Port", "UDP endpoint port number (e.g., 9000)", false, 0, 65535, 0);

// UDP client for endpoint broadcasting
UdpClientSocket* udpClient = nullptr;

std::string currentRomName;
std::string nvramMapsPath;
std::string currentMapPath;
std::vector<uint8_t> nvramData;
size_t nvramBaseAddress = 0;  // NVRAM base address from platform file
bool nvramFromController = false;  // True if NVRAM came from Controller (flat memory), false if from disk (.nv file)
bool nvramHighNibbleOnly = false;  // True if NVRAM uses only high nibble (e.g., Bally games)

// TODO: To get NVRAM directly from the Controller, we need the PinMAME plugin to expose
// the Controller object pointer via a message or event. For now, this remains nullptr
// and we fall back to reading from disk files.
void* pinmameController = nullptr;  // Pointer to PinMAME Controller object (not currently available)

// Previous game state for change detection
std::vector<std::string> previousScores;
int previousPlayerCount = 0;
int previousCurrentPlayer = 0;
int previousCurrentBall = 0;
bool previousGameOver = false;
bool gameEndSent = false;
bool firstStateCheck = true;

// Game start timestamp for minimum duration check
std::chrono::steady_clock::time_point gameStartTime;
// Sometimes the game_start and game_end events are fired during the
// initialization of the table/plugin. To avoid false positives, we will 
// ignore any game that ends within 60 seconds of starting, as it's unlikely to be a valid play session.  
// Minimum 60 seconds for a valid game
// Not sure if this could be related to the plugins being still on hard development. 
const std::chrono::seconds MIN_GAME_DURATION(60); 

// Ball-drop fallback game-over detection
// Stores the scores from the last game_end we sent, so we don't re-trigger
// for the same scores lingering in attract mode after a game ends
std::vector<std::string> lastGameEndScores;


// WebSocket server
std::atomic<bool> wsServerRunning{false};
std::thread wsServerThread;
SOCKET wsServerSocket = INVALID_SOCKET;
std::vector<SOCKET> wsClients;
std::mutex wsClientsMutex;

// Message queue for initial 60 seconds
std::vector<std::string> messageQueue;
std::mutex messageQueueMutex;
std::chrono::steady_clock::time_point serverStartTime;
const std::chrono::seconds MESSAGE_QUEUE_DURATION(60);

PSC_USE_ERROR();
PSC_ERROR_IMPLEMENT(scriptApi);

LPI_IMPLEMENT // Implement shared log support

#define LOGD LPI_LOGD
#define LOGI LPI_LOGI
#define LOGW LPI_LOGW
#define LOGE LPI_LOGE

// Get current timestamp in ISO 8601 format
std::string getTimestamp() {
    auto now = std::chrono::system_clock::now();
    auto time_t_now = std::chrono::system_clock::to_time_t(now);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()) % 1000;

    std::stringstream ss;
    ss << std::put_time(std::gmtime(&time_t_now), "%Y-%m-%dT%H:%M:%S");
    ss << '.' << std::setfill('0') << std::setw(3) << ms.count() << 'Z';
    return ss.str();
}

///////////////////////////////////////////////////////////////////////////////
// Forward declarations
void broadcastWebSocket(const std::string& message);

// Helper to add machine_id field to JSON messages if configured
std::string addMachineIdField() {
    const char* machineId = machineIdProp_Get();
    if (machineId && machineId[0] != '\0') {
        return std::string(",\"machine_id\":\"") + machineId + "\"";
    }
    return "";
}

///////////////////////////////////////////////////////////////////////////////
// Scriptable table state (for ROM-less tables)

struct TableScore {
    int player;
    std::string score;
    int ball;
};

struct TableHighScore {
    std::string label;
    std::string initials;
    std::string score;
};

std::vector<TableScore> tableScores;
std::vector<TableHighScore> tableHighScores;
std::string tableGameName;  // For ROM-less tables
int tablePlayerCount = 0;
int tableCurrentPlayer = 0;
int tableCurrentBall = 0;
std::mutex tableStateMutex;  // Protect table state from concurrent access

// Broadcast table scores via WebSocket
void broadcastTableScores() {
    std::lock_guard<std::mutex> lock(tableStateMutex);
    if (tableGameName.empty()) return;

    std::stringstream jsonOutput;
    jsonOutput << "{\"type\":\"current_scores\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << tableGameName << "\""
               << addMachineIdField() << ","
               << "\"players\":" << tablePlayerCount << ","
               << "\"current_player\":" << tableCurrentPlayer << ","
               << "\"current_ball\":" << tableCurrentBall << ","
               << "\"scores\":[";

    for (size_t i = 0; i < tableScores.size(); i++) {
        if (i > 0) jsonOutput << ",";
        jsonOutput << "{\"player\":\"Player " << tableScores[i].player << "\","
                   << "\"score\":\"" << tableScores[i].score << "\"}";
    }

    jsonOutput << "]}";
    broadcastWebSocket(jsonOutput.str());
}

// Broadcast table high scores via WebSocket
void broadcastTableHighScores() {
    std::lock_guard<std::mutex> lock(tableStateMutex);
    if (tableGameName.empty()) return;

    std::stringstream jsonOutput;
    jsonOutput << "{\"type\":\"high_scores\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << tableGameName << "\""
               << addMachineIdField() << ","
               << "\"scores\":[";

    for (size_t i = 0; i < tableHighScores.size(); i++) {
        if (i > 0) jsonOutput << ",";
        jsonOutput << "{\"label\":\"" << tableHighScores[i].label << "\","
                   << "\"initials\":\"" << tableHighScores[i].initials << "\","
                   << "\"score\":\"" << tableHighScores[i].score << "\"}";
    }

    jsonOutput << "]}";
    broadcastWebSocket(jsonOutput.str());
}

// Broadcast a single badge via WebSocket
void broadcastBadge(const std::string& player, const std::string& name, const std::string& description) {
    std::lock_guard<std::mutex> lock(tableStateMutex);
    if (tableGameName.empty()) return;

    std::stringstream jsonOutput;
    jsonOutput << "{\"type\":\"badge\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << tableGameName << "\""
               << addMachineIdField() << ","
               << "\"player\":\"" << player << "\","
               << "\"name\":\"" << name << "\","
               << "\"description\":\"" << description << "\"}";

    broadcastWebSocket(jsonOutput.str());
}

///////////////////////////////////////////////////////////////////////////////
// WebSocket implementation

// Base64 encoding for WebSocket handshake
static const char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

std::string base64_encode(const unsigned char* data, size_t len) {
    std::string ret;
    int i = 0;
    unsigned char array_3[3];
    unsigned char array_4[4];

    while (len--) {
        array_3[i++] = *(data++);
        if (i == 3) {
            array_4[0] = (array_3[0] & 0xfc) >> 2;
            array_4[1] = ((array_3[0] & 0x03) << 4) + ((array_3[1] & 0xf0) >> 4);
            array_4[2] = ((array_3[1] & 0x0f) << 2) + ((array_3[2] & 0xc0) >> 6);
            array_4[3] = array_3[2] & 0x3f;

            for(i = 0; i < 4; i++)
                ret += base64_chars[array_4[i]];
            i = 0;
        }
    }

    if (i) {
        for(int j = i; j < 3; j++)
            array_3[j] = '\0';

        array_4[0] = (array_3[0] & 0xfc) >> 2;
        array_4[1] = ((array_3[0] & 0x03) << 4) + ((array_3[1] & 0xf0) >> 4);
        array_4[2] = ((array_3[1] & 0x0f) << 2) + ((array_3[2] & 0xc0) >> 6);

        for (int j = 0; j < i + 1; j++)
            ret += base64_chars[array_4[j]];

        while(i++ < 3)
            ret += '=';
    }

    return ret;
}

// SHA-1 hash for WebSocket handshake
void sha1(const std::string& input, unsigned char output[20]) {
    // Simplified SHA-1 implementation
    uint32_t h0 = 0x67452301;
    uint32_t h1 = 0xEFCDAB89;
    uint32_t h2 = 0x98BADCFE;
    uint32_t h3 = 0x10325476;
    uint32_t h4 = 0xC3D2E1F0;

    std::vector<uint8_t> msg(input.begin(), input.end());
    size_t ml = msg.size() * 8;
    msg.push_back(0x80);
    while ((msg.size() % 64) != 56) {
        msg.push_back(0);
    }
    for (int i = 7; i >= 0; i--) {
        msg.push_back((ml >> (i * 8)) & 0xFF);
    }

    for (size_t chunk = 0; chunk < msg.size(); chunk += 64) {
        uint32_t w[80];
        for (int i = 0; i < 16; i++) {
            w[i] = (msg[chunk + i*4] << 24) | (msg[chunk + i*4 + 1] << 16) |
                   (msg[chunk + i*4 + 2] << 8) | msg[chunk + i*4 + 3];
        }
        for (int i = 16; i < 80; i++) {
            uint32_t temp = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
            w[i] = (temp << 1) | (temp >> 31);
        }

        uint32_t a = h0, b = h1, c = h2, d = h3, e = h4;
        for (int i = 0; i < 80; i++) {
            uint32_t f, k;
            if (i < 20) {
                f = (b & c) | ((~b) & d);
                k = 0x5A827999;
            } else if (i < 40) {
                f = b ^ c ^ d;
                k = 0x6ED9EBA1;
            } else if (i < 60) {
                f = (b & c) | (b & d) | (c & d);
                k = 0x8F1BBCDC;
            } else {
                f = b ^ c ^ d;
                k = 0xCA62C1D6;
            }
            uint32_t temp = ((a << 5) | (a >> 27)) + f + e + k + w[i];
            e = d;
            d = c;
            c = (b << 30) | (b >> 2);
            b = a;
            a = temp;
        }

        h0 += a;
        h1 += b;
        h2 += c;
        h3 += d;
        h4 += e;
    }

    for (int i = 0; i < 4; i++) {
        output[i] = (h0 >> (24 - i * 8)) & 0xFF;
        output[i + 4] = (h1 >> (24 - i * 8)) & 0xFF;
        output[i + 8] = (h2 >> (24 - i * 8)) & 0xFF;
        output[i + 12] = (h3 >> (24 - i * 8)) & 0xFF;
        output[i + 16] = (h4 >> (24 - i * 8)) & 0xFF;
    }
}

// Send WebSocket frame
void sendWebSocketFrame(SOCKET sock, const std::string& message) {
    std::vector<uint8_t> frame;
    frame.push_back(0x81); // FIN + text frame

    size_t len = message.size();
    if (len < 126) {
        frame.push_back(static_cast<uint8_t>(len));
    } else if (len < 65536) {
        frame.push_back(126);
        frame.push_back((len >> 8) & 0xFF);
        frame.push_back(len & 0xFF);
    } else {
        frame.push_back(127);
        for (int i = 7; i >= 0; i--) {
            frame.push_back((len >> (i * 8)) & 0xFF);
        }
    }

    frame.insert(frame.end(), message.begin(), message.end());
    send(sock, reinterpret_cast<const char*>(frame.data()), frame.size(), 0);
}

// Broadcast to all WebSocket clients
void broadcastWebSocket(const std::string& message) {
    // Send via UDP if UDP mode is enabled
    int broadcastMode = broadcastModeProp_Val;  // 1=WebSocket, 2=UDP, 3=Both
    if ((broadcastMode == 2 || broadcastMode == 3) && udpClient && udpClient->isValid()) {
        int sent = udpClient->sendData(message.c_str(), message.length());
        if (sent < 0) {
            LOGW("Failed to send UDP message");
        } else {
            LOGI("UDP message sent: %d bytes", sent);
        }
    } else if (broadcastMode == 2 || broadcastMode == 3) {
        LOGW("UDP mode enabled but udpClient is not valid (client=%p, valid=%d)",
             udpClient, udpClient ? udpClient->isValid() : 0);
    }

    // If UDP-only mode, skip WebSocket broadcasting
    if (broadcastMode == 2) {
        return;
    }

    std::lock_guard<std::mutex> lock(wsClientsMutex);

    // Check if we're within the message queuing window (first 60 seconds)
    auto now = std::chrono::steady_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - serverStartTime);
    bool withinQueueWindow = elapsed < MESSAGE_QUEUE_DURATION;

    // If past queue window and queue is not empty, clear it
    if (!withinQueueWindow) {
        std::lock_guard<std::mutex> queueLock(messageQueueMutex);
        if (!messageQueue.empty()) {
            LOGI("Message queue window expired - clearing %zu queued messages", messageQueue.size());
            messageQueue.clear();
        }
    }

    // If no clients connected and within queue window, queue the message
    if (wsClients.empty() && withinQueueWindow) {
        std::lock_guard<std::mutex> queueLock(messageQueueMutex);
        messageQueue.push_back(message);
        LOGI("No clients connected - queued message (%zu messages in queue, %lld seconds elapsed)",
             messageQueue.size(), elapsed.count());
        return;
    }

    // If no clients and past queue window, just drop the message
    if (wsClients.empty()) {
        return;
    }

    // Build the frame once for all clients
    std::vector<uint8_t> frame;
    frame.push_back(0x81); // FIN + text frame

    size_t len = message.size();
    if (len < 126) {
        frame.push_back(static_cast<uint8_t>(len));
    } else if (len < 65536) {
        frame.push_back(126);
        frame.push_back((len >> 8) & 0xFF);
        frame.push_back(len & 0xFF);
    } else {
        frame.push_back(127);
        for (int i = 7; i >= 0; i--) {
            frame.push_back((len >> (i * 8)) & 0xFF);
        }
    }

    frame.insert(frame.end(), message.begin(), message.end());

    // Send to all clients and collect dead ones
    std::vector<SOCKET> deadSockets;

    for (SOCKET client : wsClients) {
        // Validate socket before sending
        if (client == INVALID_SOCKET) {
            deadSockets.push_back(client);
            continue;
        }

        // Send with error checking - use MSG_NOSIGNAL on Unix to prevent SIGPIPE
        int flags = 0;
#ifndef _WIN32
        flags = MSG_NOSIGNAL;
#endif
        int result = send(client, reinterpret_cast<const char*>(frame.data()), static_cast<int>(frame.size()), flags);

        if (result == SOCKET_ERROR || result <= 0) {
            // Client disconnected or error
#ifdef _WIN32
            int error = WSAGetLastError();
            LOGI("Client send failed (WSAError: %d), marking for removal", error);
#else
            LOGI("Client send failed (errno: %d), marking for removal", errno);
#endif
            deadSockets.push_back(client);
        }
    }

    // Remove dead clients outside the iteration
    if (!deadSockets.empty()) {
        // Sort and remove duplicates (in case same socket was marked dead multiple times)
        std::sort(deadSockets.begin(), deadSockets.end());
        deadSockets.erase(std::unique(deadSockets.begin(), deadSockets.end()), deadSockets.end());

        for (SOCKET deadSocket : deadSockets) {
            auto it = std::find(wsClients.begin(), wsClients.end(), deadSocket);
            if (it != wsClients.end()) {
                closesocket(*it);
                wsClients.erase(it);
            }
        }
        LOGI("Removed %zu disconnected client(s), %zu clients remain", deadSockets.size(), wsClients.size());
    }
}

// Get the plugin installation directory
std::string GetPluginDirectory() {
#ifdef _WIN32
    HMODULE hm = nullptr;
    if (GetModuleHandleEx(
            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
            GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
            (LPCSTR)"ScoreServerPluginLoad", &hm) == 0)
        return "";

    char path[MAX_PATH];
    if (GetModuleFileNameA(hm, path, MAX_PATH) == 0)
        return "";

    std::string pathStr(path);
    size_t pos = pathStr.find_last_of("\\/");
    if (pos != std::string::npos)
        return pathStr.substr(0, pos);
    return "";
#else
    Dl_info info{};
    if (dladdr((void*)&GetPluginDirectory, &info) == 0 || !info.dli_fname)
        return "";

    char realBuf[PATH_MAX];
    if (!realpath(info.dli_fname, realBuf))
        return "";

    std::string pathStr(realBuf);
    size_t pos = pathStr.find_last_of('/');
    if (pos != std::string::npos)
        return pathStr.substr(0, pos);
    return "";
#endif
}

// Simple JSON value class for parsing
struct JsonValue {
    enum Type { STRING, NUMBER, OBJECT, ARRAY, BOOLEAN, NULL_TYPE };
    Type type;
    std::string strValue;
    int64_t numValue;
    std::map<std::string, JsonValue*> objValue;
    std::vector<JsonValue*> arrayValue;
    bool boolValue;

    JsonValue() : type(NULL_TYPE), numValue(0), boolValue(false) {}

    ~JsonValue() {
        for (auto& p : objValue)
            delete p.second;
        for (auto& v : arrayValue)
            delete v;
    }

    const JsonValue* get(const char* key) const {
        auto it = objValue.find(key);
        return (it != objValue.end()) ? it->second : nullptr;
    }

    const JsonValue* at(size_t index) const {
        return (index < arrayValue.size()) ? arrayValue[index] : nullptr;
    }
};

// Simple JSON parser
class SimpleJsonParser {
private:
    const char* pos;
    const char* end;

    void skipWhitespace() {
        while (pos < end && (*pos == ' ' || *pos == '\t' || *pos == '\n' || *pos == '\r'))
            pos++;
    }

    std::string parseString() {
        if (*pos != '"') return "";
        pos++; // skip opening quote

        std::string result;
        while (pos < end && *pos != '"') {
            if (*pos == '\\' && pos + 1 < end) {
                pos++;
                switch (*pos) {
                    case 'n': result += '\n'; break;
                    case 't': result += '\t'; break;
                    case 'r': result += '\r'; break;
                    case '\\': result += '\\'; break;
                    case '"': result += '"'; break;
                    case 'u': // Unicode escape - simplified handling
                        pos += 4; // skip the 4 hex digits
                        result += '?'; // placeholder
                        break;
                    default: result += *pos; break;
                }
            } else {
                result += *pos;
            }
            pos++;
        }

        if (pos < end) pos++; // skip closing quote
        return result;
    }

    int64_t parseNumber() {
        int64_t result = 0;
        bool negative = false;

        if (*pos == '-') {
            negative = true;
            pos++;
        }

        while (pos < end && *pos >= '0' && *pos <= '9') {
            result = result * 10 + (*pos - '0');
            pos++;
        }

        // Skip decimal part if present (we only need integers for offsets)
        if (pos < end && *pos == '.') {
            pos++;
            while (pos < end && *pos >= '0' && *pos <= '9')
                pos++;
        }

        return negative ? -result : result;
    }

    JsonValue* parseValue();

    JsonValue* parseObject() {
        JsonValue* obj = new JsonValue();
        obj->type = JsonValue::OBJECT;

        pos++; // skip {
        skipWhitespace();

        while (pos < end && *pos != '}') {
            skipWhitespace();
            if (*pos == '}') break;

            if (*pos != '"') {
                delete obj;
                return nullptr;
            }

            std::string key = parseString();
            skipWhitespace();

            if (pos >= end || *pos != ':') {
                delete obj;
                return nullptr;
            }
            pos++; // skip :

            skipWhitespace();
            JsonValue* value = parseValue();
            if (!value) {
                delete obj;
                return nullptr;
            }

            obj->objValue[key] = value;

            skipWhitespace();
            if (pos < end && *pos == ',') {
                pos++;
                skipWhitespace();
            }
        }

        if (pos < end) pos++; // skip }
        return obj;
    }

    JsonValue* parseArray() {
        JsonValue* arr = new JsonValue();
        arr->type = JsonValue::ARRAY;

        pos++; // skip [
        skipWhitespace();

        while (pos < end && *pos != ']') {
            skipWhitespace();
            if (*pos == ']') break;

            JsonValue* value = parseValue();
            if (!value) {
                delete arr;
                return nullptr;
            }

            arr->arrayValue.push_back(value);

            skipWhitespace();
            if (pos < end && *pos == ',') {
                pos++;
                skipWhitespace();
            }
        }

        if (pos < end) pos++; // skip ]
        return arr;
    }

public:
    JsonValue* parse(const std::string& json) {
        pos = json.c_str();
        end = pos + json.length();
        skipWhitespace();
        return parseValue();
    }
};

JsonValue* SimpleJsonParser::parseValue() {
    skipWhitespace();
    if (pos >= end) return nullptr;

    if (*pos == '"') {
        JsonValue* v = new JsonValue();
        v->type = JsonValue::STRING;
        v->strValue = parseString();
        return v;
    }
    else if (*pos == '{') {
        return parseObject();
    }
    else if (*pos == '[') {
        return parseArray();
    }
    else if (*pos == 't' || *pos == 'f') {
        JsonValue* v = new JsonValue();
        v->type = JsonValue::BOOLEAN;
        if (*pos == 't') {
            v->boolValue = true;
            pos += 4; // skip "true"
        } else {
            v->boolValue = false;
            pos += 5; // skip "false"
        }
        return v;
    }
    else if (*pos == 'n') {
        JsonValue* v = new JsonValue();
        v->type = JsonValue::NULL_TYPE;
        pos += 4; // skip "null"
        return v;
    }
    else if (*pos == '-' || (*pos >= '0' && *pos <= '9')) {
        JsonValue* v = new JsonValue();
        v->type = JsonValue::NUMBER;
        v->numValue = parseNumber();
        return v;
    }

    return nullptr;
}

///////////////////////////////////////////////////////////////////////////////
// WebSocket Server

void webSocketServerThread() {
    LOGI("WebSocket server thread starting...");

    // Winsock initialization is handled by PluginLoad/PluginUnload

    wsServerSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (wsServerSocket == INVALID_SOCKET) {
        LOGE("Failed to create WebSocket server socket");
        return;
    }

    // Set socket options for reliability
    int opt = 1;
    setsockopt(wsServerSocket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&opt), sizeof(opt));
#ifndef _WIN32
    // On Linux, also set SO_REUSEPORT to allow immediate rebind
    setsockopt(wsServerSocket, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
#endif
    // Enable TCP keepalive
    setsockopt(wsServerSocket, SOL_SOCKET, SO_KEEPALIVE, reinterpret_cast<const char*>(&opt), sizeof(opt));

    // Set SO_LINGER to 0 for immediate close without TIME_WAIT
    linger lin{};
    lin.l_onoff = 1;
    lin.l_linger = 0;
    setsockopt(wsServerSocket, SOL_SOCKET, SO_LINGER, reinterpret_cast<const char*>(&lin), sizeof(lin));

    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(3131);

    if (bind(wsServerSocket, reinterpret_cast<sockaddr*>(&serverAddr), sizeof(serverAddr)) == SOCKET_ERROR) {
#ifdef _WIN32
        LOGE("Failed to bind WebSocket server to port 3131 (WSAError: %d)", WSAGetLastError());
#else
        LOGE("Failed to bind WebSocket server to port 3131 (errno: %d)", errno);
#endif
        closesocket(wsServerSocket);
        wsServerSocket = INVALID_SOCKET;
        return;
    }

    if (listen(wsServerSocket, 5) == SOCKET_ERROR) {
#ifdef _WIN32
        LOGE("Failed to listen on WebSocket server socket (WSAError: %d)", WSAGetLastError());
#else
        LOGE("Failed to listen on WebSocket server socket (errno: %d)", errno);
#endif
        closesocket(wsServerSocket);
        wsServerSocket = INVALID_SOCKET;
        return;
    }

    LOGI("WebSocket server listening on 0.0.0.0:3131 (all network interfaces)");

    while (wsServerRunning) {
        fd_set readfds;
        FD_ZERO(&readfds);
        FD_SET(wsServerSocket, &readfds);

        timeval timeout{};
        timeout.tv_sec = 0;
        timeout.tv_usec = 100000;  // 100ms - responsive to new connections

        int activity = select(wsServerSocket + 1, &readfds, nullptr, nullptr, &timeout);
        if (activity < 0 || !wsServerRunning) break;
        if (activity == 0) continue;

        if (!wsServerRunning) break;  // Check before accept() to avoid operating on closed socket

        if (FD_ISSET(wsServerSocket, &readfds)) {
            sockaddr_in clientAddr{};
            socklen_t clientLen = sizeof(clientAddr);
            SOCKET clientSocket = accept(wsServerSocket, reinterpret_cast<sockaddr*>(&clientAddr), &clientLen);

            if (clientSocket == INVALID_SOCKET) {
                // Accept failed - log and continue
#ifdef _WIN32
                LOGW("accept() failed (WSAError: %d)", WSAGetLastError());
#else
                LOGW("accept() failed (errno: %d)", errno);
#endif
                continue;
            }

            LOGI("New WebSocket connection from %s", inet_ntoa(clientAddr.sin_addr));

            bool handshakeSuccess = false;

            // Set socket options for client connection
            int opt = 1;
            if (setsockopt(clientSocket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<const char*>(&opt), sizeof(opt)) != 0) {
                LOGW("Failed to set TCP_NODELAY");
            }

            // Set SO_LINGER to 0 for immediate close
            linger clientLin{};
            clientLin.l_onoff = 1;
            clientLin.l_linger = 0;
            if (setsockopt(clientSocket, SOL_SOCKET, SO_LINGER, reinterpret_cast<const char*>(&clientLin), sizeof(clientLin)) != 0) {
                LOGW("Failed to set SO_LINGER");
            }

            // Set receive timeout to avoid hanging
            timeval recvTimeout{};
            recvTimeout.tv_sec = 5;  // 5 second timeout for handshake
            recvTimeout.tv_usec = 0;
            if (setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<const char*>(&recvTimeout), sizeof(recvTimeout)) != 0) {
                LOGW("Failed to set SO_RCVTIMEO");
            }

            // Read HTTP upgrade request (may need multiple recv calls for slow clients)
            char buffer[4096] = {0};
            int totalBytesRead = 0;
            int bytesRead = 0;

            // Read until we have the complete handshake (ends with \r\n\r\n)
            do {
                bytesRead = recv(clientSocket, buffer + totalBytesRead, sizeof(buffer) - totalBytesRead - 1, 0);
                if (bytesRead > 0) {
                    totalBytesRead += bytesRead;
                    buffer[totalBytesRead] = '\0';

                    // Check if we have the complete handshake
                    if (strstr(buffer, "\r\n\r\n") != nullptr) {
                        break;
                    }
                } else {
                    break;  // Error or connection closed
                }
            } while (totalBytesRead < (int)sizeof(buffer) - 1);

            if (totalBytesRead > 0) {
                std::string request(buffer);

                // Extract Sec-WebSocket-Key
                size_t keyPos = request.find("Sec-WebSocket-Key: ");
                if (keyPos != std::string::npos) {
                    keyPos += 19;
                    size_t keyEnd = request.find("\r\n", keyPos);
                    if (keyEnd != std::string::npos) {
                        std::string key = request.substr(keyPos, keyEnd - keyPos);

                        // Generate accept key
                        key += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
                        unsigned char hash[20];
                        sha1(key, hash);
                        std::string acceptKey = base64_encode(hash, 20);

                        // Send WebSocket handshake response
                        std::string response =
                            "HTTP/1.1 101 Switching Protocols\r\n"
                            "Upgrade: websocket\r\n"
                            "Connection: Upgrade\r\n"
                            "Sec-WebSocket-Accept: " + acceptKey + "\r\n\r\n";

                        int sendResult = send(clientSocket, response.c_str(), response.length(), 0);
                        if (sendResult > 0) {
                            // Add client to list
                            size_t clientCount = 0;
                            size_t queuedMessageCount = 0;
                            {
                                std::lock_guard<std::mutex> lock(wsClientsMutex);
                                wsClients.push_back(clientSocket);
                                clientCount = wsClients.size();
                            }

                            LOGI("WebSocket handshake completed, %zu clients connected", clientCount);

                            // Send connection status message so client knows the link is alive
                            {
                                bool gameActive = !currentRomName.empty();
                                int bcastMode = broadcastModeProp_Val;
                                const char* bcastName = (bcastMode == 1) ? "WebSocket" : (bcastMode == 2) ? "UDP" : (bcastMode == 3) ? "Both" : "Unknown";

                                std::stringstream statusMsg;
                                statusMsg << "{\"type\":\"connected\","
                                          << "\"timestamp\":\"" << getTimestamp() << "\","
                                          << "\"server\":\"score-server\","
                                          << "\"version\":\"1.0\","
                                          << "\"broadcastMode\":\"" << bcastName << "\","
                                          << "\"gameActive\":" << (gameActive ? "true" : "false");
                                if (gameActive) {
                                    statusMsg << ",\"rom\":\"" << currentRomName << "\"";
                                }
                                statusMsg << addMachineIdField();
                                statusMsg << "}";

                                sendWebSocketFrame(clientSocket, statusMsg.str());
                            }

                            // Send any queued messages to the new client
                            {
                                std::lock_guard<std::mutex> queueLock(messageQueueMutex);
                                queuedMessageCount = messageQueue.size();
                                if (!messageQueue.empty()) {
                                    LOGI("Sending %zu queued messages to new client", queuedMessageCount);
                                    for (const auto& queuedMessage : messageQueue) {
                                        sendWebSocketFrame(clientSocket, queuedMessage);
                                    }
                                    // Don't clear the queue - let other clients within the 60s window also receive it
                                }
                            }

                            if (queuedMessageCount > 0) {
                                LOGI("Sent %zu queued messages to new client", queuedMessageCount);
                            }

                            handshakeSuccess = true;
                        } else {
                            LOGW("Failed to send WebSocket handshake response (result: %d)", sendResult);
                        }
                    } else {
                        LOGW("WebSocket handshake failed: malformed Sec-WebSocket-Key");
                    }
                } else {
                    LOGW("WebSocket handshake failed: no Sec-WebSocket-Key found");
                }
            } else {
                if (totalBytesRead == 0) {
                    LOGW("Client closed connection before sending handshake");
                } else {
#ifdef _WIN32
                    LOGW("Failed to receive WebSocket handshake (bytes: %d, WSAError: %d)", totalBytesRead, WSAGetLastError());
#else
                    LOGW("Failed to receive WebSocket handshake (bytes: %d, errno: %d)", totalBytesRead, errno);
#endif
                }
            }

            // Close socket if handshake failed
            if (!handshakeSuccess) {
                closesocket(clientSocket);
            }
        }
    }

    // Socket cleanup is handled by ScoreServerPluginUnload()
    LOGI("WebSocket server thread exiting");
}

// Forward declaration
size_t parseStartAddress(const JsonValue* startVal, bool adjustForBase = true);

// Decode BCD (Binary-Coded Decimal) from NVRAM bytes
std::string decodeBCD(const std::vector<uint8_t>& nvram, size_t start, size_t length) {
    if (start + length > nvram.size()) {
        return "ERROR";
    }

    std::stringstream result;

    // Read bytes in reverse order for Bally games (least-significant digit first)
    // For high nibble only mode, read from end to start
    if (nvramHighNibbleOnly) {
        for (int i = length - 1; i >= 0; i--) {
            uint8_t byte = nvram[start + i];
            uint8_t high = (byte >> 4) & 0x0F;
            if (high <= 9) result << (char)('0' + high);
        }
    } else {
        // Standard BCD - read forward, both nibbles
        for (size_t i = 0; i < length; i++) {
            uint8_t byte = nvram[start + i];
            uint8_t high = (byte >> 4) & 0x0F;
            uint8_t low = byte & 0x0F;
            if (high <= 9) result << (char)('0' + high);
            if (low <= 9) result << (char)('0' + low);
        }
    }

    return result.str();
}

// Decode BCD from array of offsets (used by some map files like gnr_300)
// Reads one byte from each offset in the array
std::string decodeBCDFromOffsets(const std::vector<uint8_t>& nvram, const JsonValue* offsetsArray) {
    if (!offsetsArray || offsetsArray->type != JsonValue::ARRAY) {
        return "ERROR";
    }

    std::stringstream result;

    // Read each offset in order
    for (size_t i = 0; i < offsetsArray->arrayValue.size(); i++) {
        const JsonValue* offsetVal = offsetsArray->at(i);
        if (!offsetVal) continue;

        size_t offset = parseStartAddress(offsetVal);
        if (offset >= nvram.size()) continue;

        uint8_t byte = nvram[offset];
        uint8_t high = (byte >> 4) & 0x0F;
        uint8_t low = byte & 0x0F;
        if (high <= 9) result << (char)('0' + high);
        if (low <= 9) result << (char)('0' + low);
    }

    return result.str();
}

// Apply scale factor to a score string
// For example, if score is "1523" and scale is 10, result is "15230"
std::string applyScaleFactor(const std::string& score, int scale) {
    if (scale <= 1 || score.empty() || score == "ERROR" || score == "???") {
        return score;
    }

    // Multiply the score by the scale factor
    // For BCD scores, this is typically done by appending zeros
    // scale=10 means multiply by 10 (append one zero)
    int zerosToAdd = 0;
    int tempScale = scale;
    while (tempScale > 1 && tempScale % 10 == 0) {
        zerosToAdd++;
        tempScale /= 10;
    }

    if (zerosToAdd > 0 && tempScale == 1) {
        // Simple case: scale is a power of 10, just append zeros
        return score + std::string(zerosToAdd, '0');
    } else {
        // Complex case: need to actually multiply
        // Convert to number, multiply, convert back
        try {
            unsigned long long value = std::stoull(score);
            value *= scale;
            return std::to_string(value);
        } catch (...) {
            return score; // Return original if conversion fails
        }
    }
}

// Decode character string from NVRAM bytes with optional character map
std::string decodeChar(const std::vector<uint8_t>& nvram, size_t start, size_t length, const std::string& charMap = "") {
    if (start + length > nvram.size()) {
        return "ERROR";
    }

    std::string result;
    for (size_t i = 0; i < length; i++) {
        uint8_t byte = nvram[start + i];

        if (!charMap.empty()) {
            // Use character map if provided
            if (byte < charMap.length()) {
                result += charMap[byte];
            } else {
                result += '?';
            }
        } else {
            // Fallback to ASCII if no char map
            if (byte >= 32 && byte <= 126) {
                result += (char)byte;
            } else {
                result += '?';
            }
        }
    }

    return result;
}

// Helper function to parse start address from JSON (handles both hex strings and numbers)
// If adjustForBase is true, subtracts nvramBaseAddress to get offset into NVRAM data
size_t parseStartAddress(const JsonValue* startVal, bool adjustForBase) {
    if (!startVal) {
        return 0;
    }

    size_t address = 0;
    if (startVal->type == JsonValue::STRING) {
        // Parse hex string like "0x6A5"
        address = std::stoul(startVal->strValue, nullptr, 16);
    } else if (startVal->type == JsonValue::NUMBER) {
        address = startVal->numValue;
    }

    // Adjust for NVRAM base address to get offset into actual NVRAM data
    // Controller.NVRAM returns only the NVRAM region starting at base address
    // So we always subtract base address for NVRAM region addresses
    if (adjustForBase && address >= nvramBaseAddress) {
        address -= nvramBaseAddress;
    }

    return address;
}

// Decode a value from NVRAM with proper encoding, mask, and offset support
int decodeValue(const std::vector<uint8_t>& nvram, const JsonValue* fieldObj) {
    if (!fieldObj || fieldObj->type != JsonValue::OBJECT) {
        return 0;
    }

    const JsonValue* startVal = fieldObj->get("start");

    // Check if address is in RAM region (below NVRAM base)
    // Controller.NVRAM doesn't include RAM, so return 0 for RAM addresses
    if (startVal) {
        size_t rawAddr = parseStartAddress(startVal, false);  // Get unadjusted address
        if (rawAddr < nvramBaseAddress) {
            // Address is in RAM region, not accessible from NVRAM
            static std::set<size_t> warnedAddrs;
            if (warnedAddrs.find(rawAddr) == warnedAddrs.end()) {
                LOGW("Skipping field at RAM address 0x%zx (NVRAM starts at 0x%zx)", rawAddr, nvramBaseAddress);
                warnedAddrs.insert(rawAddr);
            }
            return 0;
        }
    }

    size_t start = parseStartAddress(startVal);

    if (start >= nvram.size()) {
        return 0;
    }

    // Get encoding (default to "int" if not specified)
    const JsonValue* encodingVal = fieldObj->get("encoding");
    std::string encoding = (encodingVal && encodingVal->type == JsonValue::STRING) ? encodingVal->strValue : "int";

    // Get mask (default to 0xFF if not specified)
    uint32_t mask = 0xFF;
    const JsonValue* maskVal = fieldObj->get("mask");
    if (maskVal) {
        if (maskVal->type == JsonValue::STRING) {
            // Parse hex string like "0x0F"
            mask = std::stoul(maskVal->strValue, nullptr, 16);
        } else if (maskVal->type == JsonValue::NUMBER) {
            mask = maskVal->numValue;
        }
    }

    // Get offset (default to 0 if not specified)
    int offset = 0;
    const JsonValue* offsetVal = fieldObj->get("offset");
    if (offsetVal && offsetVal->type == JsonValue::NUMBER) {
        offset = offsetVal->numValue;
    }

    int value = 0;

    if (encoding == "bcd") {
        // BCD encoding - single byte
        uint8_t byte = nvram[start];
        byte &= mask;
        uint8_t high = (byte >> 4) & 0x0F;
        uint8_t low = byte & 0x0F;
        if (high <= 9 && low <= 9) {
            value = high * 10 + low;
        }
    } else if (encoding == "int") {
        // Integer encoding - single byte
        value = nvram[start] & mask;
    } else if (encoding == "bool") {
        // Boolean encoding
        const JsonValue* invertVal = fieldObj->get("invert");
        bool invert = (invertVal && invertVal->type == JsonValue::BOOLEAN && invertVal->boolValue);
        value = (nvram[start] & mask) ? 1 : 0;
        if (invert) {
            value = !value;
        }
    }

    // Apply offset
    value += offset;

    return value;
}

// Get NVRAM data directly from PinMAME Controller via Scriptable API
bool getNVRAMFromController(std::vector<uint8_t>& nvram) {
    if (!scriptApi) {
        LOGW("ScriptAPI not available");
        return false;
    }

    if (!pinmameController) {
        LOGW("PinMAME Controller not available");
        return false;
    }

    // Get the Controller class definition
    ScriptClassDef* controllerClass = scriptApi->GetClassDef("Controller");
    if (!controllerClass) {
        LOGE("Failed to get Controller class definition");
        return false;
    }

    // Find the NVRAM property member
    int nvramMemberIndex = -1;
    for (unsigned int i = 0; i < controllerClass->nMembers; i++) {
        if (std::string(controllerClass->members[i].name.name) == "NVRAM") {
            nvramMemberIndex = i;
            break;
        }
    }

    if (nvramMemberIndex < 0) {
        LOGE("Failed to find NVRAM property in Controller class");
        return false;
    }

    // Call the NVRAM property getter
    ScriptVariant result;
    controllerClass->members[nvramMemberIndex].Call(pinmameController, nvramMemberIndex, nullptr, &result);

    // Extract byte array from result - ByteArray is a ScriptArray*
    ScriptArray* arr = result.vArray;
    if (!arr) {
        LOGE("NVRAM array is null");
        return false;
    }

    // ScriptArray has lengths[] array where lengths[0] is the size
    // Data follows immediately after the lengths array
    size_t arraySize = arr->lengths[0];

    // The data is stored right after the lengths array (1 dimension = 1 length value)
    uint8_t* dataPtr = reinterpret_cast<uint8_t*>(&arr->lengths[1]);

    // Debug: log NVRAM size (only first time per ROM) and first few bytes
    static std::string lastRomLogged;
    if (lastRomLogged != currentRomName) {
        LOGI("NVRAM size for %s: %zu bytes", currentRomName.c_str(), arraySize);

        // Log first 32 bytes to understand the layout
        std::stringstream hexDump;
        hexDump << "First 32 bytes: ";
        for (size_t i = 0; i < (std::min)(arraySize, (size_t)32); i++) {
            char buf[8];
            snprintf(buf, sizeof(buf), "%02X ", dataPtr[i]);
            hexDump << buf;
        }
        LOGI("%s", hexDump.str().c_str());

        lastRomLogged = currentRomName;
    }

    // Copy bytes from array
    nvram.resize(arraySize);
    memcpy(nvram.data(), dataPtr, arraySize);

    // Release the array
    if (arr->Release) {
        arr->Release(arr);
    }

    return true;
}

// Extract current player scores from game_state
void extractAndLogCurrentScores() {
    if (!pinmameController || !scriptApi) {
        return; // Can't get live NVRAM without Controller
    }

    if (currentMapPath.empty()) {
        return; // No map loaded
    }

    // Get current NVRAM
    std::vector<uint8_t> liveNvram;
    if (!getNVRAMFromController(liveNvram)) {
        return;
    }

    // Read the JSON map file
    std::ifstream file(currentMapPath);
    if (!file.is_open()) {
        return;
    }

    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string jsonContent = buffer.str();
    file.close();

    // Parse JSON
    SimpleJsonParser parser;
    JsonValue* root = parser.parse(jsonContent);
    if (!root || root->type != JsonValue::OBJECT) {
        delete root;
        return;
    }

    // Get game_state section
    const JsonValue* gameState = root->get("game_state");
    if (!gameState || gameState->type != JsonValue::OBJECT) {
        delete root;
        return;
    }

    // Get player count
    const JsonValue* playerCountObj = gameState->get("player_count");
    int playerCount = decodeValue(liveNvram, playerCountObj);

    // Get current player
    const JsonValue* currentPlayerObj = gameState->get("current_player");
    int currentPlayer = decodeValue(liveNvram, currentPlayerObj);

    // Get current ball
    const JsonValue* currentBallObj = gameState->get("current_ball");
    int currentBall = decodeValue(liveNvram, currentBallObj);

    // Get scores array
    const JsonValue* scores = gameState->get("scores");
    if (!scores || scores->type != JsonValue::ARRAY) {
        delete root;
        return;
    }

    // If playerCount is 0 (RAM address not accessible), infer from non-zero scores
    std::vector<std::string> allScores;
    int inferredPlayerCount = 0;

    if (playerCount == 0) {
        // Extract all scores first to count non-zero ones
        for (size_t i = 0; i < scores->arrayValue.size(); i++) {
            const JsonValue* scoreEntry = scores->at(i);
            if (!scoreEntry || scoreEntry->type != JsonValue::OBJECT) {
                allScores.push_back("");
                continue;
            }

            const JsonValue* encodingVal = scoreEntry->get("encoding");
            const JsonValue* offsetsVal = scoreEntry->get("offsets");
            const JsonValue* startVal = scoreEntry->get("start");
            const JsonValue* lengthVal = scoreEntry->get("length");
            const JsonValue* scaleVal = scoreEntry->get("scale");

            std::string score;

            // Check if using offsets array format (e.g., gnr_300)
            if (offsetsVal && offsetsVal->type == JsonValue::ARRAY && encodingVal) {
                if (encodingVal->strValue == "bcd") {
                    score = decodeBCDFromOffsets(liveNvram, offsetsVal);
                } else {
                    score = "???";
                }
            }
            // Traditional start+length format
            else if (startVal && lengthVal && encodingVal) {
                size_t startAddr = parseStartAddress(startVal);
                if (encodingVal->strValue == "bcd") {
                    score = decodeBCD(liveNvram, startAddr, lengthVal->numValue);
                } else if (encodingVal->strValue == "int") {
                    uint64_t value = 0;
                    size_t len = lengthVal->numValue;
                    if (startAddr + len <= liveNvram.size()) {
                        for (size_t j = 0; j < len; j++) {
                            value = (value << 8) | liveNvram[startAddr + j];
                        }
                        score = std::to_string(value);
                    } else {
                        score = "ERROR";
                    }
                } else {
                    score = "???";
                }
            } else {
                // Neither offsets nor start+length found
                allScores.push_back("");
                continue;
            }

            // Apply scale factor if present
            if (scaleVal && scaleVal->type == JsonValue::NUMBER && scaleVal->numValue > 1) {
                score = applyScaleFactor(score, (int)scaleVal->numValue);
            }

            allScores.push_back(score);

            // Count as active player if score is non-zero/non-empty
            if (!score.empty() && score != "0" && score != "ERROR" && score != "???") {
                bool allZeros = true;
                for (char c : score) {
                    if (c != '0') {
                        allZeros = false;
                        break;
                    }
                }
                if (!allZeros) {
                    inferredPlayerCount = i + 1;  // Player count is highest non-zero player index + 1
                }
            }
        }

        playerCount = (inferredPlayerCount > 0) ? inferredPlayerCount : 1;  // At least 1 player
    }

    // Build output
    std::stringstream output;
    output << "=== Current Game Status for " << currentRomName << " ===\n";
    output << "Players: " << playerCount << " | Current Player: " << currentPlayer << " | Ball: " << currentBall << "\n";
    output << "----------------------------------------\n";

    // Extract each player's score (use pre-extracted scores if available)
    if (!allScores.empty()) {
        // Use already extracted scores
        for (size_t i = 0; i < allScores.size() && i < (size_t)playerCount; i++) {
            const JsonValue* scoreEntry = scores->at(i);
            if (!scoreEntry || scoreEntry->type != JsonValue::OBJECT) continue;

            const JsonValue* labelVal = scoreEntry->get("label");
            if (!labelVal) continue;

            std::string playerMarker = (i + 1 == (size_t)currentPlayer) ? " <-- PLAYING" : "";
            output << labelVal->strValue << ": " << std::right << std::setw(15) << allScores[i] << playerMarker << "\n";
        }
    } else {
        // Extract scores normally
        for (size_t i = 0; i < scores->arrayValue.size() && i < (size_t)playerCount; i++) {
        const JsonValue* scoreEntry = scores->at(i);
        if (!scoreEntry || scoreEntry->type != JsonValue::OBJECT) continue;

        const JsonValue* labelVal = scoreEntry->get("label");
        const JsonValue* encodingVal = scoreEntry->get("encoding");
        const JsonValue* offsetsVal = scoreEntry->get("offsets");
        const JsonValue* startVal = scoreEntry->get("start");
        const JsonValue* lengthVal = scoreEntry->get("length");
        const JsonValue* scaleVal = scoreEntry->get("scale");

        if (!labelVal || !encodingVal) continue;

        std::string score;

        // Check if using offsets array format
        if (offsetsVal && offsetsVal->type == JsonValue::ARRAY) {
            if (encodingVal->strValue == "bcd") {
                score = decodeBCDFromOffsets(liveNvram, offsetsVal);
            } else {
                score = "???";
            }
        }
        // Traditional start+length format
        else if (startVal && lengthVal) {
            size_t startAddr = parseStartAddress(startVal);
            if (encodingVal->strValue == "bcd") {
                score = decodeBCD(liveNvram, startAddr, lengthVal->numValue);
            } else if (encodingVal->strValue == "int") {
                uint64_t value = 0;
                size_t len = lengthVal->numValue;
                if (startAddr + len <= liveNvram.size()) {
                    for (size_t j = 0; j < len; j++) {
                        value = (value << 8) | liveNvram[startAddr + j];
                    }
                    score = std::to_string(value);
                } else {
                    score = "ERROR";
                }
            } else {
                score = "???";
            }
        } else {
            continue;
        }

        // Apply scale factor if present
        if (scaleVal && scaleVal->type == JsonValue::NUMBER && scaleVal->numValue > 1) {
            score = applyScaleFactor(score, (int)scaleVal->numValue);
        }

        std::string playerMarker = (i + 1 == (size_t)currentPlayer) ? " <-- PLAYING" : "";
        output << labelVal->strValue << ": " << std::right << std::setw(15) << score << playerMarker << "\n";
        }
    }

    // Just to have the log in the same format as high score logs for easier comparison
    LOGI("Current Scores - %s", output.str().c_str());

    // Broadcast via WebSocket as JSON
    std::stringstream jsonOutput;
    jsonOutput << "{\"type\":\"current_scores\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << currentRomName << "\""
               << addMachineIdField() << ","
               << "\"players\":" << playerCount << ","
               << "\"current_player\":" << currentPlayer << ","
               << "\"current_ball\":" << currentBall << ","
               << "\"scores\":[";

    for (size_t i = 0; i < scores->arrayValue.size() && i < (size_t)playerCount; i++) {
        const JsonValue* scoreEntry = scores->at(i);
        if (!scoreEntry || scoreEntry->type != JsonValue::OBJECT) continue;

        const JsonValue* labelVal = scoreEntry->get("label");
        const JsonValue* encodingVal = scoreEntry->get("encoding");
        const JsonValue* offsetsVal = scoreEntry->get("offsets");
        const JsonValue* startVal = scoreEntry->get("start");
        const JsonValue* lengthVal = scoreEntry->get("length");
        const JsonValue* scaleVal = scoreEntry->get("scale");

        if (!labelVal || !encodingVal) continue;

        std::string score;

        // Check if using offsets array format
        if (offsetsVal && offsetsVal->type == JsonValue::ARRAY) {
            if (encodingVal->strValue == "bcd") {
                score = decodeBCDFromOffsets(liveNvram, offsetsVal);
            } else {
                score = "???";
            }
        }
        // Traditional start+length format
        else if (startVal && lengthVal) {
            size_t startAddr = parseStartAddress(startVal);
            if (encodingVal->strValue == "bcd") {
                score = decodeBCD(liveNvram, startAddr, lengthVal->numValue);
            } else if (encodingVal->strValue == "int") {
                uint64_t value = 0;
                size_t len = lengthVal->numValue;
                if (startAddr + len <= liveNvram.size()) {
                    for (size_t j = 0; j < len; j++) {
                        value = (value << 8) | liveNvram[startAddr + j];
                    }
                    score = std::to_string(value);
                }
            }
        } else {
            continue;
        }

        // Apply scale factor if present
        if (scaleVal && scaleVal->type == JsonValue::NUMBER && scaleVal->numValue > 1) {
            score = applyScaleFactor(score, (int)scaleVal->numValue);
        }

        if (i > 0) jsonOutput << ",";
        jsonOutput << "{\"player\":\"" << labelVal->strValue << "\",\"score\":\"" << score << "\"}";
    }

    jsonOutput << "]}";
    broadcastWebSocket(jsonOutput.str());

    // Clean up JSON data after we're done using it
    delete root;
}

// Extract high scores using the JSON map
bool extractHighScores(const std::string& mapFilePath, const std::vector<uint8_t>& nvram, std::string& output) {
    // Read the JSON map file
    std::ifstream file(mapFilePath);
    if (!file.is_open()) {
        LOGE("Failed to open map file: %s", mapFilePath.c_str());
        return false;
    }

    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string jsonContent = buffer.str();
    file.close();

    // Parse JSON
    SimpleJsonParser parser;
    JsonValue* root = parser.parse(jsonContent);
    if (!root || root->type != JsonValue::OBJECT) {
        LOGE("Failed to parse JSON map file");
        delete root;
        return false;
    }

    // Get high_scores array
    const JsonValue* highScores = root->get("high_scores");
    if (!highScores || highScores->type != JsonValue::ARRAY) {
        LOGE("No high_scores array found in map file");
        delete root;
        return false;
    }

    std::stringstream outStream;
    outStream << "High Scores for " << currentRomName << "\n";
    outStream << "================================================\n\n";

    // Process each high score entry
    for (size_t i = 0; i < highScores->arrayValue.size(); i++) {
        const JsonValue* entry = highScores->at(i);
        if (!entry || entry->type != JsonValue::OBJECT) continue;

        const JsonValue* labelVal = entry->get("label");
        const JsonValue* initialsVal = entry->get("initials");
        const JsonValue* scoreVal = entry->get("score");

        if (!labelVal || !initialsVal || !scoreVal) continue;

        std::string label = labelVal->strValue;

        // Extract initials
        const JsonValue* initStart = initialsVal->get("start");
        const JsonValue* initLength = initialsVal->get("length");
        const JsonValue* initEncoding = initialsVal->get("encoding");

        if (!initStart || !initLength || !initEncoding) continue;

        std::string initials;
        size_t initStartAddr = parseStartAddress(initStart);
        if (initEncoding->strValue == "ch") {
            initials = decodeChar(nvram, initStartAddr, initLength->numValue);
        } else {
            initials = "???";
        }

        // Extract score - support both offsets and start+length formats
        const JsonValue* scoreOffsets = scoreVal->get("offsets");
        const JsonValue* scoreStart = scoreVal->get("start");
        const JsonValue* scoreLength = scoreVal->get("length");
        const JsonValue* scoreEncoding = scoreVal->get("encoding");
        const JsonValue* scoreScale = scoreVal->get("scale");

        std::string score;

        // Check if using offsets array format (e.g., gnr_300)
        if (scoreOffsets && scoreOffsets->type == JsonValue::ARRAY && scoreEncoding) {
            if (scoreEncoding->strValue == "bcd") {
                score = decodeBCDFromOffsets(nvram, scoreOffsets);
            } else {
                score = "???";
            }
        }
        // Traditional start+length format
        else if (scoreStart && scoreLength && scoreEncoding) {
            size_t scoreStartAddr = parseStartAddress(scoreStart);
            if (scoreEncoding->strValue == "bcd") {
                score = decodeBCD(nvram, scoreStartAddr, scoreLength->numValue);
            } else if (scoreEncoding->strValue == "int") {
                // Simple integer decoding (big-endian)
                uint64_t value = 0;
                size_t len = scoreLength->numValue;
                if (scoreStartAddr + len <= nvram.size()) {
                    for (size_t j = 0; j < len; j++) {
                        value = (value << 8) | nvram[scoreStartAddr + j];
                    }
                    score = std::to_string(value);
                } else {
                    score = "ERROR";
                }
            } else {
                score = "???";
            }
        } else {
            continue;  // Skip if neither format is available
        }

        // Apply scale factor if present
        if (scoreScale && scoreScale->type == JsonValue::NUMBER && scoreScale->numValue > 1) {
            score = applyScaleFactor(score, (int)scoreScale->numValue);
        }

        // Format output
        outStream << std::left << std::setw(20) << label << " : "
                  << std::setw(5) << initials << " - "
                  << std::right << std::setw(15) << score << "\n";
    }

    delete root;

    output = outStream.str();
    return true;
}

// Shared function to extract and save high scores
void extractAndSaveHighScores(const char* eventName) {
    LOGI("%s - extracting high scores", eventName);

    if (currentRomName.empty()) {
        LOGW("No ROM name available, skipping high score extraction");
        return;
    }

    // Find the map file for this ROM
    std::string indexPath = nvramMapsPath + "/index.json";
    std::ifstream indexFile(indexPath);
    if (!indexFile.is_open()) {
        LOGE("Failed to open index.json at: %s", indexPath.c_str());
        return;
    }

    std::stringstream buffer;
    buffer << indexFile.rdbuf();
    std::string indexJson = buffer.str();
    indexFile.close();

    // Parse index to find map file
    SimpleJsonParser parser;
    JsonValue* index = parser.parse(indexJson);
    if (!index || index->type != JsonValue::OBJECT) {
        LOGE("Failed to parse index.json");
        delete index;
        return;
    }

    const JsonValue* mapPathVal = index->get(currentRomName.c_str());
    if (!mapPathVal || mapPathVal->type != JsonValue::STRING) {
        LOGW("No map found for ROM: %s", currentRomName.c_str());
        delete index;
        return;
    }

    std::string mapPath = nvramMapsPath + "/" + mapPathVal->strValue;
    delete index;

    LOGI("Using map file: %s", mapPath.c_str());

    // Store map path for current score extraction
    currentMapPath = mapPath;

    // Load platform file to get NVRAM base address
    std::ifstream mapFile(mapPath);
    if (!mapFile.is_open()) {
        LOGE("Failed to open map file to read platform: %s", mapPath.c_str());
        return;
    }

    std::stringstream mapBuffer;
    mapBuffer << mapFile.rdbuf();
    std::string mapJsonContent = mapBuffer.str();
    mapFile.close();

    // Parse JSON map to get platform
    SimpleJsonParser mapParser;
    JsonValue* mapRoot = mapParser.parse(mapJsonContent);
    if (!mapRoot || mapRoot->type != JsonValue::OBJECT) {
        LOGE("Failed to parse JSON map file for platform");
        delete mapRoot;
        return;
    }

    // Extract the platform name from _metadata
    const JsonValue* metadata = mapRoot->get("_metadata");
    if (!metadata || metadata->type != JsonValue::OBJECT) {
        LOGE("Map file missing _metadata section for ROM: %s", currentRomName.c_str());
        delete mapRoot;
        return;
    }

    const JsonValue* platformVal = metadata->get("platform");
    if (!platformVal || platformVal->type != JsonValue::STRING) {
        LOGE("Map file missing platform in _metadata for ROM: %s", currentRomName.c_str());
        delete mapRoot;
        return;
    }

    std::string platform = platformVal->strValue;
    LOGI("Platform for %s: %s", currentRomName.c_str(), platform.c_str());

    // Get character map from _metadata if available (while we have mapRoot)
    std::string charMap;
    const JsonValue* charMapVal = metadata->get("char_map");
    if (charMapVal && charMapVal->type == JsonValue::STRING) {
        charMap = charMapVal->strValue;
    }

    // DON'T delete mapRoot yet - we'll reuse it for high score extraction

    // Load platform file to get NVRAM base address
    std::string platformPath = nvramMapsPath + "/platforms/" + platform + ".json";
    std::ifstream platformFile(platformPath);
    if (!platformFile.is_open()) {
        LOGE("Failed to open platform file: %s", platformPath.c_str());
        return;
    }

    std::stringstream platformBuffer;
    platformBuffer << platformFile.rdbuf();
    std::string platformJsonContent = platformBuffer.str();
    platformFile.close();

    JsonValue* platformRoot = mapParser.parse(platformJsonContent);
    if (!platformRoot || platformRoot->type != JsonValue::OBJECT) {
        LOGE("Failed to parse platform JSON: %s", platformPath.c_str());
        delete platformRoot;
        return;
    }

    // Find NVRAM base address and nibble mode from memory_layout
    nvramBaseAddress = 0;
    nvramHighNibbleOnly = false;
    const JsonValue* memoryLayout = platformRoot->get("memory_layout");
    if (memoryLayout && memoryLayout->type == JsonValue::ARRAY) {
        for (size_t i = 0; i < memoryLayout->arrayValue.size(); i++) {
            const JsonValue* entry = memoryLayout->at(i);
            if (entry && entry->type == JsonValue::OBJECT) {
                const JsonValue* typeVal = entry->get("type");
                if (typeVal && typeVal->type == JsonValue::STRING && typeVal->strValue == "nvram") {
                    const JsonValue* addressVal = entry->get("address");
                    if (addressVal && addressVal->type == JsonValue::STRING) {
                        nvramBaseAddress = parseStartAddress(addressVal, false);  // Don't adjust when reading base address itself
                        LOGI("Found NVRAM base address for %s: 0x%zx (%zu)", platform.c_str(), nvramBaseAddress, nvramBaseAddress);
                    }

                    // Check for nibble mode
                    const JsonValue* nibbleVal = entry->get("nibble");
                    if (nibbleVal && nibbleVal->type == JsonValue::STRING && nibbleVal->strValue == "high") {
                        nvramHighNibbleOnly = true;
                        LOGI("NVRAM uses high nibble only");
                    }
                    break;
                }
            }
        }
    }
    delete platformRoot;

    // Try to get NVRAM from Controller first
    bool gotNVRAM = false;
    if (scriptApi && pinmameController) {
        LOGI("Attempting to get NVRAM from PinMAME Controller");
        gotNVRAM = getNVRAMFromController(nvramData);
        if (gotNVRAM) {
            nvramFromController = true;  // Controller returns flat memory layout
        }
    }

    // Check if we got NVRAM successfully
    if (!gotNVRAM) {
        LOGE("Failed to get NVRAM from PinMAME Controller for ROM: %s", currentRomName.c_str());
        return;
    }

    // Extract high scores - reuse the already parsed mapRoot from above
    // (mapRoot and charMap were already loaded when we read the platform)

    // Get high_scores array
    const JsonValue* highScores = mapRoot->get("high_scores");
    if (!highScores || highScores->type != JsonValue::ARRAY) {
        LOGE("No high_scores array found in map file");
        delete mapRoot;
        return;
    }

    // Build JSON output with structured high scores
    std::stringstream jsonOutput;
    jsonOutput << "{\"type\":\"high_scores\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << currentRomName << "\""
               << addMachineIdField() << ","
               << "\"scores\":[";

    // Also build text output for logging
    std::stringstream textOutput;
    textOutput << "High Scores for " << currentRomName << "\n";
    textOutput << "================================================\n\n";

    bool firstEntry = true;
    for (size_t i = 0; i < highScores->arrayValue.size(); i++) {
        const JsonValue* entry = highScores->at(i);
        if (!entry || entry->type != JsonValue::OBJECT) continue;

        const JsonValue* labelVal = entry->get("label");
        const JsonValue* initialsVal = entry->get("initials");
        const JsonValue* scoreVal = entry->get("score");

        if (!labelVal || !scoreVal) continue;  // initials are optional

        std::string label = labelVal->strValue;

        // Extract initials (optional)
        std::string initials;
        if (initialsVal) {
            const JsonValue* initStart = initialsVal->get("start");
            const JsonValue* initLength = initialsVal->get("length");
            const JsonValue* initEncoding = initialsVal->get("encoding");

            if (initStart && initLength && initEncoding) {
                size_t initStartAddr = parseStartAddress(initStart);
                if (initEncoding->strValue == "ch") {
                    initials = decodeChar(nvramData, initStartAddr, initLength->numValue, charMap);
                } else {
                    initials = "???";
                }
            }
        }

        // Extract score - support both offsets and start+length formats
        const JsonValue* scoreOffsets = scoreVal->get("offsets");
        const JsonValue* scoreStart = scoreVal->get("start");
        const JsonValue* scoreLength = scoreVal->get("length");
        const JsonValue* scoreEncoding = scoreVal->get("encoding");
        const JsonValue* scoreScale = scoreVal->get("scale");

        if (!scoreEncoding) continue;
        if (!scoreOffsets && (!scoreStart || !scoreLength)) continue;  // Need either offsets OR start+length

        std::string score;

        // Check if using offsets array format (e.g., gnr_300)
        if (scoreOffsets && scoreOffsets->type == JsonValue::ARRAY) {
            if (scoreEncoding->strValue == "bcd") {
                score = decodeBCDFromOffsets(nvramData, scoreOffsets);
            } else {
                score = "???";
            }
        }
        // Traditional start+length format
        else if (scoreStart && scoreLength) {
            size_t rawScoreAddr = parseStartAddress(scoreStart, false);
            size_t scoreStartAddr = parseStartAddress(scoreStart);

            // Debug log for first high score entry
            static bool loggedHighScore = false;
            if (!loggedHighScore) {
                LOGI("High score address: raw=0x%zx, adjusted=0x%zx, length=%d, nvramSize=%zu",
                     rawScoreAddr, scoreStartAddr, (int)scoreLength->numValue, nvramData.size());
                loggedHighScore = true;
            }

            if (scoreEncoding->strValue == "bcd") {
                score = decodeBCD(nvramData, scoreStartAddr, scoreLength->numValue);
            } else if (scoreEncoding->strValue == "int") {
                uint64_t value = 0;
                size_t len = scoreLength->numValue;
                if (scoreStartAddr + len <= nvramData.size()) {
                    for (size_t j = 0; j < len; j++) {
                        value = (value << 8) | nvramData[scoreStartAddr + j];
                    }
                    score = std::to_string(value);
                } else {
                    score = "ERROR";
                }
            } else {
                score = "???";
            }
        } else {
            score = "ERROR";  // Neither format available
        }

        // Apply scale factor if present
        if (scoreScale && scoreScale->type == JsonValue::NUMBER && scoreScale->numValue > 1) {
            score = applyScaleFactor(score, (int)scoreScale->numValue);
        }

        // Add to JSON array
        if (!firstEntry) jsonOutput << ",";
        jsonOutput << "{\"label\":\"" << label << "\",\"initials\":\"" << initials << "\",\"score\":\"" << score << "\"}";
        firstEntry = false;

        // Add to text output for logging
        textOutput << std::left << std::setw(20) << label << " : "
                   << std::setw(5) << initials << " - "
                   << std::right << std::setw(15) << score << "\n";
    }

    jsonOutput << "]}";

    delete mapRoot;

    // Log the extracted high scores
    LOGI("Extracted high scores:\n%s", textOutput.str().c_str());

    // Broadcast via WebSocket
    broadcastWebSocket(jsonOutput.str());
}

// Check if game state has changed and broadcast if so
void checkAndBroadcastCurrentScores() {
    if (!pinmameController || !scriptApi) {
        return; // Can't get live NVRAM without Controller
    }

    if (currentMapPath.empty()) {
        return; // No map loaded
    }

    // Get current NVRAM
    std::vector<uint8_t> liveNvram;
    if (!getNVRAMFromController(liveNvram)) {
        return;
    }

    // Read the JSON map file
    std::ifstream file(currentMapPath);
    if (!file.is_open()) {
        return;
    }

    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string jsonContent = buffer.str();
    file.close();

    // Parse JSON
    SimpleJsonParser parser;
    JsonValue* root = parser.parse(jsonContent);
    if (!root || root->type != JsonValue::OBJECT) {
        delete root;
        return;
    }

    // Get game_state section
    const JsonValue* gameState = root->get("game_state");
    if (!gameState || gameState->type != JsonValue::OBJECT) {
        delete root;
        return;
    }

    // Get current game state (use decodeValue to handle encoding/mask/offset)
    const JsonValue* playerCountObj = gameState->get("player_count");
    int playerCount = decodeValue(liveNvram, playerCountObj);

    // Debug: log NVRAM layout once when playerCount is 0
    static bool loggedLayout = false;
    if (!loggedLayout && playerCount == 0 && liveNvram.size() > 0) {
        std::stringstream hexDump;
        hexDump << "NVRAM at addresses 0x00-0x20: ";
        for (size_t i = 0; i < (std::min)(liveNvram.size(), (size_t)32); i++) {
            char buf[8];
            snprintf(buf, sizeof(buf), "%02X ", liveNvram[i]);
            hexDump << buf;
        }
        LOGI("%s", hexDump.str().c_str());
        LOGI("Byte at 0x0C (playerCount addr): 0x%02X", liveNvram.size() > 0x0C ? liveNvram[0x0C] : 0xFF);
        loggedLayout = true;
    }

    const JsonValue* currentPlayerObj = gameState->get("current_player");
    int currentPlayer = decodeValue(liveNvram, currentPlayerObj);

    const JsonValue* currentBallObj = gameState->get("current_ball");
    int currentBall = decodeValue(liveNvram, currentBallObj);

    // Get scores array
    const JsonValue* scores = gameState->get("scores");
    if (!scores || scores->type != JsonValue::ARRAY) {
        delete root;
        return;
    }

    // If playerCount is 0 (RAM address not accessible), default to all available score slots
    if (playerCount == 0 && scores->arrayValue.size() > 0) {
        playerCount = scores->arrayValue.size();
    }

    // Extract current scores
    std::vector<std::string> currentScores;

    for (size_t i = 0; i < scores->arrayValue.size() && i < (size_t)playerCount; i++) {
        const JsonValue* scoreEntry = scores->at(i);
        if (!scoreEntry || scoreEntry->type != JsonValue::OBJECT) continue;

        const JsonValue* encodingVal = scoreEntry->get("encoding");
        const JsonValue* offsetsVal = scoreEntry->get("offsets");
        const JsonValue* startVal = scoreEntry->get("start");
        const JsonValue* lengthVal = scoreEntry->get("length");
        const JsonValue* scaleVal = scoreEntry->get("scale");

        if (!encodingVal) continue;

        std::string score;

        // Check if using offsets array format
        if (offsetsVal && offsetsVal->type == JsonValue::ARRAY) {
            if (encodingVal->strValue == "bcd") {
                score = decodeBCDFromOffsets(liveNvram, offsetsVal);
            } else {
                score = "???";
            }
        }
        // Traditional start+length format
        else if (startVal && lengthVal) {
            size_t startAddr = parseStartAddress(startVal);
            if (encodingVal->strValue == "bcd") {
                score = decodeBCD(liveNvram, startAddr, lengthVal->numValue);
            } else if (encodingVal->strValue == "int") {
                uint64_t value = 0;
                size_t len = lengthVal->numValue;
                if (startAddr + len <= liveNvram.size()) {
                    for (size_t j = 0; j < len; j++) {
                        value = (value << 8) | liveNvram[startAddr + j];
                    }
                    score = std::to_string(value);
                }
            }
        } else {
            continue;
        }

        // Apply scale factor if present
        if (scaleVal && scaleVal->type == JsonValue::NUMBER && scaleVal->numValue > 1) {
            score = applyScaleFactor(score, (int)scaleVal->numValue);
        }

        currentScores.push_back(score);
    }

   // Check for game over condition via NVRAM flag (primary method)
   bool currentGameOver = false;
   const JsonValue* gameOverObj = gameState->get("game_over");
   bool hasNvramGameOverFlag = (gameOverObj != nullptr);
   if (hasNvramGameOverFlag)
   {
      currentGameOver = (decodeValue(liveNvram, gameOverObj) != 0);
   }

   // Helper: check if any score in the list is non-zero
   auto hasNonZeroScore = [](const std::vector<std::string>& scores) -> bool {
      for (const auto& s : scores) {
         if (s.empty() || s == "ERROR" || s == "???") continue;
         for (char c : s) {
            if (c != '0') return true;
         }
      }
      return false;
   };

   // Helper: send game_end event and update state
   auto sendGameEnd = [&](const char* detectionMethod) {
      auto gameDuration = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - gameStartTime);
      std::stringstream scoreLog;
      scoreLog << "Game over detected via " << detectionMethod << ". Final Scores: | ";
      for (size_t i = 0; i < currentScores.size(); ++i)
      {
         scoreLog << "P" << (i + 1) << ": " << currentScores[i] << " | ";
      }
      LOGI("%s", scoreLog.str().c_str());

      gameEndSent = true;
      lastGameEndScores = currentScores;

      // Build scores JSON array from current game scores
      std::stringstream scoresJson;
      scoresJson << "[";
      for (size_t i = 0; i < currentScores.size(); ++i) {
         if (i > 0) scoresJson << ",";
         scoresJson << "{\"player\":\"Player " << (i + 1) << "\",\"score\":\"" << currentScores[i] << "\"}";
      }
      scoresJson << "]";

      // Broadcast game end message via WebSocket (with scores and reason)
      std::stringstream gameEndMsg;
      gameEndMsg << "{\"type\":\"game_end\","
                 << "\"timestamp\":\"" << getTimestamp() << "\","
                 << "\"rom\":\"" << currentRomName << "\""
                 << addMachineIdField() << ","
                 << "\"reason\":\"game_over\","
                 << "\"game_duration\":" << gameDuration.count() << ","
                 << "\"scores\":" << scoresJson.str() << "}";
      broadcastWebSocket(gameEndMsg.str());

      // Extract final high scores
      std::string context = std::string("Game end (") + detectionMethod + ")";
      extractAndSaveHighScores(context.c_str());
   };

   // Skip detection on first check to establish baseline (VPX startup / attract mode)
   if (firstStateCheck)
   {
      previousGameOver = currentGameOver;
      // On startup, if ball is already 0 with leftover scores, this is attract mode.
      // Record current scores as lastGameEndScores so we don't falsely trigger game_end
      // if the state doesn't change.
      if (currentBall == 0 && hasNonZeroScore(currentScores))
      {
         lastGameEndScores = currentScores;
         LOGI("Initial state: Ball=0 with existing scores (Attract Mode) - Recording baseline");
      }
      firstStateCheck = false;
   }
   else if (!gameEndSent)
   {
      // === PRIMARY: NVRAM game_over flag detection (false -> true) ===
      if (hasNvramGameOverFlag && currentGameOver && !previousGameOver)
      {
         sendGameEnd("NVRAM flag");
      }
      // === FALLBACK: Ball-drop detection (ball N>0 -> 0) ===
      // Only fires if the NVRAM flag didn't already trigger game_end above.
      // Detects game over when ball drops to 0, scores are non-zero,
      // and these aren't the same scores from a previous game_end (attract mode).
      else if (currentBall == 0 && previousCurrentBall > 0 && !gameEndSent)
      {
         if (hasNonZeroScore(currentScores) && currentScores != lastGameEndScores)
         {
            sendGameEnd("ball-drop fallback");
         }
         else
         {
            LOGI("Ball dropped to 0 but scores match last game end or are zero (Attract Mode) - Ignoring");
         }
      }
   }

   // === NEW GAME DETECTION: re-arm the game_end trigger ===
   // Detect new game started when ball transitions from 0 to > 0
   if (gameEndSent && currentBall > 0 && previousCurrentBall == 0)
   {
      LOGI("Ball changed from 0 to %d (New Game detected) - Re-arming game end trigger", currentBall);
      gameEndSent = false;
   }
   // Also re-arm via NVRAM flag reset (true -> false) with ball > 0
   else if (gameEndSent && hasNvramGameOverFlag && !currentGameOver && previousGameOver)
   {
      if (currentBall > 0)
      {
         LOGI("Game over flag cleared and Ball > 0 (New Game detected) - Re-arming trigger");
         gameEndSent = false;
      }
      else
      {
         LOGI("Game over flag cleared but Ball is 0 (Attract Mode flickering) - Keeping trigger inactive");
      }
   }
    // Check if anything changed
   bool changed = (playerCount != previousPlayerCount ||
                   currentPlayer != previousCurrentPlayer ||
                   currentBall != previousCurrentBall ||
                   currentScores != previousScores ||
                   currentGameOver != previousGameOver);

    if (changed) {
        // Update previous state
        previousPlayerCount = playerCount;
        previousCurrentPlayer = currentPlayer;
        previousCurrentBall = currentBall;
        previousScores = currentScores;
        previousGameOver = currentGameOver;

        // Log and broadcast the change
        extractAndLogCurrentScores();
    }

    delete root;
}

void onGameStart(const unsigned int eventId, void* userData, void* eventData) {
    // Game starting - get the ROM name
    CtlOnGameStartMsg* msg = static_cast<CtlOnGameStartMsg*>(eventData);
    if (msg && msg->gameId) {
        currentRomName = msg->gameId;
        gameStartTime = std::chrono::steady_clock::now();
        LOGI("Game started: %s", currentRomName.c_str());

        // Broadcast game start message via WebSocket
        std::stringstream gameStartMsg;
        gameStartMsg << "{\"type\":\"game_start\","
                     << "\"timestamp\":\"" << getTimestamp() << "\","
                     << "\"rom\":\"" << currentRomName << "\""
                     << addMachineIdField() << "}";
        broadcastWebSocket(gameStartMsg.str());

        // Clear previous NVRAM data
        nvramData.clear();

        // Get the Controller pointer from PinMAME plugin
        pinmameController = nullptr;
        msgApi->BroadcastMsg(endpointId, getControllerId, &pinmameController);
        if (pinmameController) {
            LOGI("Got Controller pointer from PinMAME plugin");
        } else {
            LOGW("Controller pointer not available from PinMAME plugin");
        }

        // Clear previous state for change detection
        previousScores.clear();
        previousPlayerCount = 0;
        previousCurrentPlayer = 0;
        previousCurrentBall = 0;
        previousGameOver = false;
        gameEndSent = false;
        firstStateCheck = true;
        lastGameEndScores.clear();

        // Extract high scores immediately on game start
        extractAndSaveHighScores("Game start");
    }
}

void onGameEnd(const unsigned int eventId, void* userData, void* eventData) {
    auto gameDuration = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - gameStartTime);
    LOGI("Game ended: %s (duration: %llds)", currentRomName.c_str(), (long long)gameDuration.count());

    // Skip if game lasted less than minimum duration (spurious event on some platforms)
    if (gameDuration < MIN_GAME_DURATION) {
        LOGI("Game duration too short (%llds < %llds), ignoring spurious game_end event",
             (long long)gameDuration.count(), (long long)MIN_GAME_DURATION.count());
        return;
    }

    // Skip if game_end was already sent by NVRAM/ball-drop detection
    if (gameEndSent) {
        LOGI("game_end already sent by NVRAM detection, skipping duplicate broadcast");
        extractAndSaveHighScores("Game end");
        currentMapPath.clear();
        return;
    }

    // Build scores JSON from lastGameEndScores (set by NVRAM/ball-drop detection if it fired first)
    std::stringstream scoresJson;
    scoresJson << "[";
    for (size_t i = 0; i < lastGameEndScores.size(); ++i) {
        if (i > 0) scoresJson << ",";
        scoresJson << "{\"player\":\"Player " << (i + 1) << "\",\"score\":\"" << lastGameEndScores[i] << "\"}";
    }
    scoresJson << "]";

    // Broadcast game end message via WebSocket (with scores and reason)
    std::stringstream gameEndMsg;
    gameEndMsg << "{\"type\":\"game_end\","
               << "\"timestamp\":\"" << getTimestamp() << "\","
               << "\"rom\":\"" << currentRomName << "\""
               << addMachineIdField() << ","
               << "\"reason\":\"game_over\","
               << "\"game_duration\":" << gameDuration.count() << ","
               << "\"scores\":" << scoresJson.str() << "}";
    broadcastWebSocket(gameEndMsg.str());
    gameEndSent = true;

    extractAndSaveHighScores("Game end");

    // Clear map path when game ends
    currentMapPath.clear();
}

void onPrepareFrame(const unsigned int eventId, void* userData, void* eventData) {
    // Check if game state changed and broadcast if so
    checkAndBroadcastCurrentScores();
}

///////////////////////////////////////////////////////////////////////////////
// Scriptable COM object for table scripts

class ScoreServerClass {
public:
    // Reference counting (required by ScriptablePlugin API)
    // Since this is a singleton, we don't actually delete it
    uint32_t AddRef() { return ++refCount; }
    uint32_t Release() { return --refCount; }

    // Set game name (must be called first, usually in Table_Init)
    void SetGameName(const std::string& gameName) {
        std::lock_guard<std::mutex> lock(tableStateMutex);
        tableGameName = gameName;
        LOGI("Table game name set to: %s", gameName.c_str());

        // Send table_loaded message
        std::stringstream tableLoadedMsg;
        tableLoadedMsg << "{\"type\":\"table_loaded\","
                       << "\"timestamp\":\"" << getTimestamp() << "\","
                       << "\"rom\":\"" << tableGameName << "\""
                       << addMachineIdField() << "}";
        broadcastWebSocket(tableLoadedMsg.str());
    }

    // Set game state
    // gameState: 1 = Game Start, 2 = Game Playing, 3 = Game End
    void SetGameState(int playerCount, int currentPlayer, int currentBall, int gameState) {
        {
            std::lock_guard<std::mutex> lock(tableStateMutex);
            tablePlayerCount = playerCount;
            tableCurrentPlayer = currentPlayer;
            tableCurrentBall = currentBall;
        }

        // Handle game state changes - send lifecycle events separately
        if (gameState == 1) {
            // Game Start - send dedicated game_start event
            gameStartTime = std::chrono::steady_clock::now();
            std::stringstream gameStartMsg;
            gameStartMsg << "{\"type\":\"game_start\","
                         << "\"timestamp\":\"" << getTimestamp() << "\","
                         << "\"rom\":\"" << tableGameName << "\""
                         << addMachineIdField() << "}";
            broadcastWebSocket(gameStartMsg.str());
            LOGI("Game start event sent for: %s", tableGameName.c_str());

            // Also broadcast current scores after game start
            broadcastTableScores();
        } else if (gameState == 3) {
            // Game End - send dedicated game_end event (only if not already sent)
            auto gameDuration = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - gameStartTime);
            if (gameDuration < MIN_GAME_DURATION) {
                LOGI("Game duration too short (%llds < %llds), ignoring spurious game_end from SetGameState",
                     (long long)gameDuration.count(), (long long)MIN_GAME_DURATION.count());
            } else if (!gameEndSent) {
                std::stringstream gameEndMsg;
                gameEndMsg << "{\"type\":\"game_end\","
                           << "\"timestamp\":\"" << getTimestamp() << "\","
                           << "\"rom\":\"" << tableGameName << "\""
                           << addMachineIdField() << ","
                           << "\"reason\":\"game_over\","
                           << "\"game_duration\":" << gameDuration.count()
                           << "}";
                broadcastWebSocket(gameEndMsg.str());
                gameEndSent = true;
                LOGI("Game end event sent for: %s", tableGameName.c_str());
            } else {
                LOGI("Game end event already sent for: %s, skipping SetGameState broadcast", tableGameName.c_str());
            }

            // Also broadcast final scores after game end
            broadcastTableScores();
        } else if (gameState == 2) {
            // Game Playing - only broadcast current scores
            broadcastTableScores();
        }
    }

    // Helper to split string by delimiter
    std::vector<std::string> splitString(const std::string& str, const std::string& delimiter) {
        std::vector<std::string> result;
        size_t start = 0;
        size_t end = str.find(delimiter);

        while (end != std::string::npos) {
            result.push_back(str.substr(start, end - start));
            start = end + delimiter.length();
            end = str.find(delimiter, start);
        }
        result.push_back(str.substr(start));
        return result;
    }

    // Set all current scores at once using delimited strings
    // Usage: Server.SetScoresArray Join(players, "|"), Join(scores, "|")
    void SetScoresArray(const std::string& playersStr, const std::string& scoresStr) {
        {
            std::lock_guard<std::mutex> lock(tableStateMutex);
            // Clear existing scores
            tableScores.clear();

            // Split by | delimiter
            auto players = splitString(playersStr, "|");
            auto scores = splitString(scoresStr, "|");

            // Get the minimum count
            size_t count = players.size();
            if (scores.size() < count) count = scores.size();

            // Add all scores
            for (size_t i = 0; i < count; i++) {
                // Try to extract player number from player string (e.g., "Player 1" -> 1)
                int playerNum = static_cast<int>(i + 1);
                tableScores.push_back({playerNum, scores[i], tableCurrentBall});
            }
        }

        // Broadcast updated scores
        broadcastTableScores();
    }

    // Set all high scores at once using delimited strings
    // Usage: Server.SetHighScoresArray Join(labels, "|"), Join(initials, "|"), Join(scores, "|")
    void SetHighScoresArray(const std::string& labelsStr, const std::string& initialsStr, const std::string& scoresStr) {
        try {
            {
                std::lock_guard<std::mutex> lock(tableStateMutex);
                // Clear existing high scores
                tableHighScores.clear();

                // Split by | delimiter
                auto labels = splitString(labelsStr, "|");
                auto initials = splitString(initialsStr, "|");
                auto scores = splitString(scoresStr, "|");

                // Get the minimum count
                size_t count = labels.size();
                if (initials.size() < count) count = initials.size();
                if (scores.size() < count) count = scores.size();

                // Skip if no data
                if (count == 0) {
                    LOGI("SetHighScoresArray: no high scores to set");
                    return;
                }

                // Add all high scores
                for (size_t i = 0; i < count; i++) {
                    tableHighScores.push_back({labels[i], initials[i], scores[i]});
                }
            }

            // Broadcast once (outside the lock to avoid deadlock)
            broadcastTableHighScores();
        } catch (const std::exception& e) {
            LOGE("SetHighScoresArray failed: %s", e.what());
        } catch (...) {
            LOGE("SetHighScoresArray failed with unknown error");
        }
    }

    // Award a badge/achievement
    void AwardBadge(const std::string& player, const std::string& name, const std::string& description) {
        broadcastBadge(player, name, description);  // Just forward the badge event
        LOGI("Badge awarded to %s: %s - %s", player.c_str(), name.c_str(), description.c_str());
    }

    // Clear all table state (call on game end)
    void ClearState() {
        std::lock_guard<std::mutex> lock(tableStateMutex);
        tableScores.clear();
        tableHighScores.clear();
        tablePlayerCount = 0;
        tableCurrentPlayer = 0;
        tableCurrentBall = 0;
    }

private:
    uint32_t refCount = 1;
};

// Singleton instance
static ScoreServerClass scoreServerInstance;

// Register the scriptable class
PSC_CLASS_START(ScoreServerClass)
    PSC_FUNCTION1(ScoreServerClass, void, SetGameName, string)
    PSC_FUNCTION4(ScoreServerClass, void, SetGameState, int, int, int, int)
    PSC_FUNCTION2(ScoreServerClass, void, SetScoresArray, string, string)
    PSC_FUNCTION3(ScoreServerClass, void, SetHighScoresArray, string, string, string)
    PSC_FUNCTION3(ScoreServerClass, void, AwardBadge, string, string, string)
    PSC_FUNCTION0(ScoreServerClass, void, ClearState)
PSC_CLASS_END(ScoreServerClass)

} // namespace ScoreServer

using namespace ScoreServer;

MSGPI_EXPORT void MSGPIAPI ScoreServerPluginLoad(const uint32_t sessionId, const MsgPluginAPI* api)
{
    msgApi = api;
    endpointId = sessionId;

    // Setup logging
    LPISetup(endpointId, msgApi);

    // Get plugin directory and set NVRAM maps path to bundled files
    std::string pluginDir = GetPluginDirectory();
    if (pluginDir.empty()) {
        LOGE("Failed to determine plugin directory!");
        return;
    }

    nvramMapsPath = pluginDir + "/nvram-maps";

    // Verify the maps directory exists
    if (!std::filesystem::exists(nvramMapsPath)) {
        LOGE("NVRAM maps directory not found at: %s", nvramMapsPath.c_str());
        return;
    }

    LOGI("Score Server Plugin loaded");
    LOGI("NVRAM Maps Path: %s", nvramMapsPath.c_str());

    // Register plugin settings
    msgApi->RegisterSetting(endpointId, &machineIdProp);
    msgApi->RegisterSetting(endpointId, &broadcastModeProp);
    msgApi->RegisterSetting(endpointId, &udpHostProp);
    msgApi->RegisterSetting(endpointId, &udpPortProp);

#ifdef _WIN32
    // Initialize Winsock on Windows (must be done before any socket operations)
    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        LOGE("WSAStartup failed");
        return;
    }
#endif

    // Initialize UDP client if UDP mode is enabled
    int broadcastMode = broadcastModeProp_Val;  // 1=WebSocket, 2=UDP, 3=Both
    const char* modeName = (broadcastMode == 1) ? "WebSocket" : (broadcastMode == 2) ? "UDP" : (broadcastMode == 3) ? "Both" : "Unknown";
    LOGI("Broadcast Mode: %s (%d)", modeName, broadcastMode);

    if (broadcastMode == 2 || broadcastMode == 3) {
        const char* udpHost = udpHostProp_Get();
        int udpPort = udpPortProp_Val;

        LOGI("UDP configuration: Host=%s, Port=%d", udpHost ? udpHost : "(null)", udpPort);

        if (udpHost && udpHost[0] != '\0' && udpPort > 0) {
            udpClient = new UdpClientSocket(udpHost, (short)udpPort);
            if (udpClient->isValid()) {
                LOGI("UDP client initialized successfully for endpoint %s:%d", udpHost, udpPort);
            } else {
                LOGE("Failed to initialize UDP client: %s", udpClient->getMessage());
                delete udpClient;
                udpClient = nullptr;
            }
        } else {
            LOGW("UDP mode enabled but UdpHost or UdpPort not configured properly");
        }
    }

    // Get VPX API
    msgApi->BroadcastMsg(endpointId, getVpxApiId = msgApi->GetMsgID(VPXPI_NAMESPACE, VPXPI_MSG_GET_API), &vpxApi);

    // Get Scriptable API
    msgApi->BroadcastMsg(endpointId, getScriptApiId = msgApi->GetMsgID(SCRIPTPI_NAMESPACE, SCRIPTPI_MSG_GET_API), &scriptApi);
    if (scriptApi) {
        LOGI("ScriptablePlugin API obtained successfully");

        // Register the ScoreServerClass scriptable class so table scripts can call it
        RegisterScoreServerClassSCD([&](ScriptClassDef* classDef) {
            // Override the CreateObject to return our singleton instance
            classDef->CreateObject = []() -> void* {
                return &scoreServerInstance;
            };
            scriptApi->RegisterScriptClass(classDef);

            // Register COM object override so CreateObject("VPinball.ScoreServer") works
            scriptApi->SetCOMObjectOverride("VPinball.ScoreServer", classDef);
        });
        scriptApi->SubmitTypeLibrary();

        LOGI("ScoreServerClass registered - tables can now use CreateObject(\"VPinball.ScoreServer\")");
    } else {
        LOGW("ScriptablePlugin API not available - will fall back to disk-based NVRAM reading");
    }

    // Register message ID for getting Controller from PinMAME
    getControllerId = msgApi->GetMsgID("PinMAME", "GetController");

    // Subscribe to controller events
    msgApi->SubscribeMsg(endpointId, onGameStartId = msgApi->GetMsgID(CTLPI_NAMESPACE, CTLPI_EVT_ON_GAME_START), onGameStart, nullptr);
    msgApi->SubscribeMsg(endpointId, onGameEndId = msgApi->GetMsgID(CTLPI_NAMESPACE, CTLPI_EVT_ON_GAME_END), onGameEnd, nullptr);

    // Subscribe to frame prepare event for periodic current score logging
    msgApi->SubscribeMsg(endpointId, onPrepareFrameId = msgApi->GetMsgID(VPXPI_NAMESPACE, VPXPI_EVT_ON_PREPARE_FRAME), onPrepareFrame, nullptr);

    // Start WebSocket server (unless in UDP-only mode)
    if (broadcastMode != 2) {  // Skip WebSocket server in UDP-only mode
        serverStartTime = std::chrono::steady_clock::now();  // Mark server start time for message queue window
        wsServerRunning = true;
        wsServerThread = std::thread(webSocketServerThread);
        LOGI("WebSocket server thread started on port 3131 (message queue active for 60 seconds)");
    } else {
        LOGI("Running in UDP-only mode - WebSocket server not started");
    }
}

MSGPI_EXPORT void MSGPIAPI ScoreServerPluginUnload()
{
    LOGI("Score Server Plugin unloading");

    // Send game_end message if a game was active (with plugin_unload reason)
    if (!currentRomName.empty()) {
        // Build scores JSON from lastGameEndScores (scores from the last finished game, if any)
        std::stringstream scoresJson;
        scoresJson << "[";
        for (size_t i = 0; i < lastGameEndScores.size(); ++i) {
            if (i > 0) scoresJson << ",";
            scoresJson << "{\"player\":\"Player " << (i + 1) << "\",\"score\":\"" << lastGameEndScores[i] << "\"}";
        }
        scoresJson << "]";

        auto gameDuration = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - gameStartTime);
        std::stringstream gameEndMsg;
        gameEndMsg << "{\"type\":\"game_end\","
                   << "\"timestamp\":\"" << getTimestamp() << "\","
                   << "\"rom\":\"" << currentRomName << "\""
                   << addMachineIdField() << ","
                   << "\"reason\":\"plugin_unload\","
                   << "\"game_duration\":" << gameDuration.count() << ","
                   << "\"scores\":" << scoresJson.str() << "}";
        broadcastWebSocket(gameEndMsg.str());

        // Give a brief moment for the message to be sent
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    // Stop WebSocket server
    wsServerRunning = false;

    // Shutdown and close all client connections gracefully
    {
        std::lock_guard<std::mutex> lock(wsClientsMutex);
        for (SOCKET client : wsClients) {
            // Shutdown the connection gracefully before closing
            shutdown(client, SHUT_RDWR);
            closesocket(client);
        }
        wsClients.clear();
    }

    // Close server socket to wake up accept()
    if (wsServerSocket != INVALID_SOCKET) {
        shutdown(wsServerSocket, SHUT_RDWR);
        closesocket(wsServerSocket);
        wsServerSocket = INVALID_SOCKET;
    }

    // Wait for server thread to finish
    if (wsServerThread.joinable()) {
        wsServerThread.join();
    }
    LOGI("WebSocket server thread stopped");

    // Cleanup UDP client
    if (udpClient) {
        delete udpClient;
        udpClient = nullptr;
        LOGI("UDP client closed");
    }

#ifdef _WIN32
    WSACleanup();
#endif

    // Cleanup
    msgApi->UnsubscribeMsg(onGameStartId, onGameStart);
    msgApi->UnsubscribeMsg(onGameEndId, onGameEnd);
    msgApi->UnsubscribeMsg(onPrepareFrameId, onPrepareFrame);
    msgApi->ReleaseMsgID(getVpxApiId);
    msgApi->ReleaseMsgID(getScriptApiId);
    msgApi->ReleaseMsgID(getControllerId);
    msgApi->ReleaseMsgID(onGameStartId);
    msgApi->ReleaseMsgID(onGameEndId);
    msgApi->ReleaseMsgID(onPrepareFrameId);

    // Unregister COM object override
    if (scriptApi) {
        scriptApi->SetCOMObjectOverride("VPinball.ScoreServer", nullptr);
    }

    vpxApi = nullptr;
    scriptApi = nullptr;
    pinmameController = nullptr;
    msgApi = nullptr;
}