Function bodies 456 total

void ledsOff() {
    ledsSetYes(LedState::OFF);
    ledsSetNo(LedState::OFF);
    statusPulse = false;
    neopixel.clear();
    neopixel.show();
}

bool checkResetGesture() {
    unsigned long now = millis();

    // Encoder button is active LOW (pullup)
    if (digitalRead(PIN_ENCODER_SW) == LOW) {
        // Start tracking if not already
        if (encoderBtnHeldSince == 0) {
            encoderBtnHeldSince = now;
            resetMessageShown = false;
            Serial.println("Encoder button held - reset timer started");
        }

        unsigned long heldFor = now - encoderBtnHeldSince;

        // After 3 seconds, show restart message
        if (heldFor >= RESET_HOLD_MS && !resetMessageShown) {
            Serial.println("Showing restart message...");
            displayMessage("HOLD TO CONFIRM", "RESTARTING", "Release to cancel");
            ledsSetYes(LedState::BRIGHT);
            ledsSetNo(LedState::BRIGHT);
            resetMessageShown = true;
        }

        // After 5 seconds total (3 + 2), perform restart
        if (heldFor >= RESET_HOLD_MS + RESET_CONFIRM_MS) {
            Serial.println("Restarting termi

void onDisplayUpdate(const DisplayState& state) {
    currentDisplay = state;
    displayDirty = true;

    // Update button LEDs from display state
    ledsSetFromDisplay(state);

    // Update neopixel from game state
    ledsSetGameState(state.statusLed);
}

void setup() {
    // Initialize serial for debugging
    Serial.begin(115200);
    Serial.println();
    Serial.println("=== Murderhouse ESP32 Terminal v" FIRMWARE_VERSION " ===");

    // Initialize subsystems
    Serial.println("Initializing display...");
    displayInit();
    displayConnectionStatus(ConnectionState::BOOT);

    Serial.println("Initializing LEDs...");
    ledsInit();
    ledsSetStatus(ConnectionState::BOOT);

    // Brief LED test at boot
    Serial.println("Testing button LEDs...");
    ledsSetYes(LedState::BRIGHT);
    ledsSetNo(LedState::BRIGHT);
    delay(500);
    ledsSetYes(LedState::OFF);
    ledsSetNo(LedState::OFF);

    Serial.println("Initializing heart rate monitor...");
    heartrateInit();

    // Brief heartbeat LED test at boot
    Serial.println("Testing heartbeat LED (D3)...");
    digitalWrite(PIN_LED_HEARTBEAT, HIGH);
    delay(500);
    digitalWrite(PIN_LED_HEARTBEAT, LOW);

    Serial.println("Initializing input...");
    inputInit();

    //

void loop() {
    // Update LEDs (for pulse animations)
    ledsUpdate();

    // Update heart rate monitor (sampling + LED control)
    heartrateUpdate();

    // Periodically send heartbeat BPM to server
    if (networkIsConnected()) {
        unsigned long now2 = millis();
        bool active = heartrateIsActive();

        if (active && (now2 - lastHeartbeatSend >= HEARTBEAT_SEND_MS)) {
            networkSendHeartbeat(heartrateGetBPM());
            lastHeartbeatSend = now2;
            lastHeartbeatActive = true;
        } else if (!active && lastHeartbeatActive) {
            // Send one final message with bpm=0 to clear
            networkSendHeartbeat(0);
            lastHeartbeatActive = false;
        }
    }

    // Check for reset gesture (hold both buttons for 3 seconds)
    if (checkResetGesture()) {
        delay(10);
        return;  // Skip normal processing while reset is pending
    }

    // Handle player selection mode (before network is initialized)
    if (!pla

static const char* getRangeLabel(const char* word) {
    char c = word[0];
    if (c <= 'C') return "A-C";
    if (c <= 'H') return "D-H";
    if (c <= 'M') return "I-M";
    if (c <= 'S') return "N-S";
    return "T-Z";
}

static void updateOperatorDisplay() {
    // Show "SENT!" briefly after a slide was dispatched (matches React Operator UX)
    if (operatorSentTime > 0 && millis() - operatorSentTime < 2000) {
        DisplayState state;
        state.line2.text  = "SENT!";
        state.line2.style = DisplayStyle::CRITICAL;
        state.leds.yes    = LedState::OFF;
        state.leds.no     = LedState::OFF;
        state.statusLed   = GameLedState::NONE;
        if (displayCallback != nullptr) displayCallback(state);
        return;
    }

    DisplayState state;
    const OpWord& entry = OP_FLAT[operatorFlatIdx];

    // line1.left = committed sentence, line1.right = alphabetical range label when not ready
    state.line1.left  = operatorBuiltMsg;
    state.line1.right = operatorReady ? "" : getRangeLabel(entry.word);

    // line2 carries preview word and triggers operator rendering mode
    state.line2.text  = operatorReady ? "" : entry.word;
    state.line2.style = DisplayStyle::OPERATOR;

    /

void networkSetPlayerId(uint8_t playerNum) {
    // Use just the number to match the web client format
    snprintf(playerId, sizeof(playerId), "%d", playerNum);
    isOperatorMode = false;
    Serial.print("Player ID set to: ");
    Serial.println(playerId);
}

void networkSetOperatorMode() {
    isOperatorMode = true;
    playerId[0] = '\0';
    Serial.println("Operator mode set");
}

bool networkIsOperatorMode() {
    return isOperatorMode;
}

bool networkIsOperatorReady() {
    return operatorReady;
}

void networkInit() {
    connState = ConnectionState::WIFI_CONNECTING;

    // Start WiFi connection
    WiFi.mode(WIFI_STA);
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);

    Serial.print("Connecting to WiFi: ");
    Serial.println(WIFI_SSID);
    Serial.print("Player ID: ");
    Serial.println(playerId);
}

void networkSetDisplayCallback(DisplayStateCallback callback) {
    displayCallback = callback;
}

ConnectionState networkUpdate() {
    unsigned long now = millis();

    switch (connState) {
        case ConnectionState::BOOT:
            // Should not be here after init
            connState = ConnectionState::WIFI_CONNECTING;
            break;

        case ConnectionState::WIFI_CONNECTING:
            if (WiFi.status() == WL_CONNECTED) {
                Serial.print("WiFi connected. IP: ");
                Serial.println(WiFi.localIP());

                if (serverHost[0] != '\0') {
                    // Already discovered server (reconnecting), go straight to WS
                    webSocket.begin(serverHost, serverPort, WS_PATH);
                    webSocket.onEvent(onWebSocketEvent);
                    webSocket.setReconnectInterval(WS_RECONNECT_MS);
                    connState = ConnectionState::WS_CONNECTING;
                } else {
                    // Need to discover server first
                    udp.begin(DISCOVERY_PORT);
                    lastDiscoveryB

void networkRetryJoin() {
    if (connState == ConnectionState::ERROR || connState == ConnectionState::RECONNECTING) {
        Serial.println("Retrying join...");
        lastError[0] = '\0';  // Clear error message

        if (wsConnected) {
            if (isOperatorMode) {
                sendMessage(ClientMsg::OPERATOR_JOIN);
            } else {
                StaticJsonDocument<128> doc;
                doc["playerId"] = playerId;
                JsonObject payload = doc.as<JsonObject>();
                sendMessage(ClientMsg::JOIN, &payload);
            }
            connState = ConnectionState::JOINING;
        } else {
            connState = ConnectionState::RECONNECTING;
        }
    }
}

bool networkIsConnected() {
    return connState == ConnectionState::CONNECTED && wsConnected && gameJoined;
}

static void sendMessage(const char* type, JsonObject* payload) {
    StaticJsonDocument<256> doc;
    doc["type"] = type;

    if (payload != nullptr) {
        doc["payload"] = *payload;
    } else {
        doc.createNestedObject("payload");
    }

    String json;
    serializeJson(doc, json);

    Serial.print("Sending: ");
    Serial.println(json);

    webSocket.sendTXT(json);
}

void networkSendSelectUp() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::SELECT_UP);
    }
}

void networkSendSelectDown() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::SELECT_DOWN);
    }
}

void networkSendSelectTo(const char* targetId) {
    if (networkIsConnected()) {
        StaticJsonDocument<128> doc;
        doc["targetId"] = targetId;
        JsonObject payload = doc.as<JsonObject>();
        sendMessage(ClientMsg::SELECT_TO, &payload);
    }
}

void networkSendConfirm() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::CONFIRM);
    }
}

void networkSendConfirmWithTarget(const char* targetId) {
    if (networkIsConnected()) {
        StaticJsonDocument<128> doc;
        doc["targetId"] = targetId;
        JsonObject payload = doc.as<JsonObject>();
        sendMessage(ClientMsg::CONFIRM, &payload);
    }
}

void networkSendAbstain() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::ABSTAIN);
    }
}

void networkSendIdleScrollUp() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::IDLE_SCROLL_UP);
    }
}

void networkSendIdleScrollDown() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::IDLE_SCROLL_DOWN);
    }
}

void networkSendUseItem(const char* itemId) {
    if (networkIsConnected()) {
        StaticJsonDocument<128> doc;
        doc["itemId"] = itemId;
        JsonObject payload = doc.as<JsonObject>();
        sendMessage(ClientMsg::USE_ITEM, &payload);
    }
}

void networkSendHeartbeat(uint8_t bpm) {
    if (networkIsConnected()) {
        StaticJsonDocument<128> doc;
        doc["bpm"] = bpm;
        JsonObject payload = doc.as<JsonObject>();
        sendMessage(ClientMsg::HEARTBEAT, &payload);
    }
}

const char* networkGetLastError() {
    return lastError;
}

static void onWebSocketEvent(WStype_t type, uint8_t* payload, size_t length) {
    switch (type) {
        case WStype_DISCONNECTED:
            Serial.println("WebSocket disconnected");
            wsConnected = false;
            gameJoined = false;
            break;

        case WStype_CONNECTED:
            Serial.print("WebSocket connected to: ");
            Serial.println((char*)payload);
            wsConnected = true;
            break;

        case WStype_TEXT: {
            Serial.print("Received: ");
            Serial.println((char*)payload);

            // Parse JSON message
            StaticJsonDocument<4096> doc;
            DeserializationError error = deserializeJson(doc, payload, length);

            if (error) {
                Serial.print("JSON parse error: ");
                Serial.println(error.c_str());
                return;
            }

            const char* msgType = doc["type"];
            JsonObject msgPayload = doc["payload"];

            /

static void parsePlayerState(JsonObject& payload) {
    // Check if display object exists
    if (!payload.containsKey("display")) {
        Serial.println("No display in player state");
        return;
    }

    JsonObject display = payload["display"];

    // Parse line1 (use | "" to handle null values)
    JsonObject line1 = display["line1"];
    currentDisplayState.line1.left = line1["left"] | "";
    currentDisplayState.line1.right = line1["right"] | "";

    // Parse line2
    JsonObject line2 = display["line2"];
    currentDisplayState.line2.text = line2["text"] | "";
    currentDisplayState.line2.style = parseDisplayStyle(line2["style"] | "normal");

    // Parse line3 (supports centered text, left/right, and left/center/right)
    JsonObject line3 = display["line3"];
    currentDisplayState.line3.text = line3["text"] | "";
    currentDisplayState.line3.left = line3["left"] | "";
    currentDisplayState.line3.center = line3["center"] | "";
    currentDisplayState.line3.right 

static void parseOperatorState(JsonObject& payload) {
    bool wasReady = operatorReady;
    operatorReady = payload["ready"] | false;

    // Update built message from server state
    operatorBuiltMsg  = "";
    operatorLastWord  = "";
    operatorWordCount = 0;
    JsonArray words = payload["words"];
    if (!words.isNull()) {
        for (JsonVariant word : words) {
            if (operatorWordCount > 0) operatorBuiltMsg += " ";
            String w = word.as<String>();
            operatorBuiltMsg += w;
            operatorLastWord  = w;   // keep overwriting to capture last
            operatorWordCount++;
        }
    }

    // Reset dial and show "SENT!" when a slide was dispatched (was ready → now empty)
    if (wasReady && operatorWordCount == 0 && !operatorReady) {
        operatorFlatIdx = 0;
        operatorSentTime = millis();
    }

    updateOperatorDisplay();
}

void networkOperatorTick() {
    if (operatorSentTime > 0 && millis() - operatorSentTime >= 2000) {
        operatorSentTime = 0;
        updateOperatorDisplay();
    }
}

void networkOperatorScrollDown() {
    operatorFlatIdx = (operatorFlatIdx + 1) % OP_FLAT_SIZE;
    updateOperatorDisplay();
}

void networkOperatorScrollUp() {
    operatorFlatIdx = (operatorFlatIdx - 1 + OP_FLAT_SIZE) % OP_FLAT_SIZE;
    updateOperatorDisplay();
}

void networkSendOperatorAdd() {
    if (networkIsConnected()) {
        const char* word = OP_FLAT[operatorFlatIdx].word;
        StaticJsonDocument<64> doc;
        doc["word"] = word;
        JsonObject payload = doc.as<JsonObject>();
        sendMessage(ClientMsg::OPERATOR_ADD, &payload);
    }
}

void networkSendOperatorReady() {
    if (networkIsConnected() && operatorWordCount > 0) {
        sendMessage(ClientMsg::OPERATOR_READY);
    }
}

void networkSendOperatorUnready() {
    if (networkIsConnected()) {
        sendMessage(ClientMsg::OPERATOR_UNREADY);
    }
}

void networkSendOperatorClear() {
    operatorFlatIdx = 0;
    updateOperatorDisplay();
    if (networkIsConnected()) {
        sendMessage(ClientMsg::OPERATOR_CLEAR);
    }
}

void networkSendOperatorDelete() {
    // Jump dial to the position of the last committed word before deleting
    if (operatorWordCount > 0) {
        for (int i = 0; i < OP_FLAT_SIZE; i++) {
            if (operatorLastWord == OP_FLAT[i].word) {
                operatorFlatIdx = i;
                break;
            }
        }
    }
    updateOperatorDisplay();
    if (networkIsConnected()) {
        sendMessage(ClientMsg::OPERATOR_DELETE);
    }
}

inline LedState parseLedState(const String& state) {
    if (state == "dim") return LedState::DIM;
    if (state == "bright") return LedState::BRIGHT;
    if (state == "pulse") return LedState::PULSE;
    return LedState::OFF;
}

inline DisplayStyle parseDisplayStyle(const String& style) {
    if (style == "locked") return DisplayStyle::LOCKED;
    if (style == "abstained") return DisplayStyle::ABSTAINED;
    if (style == "waiting") return DisplayStyle::WAITING;
    if (style == "critical") return DisplayStyle::CRITICAL;
    if (style == "operator") return DisplayStyle::OPERATOR;
    return DisplayStyle::NORMAL;
}

inline GameLedState parseGameLedState(const String& state) {
    if (state == "lobby") return GameLedState::LOBBY;
    if (state == "day") return GameLedState::DAY;
    if (state == "night") return GameLedState::NIGHT;
    if (state == "voting") return GameLedState::VOTING;
    if (state == "locked") return GameLedState::LOCKED;
    if (state == "abstained") return GameLedState::ABSTAINED;
    if (state == "dead") return GameLedState::DEAD;
    if (state == "gameOver") return GameLedState::GAME_OVER;
    return GameLedState::NONE;
}

inline IconState parseIconState(const String& state) {
    if (state == "active") return IconState::ACTIVE;
    if (state == "inactive") return IconState::INACTIVE;
    return IconState::EMPTY;
}

    DisplayState() {
        line1.left = "CONNECTING";
        line1.right = "";
        line2.text = "...";
        line2.style = DisplayStyle::NORMAL;
        line3.text = "Please wait";
        leds.yes = LedState::OFF;
        leds.no = LedState::OFF;
        statusLed = GameLedState::NONE;
        idleScrollIndex = 0;
        targetCount = 0;
        selectionIndex = -1;
    }

function getTeamDisplayName(role) {
  if (role?.id === RoleId.JESTER) return str('slides', 'death.teamJester');
  const names = {
    circle: str('slides', 'death.teamCircle'),
    cell: str('slides', 'death.teamCell'),
    neutral: str('slides', 'death.teamNeutral'),
  };
  return names[role?.team] || str('slides', 'death.teamUnknown');
}

function tallyVotes(results) {
  const tally = {};
  for (const [, targetId] of Object.entries(results)) {
    if (targetId === null) continue;
    tally[targetId] = (tally[targetId] || 0) + 1;
  }
  const isEmpty = Object.keys(tally).length === 0;
  const maxVotes = isEmpty ? 0 : Math.max(...Object.values(tally));
  const frontrunners = Object.keys(tally).filter(
    (id) => tally[id] === maxVotes,
  );
  return { tally, maxVotes, frontrunners, isEmpty };
}

function checkRunoff(frontrunners, tally, runoffRound, eventName) {
  if (frontrunners.length <= 1) return null;
  if (runoffRound >= 3) {
    const winnerId =
      frontrunners[Math.floor(Math.random() * frontrunners.length)];
    return { tieBreaker: true, winnerId, tally };
  }
  return {
    success: true,
    runoff: true,
    frontrunners,
    tally,
    message: str('log', 'voteRunoffStarted', { event: eventName, count: frontrunners.length }),
  };
}

function getRunoffTargets(eventId, game) {
  const instance = game.activeEvents.get(eventId);
  return instance?.runoffCandidates?.length > 0
    ? instance.runoffCandidates
    : null;
}

function resolveCustomEventReward(winnerId, config, game, tally, wasTie) {
  const winner = game.getPlayer(winnerId);

  if (!winner) {
    return {
      success: false,
      message: 'Winner not found',
    };
  }

  let message = '';
  let slideSubtitle = winner.name;

  switch (config.rewardType) {
    case 'item':
      game.giveItem(winner.id, config.rewardParam);
      message = str('log', 'customReward', { name: winner.name, reward: config.rewardParam });
      slideSubtitle = `${winner.name} received ${config.rewardParam}`;
      break;

    case 'role':
      const newRole = getRole(config.rewardParam);
      if (newRole) {
        winner.assignRole(newRole);
        message = str('log', 'customRoleChange', { name: winner.name, role: newRole.name });
        slideSubtitle = `${winner.name} is now ${newRole.name}`;
      }
      break;

    case 'resurrection':
      if (!winner.isAlive) {
        game.revivePlayer(winner.id, 'vote');
        message = str('log', 'customReviv

export function getEvent(eventId) {
  return events[eventId] || null;
}