High Scores

static bool validGame(high_score_game_t game)

1. Exit this functionreturn (unsigned)game < HIGH_SCORE_GAME_COUNT;

static bool validGame(high_score_game_t game)
{
    return (unsigned)game < HIGH_SCORE_GAME_COUNT;
}

static bool validName(const char *name)

1. Decisionname == NULL
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. Executebool nonSpace = false;
3. FOR loopsize_t i = 0; i <= HIGH_SCORE_NAME_CHARS; ++i

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst char ch = name[i];
      2. Decisionch == '\0'
         True

         1. Exit this functionreturn nonSpace;

         False

         Continue after this decision.

      3. Decisioni == HIGH_SCORE_NAME_CHARS
         True

         1. Exit this functionreturn false;

         False

         Continue after this decision.

      4. Decision(ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') && ch != '_' && ch != ' '
         True

         1. Exit this functionreturn false;

         False

         Continue after this decision.

      5. Decisionch != ' '
         True

         1. ExecutenonSpace = true;

         False

         Continue after this decision.

4. Exit this functionreturn false;

static bool validName(const char *name)
{
    if (name == NULL) return false;
    bool nonSpace = false;
    for (size_t i = 0; i <= HIGH_SCORE_NAME_CHARS; ++i) {
        const char ch = name[i];
        if (ch == '\0') return nonSpace;
        if (i == HIGH_SCORE_NAME_CHARS) return false;
        if ((ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') && ch != '_' && ch != ' ') return false;
        if (ch != ' ') nonSpace = true;
    }
    return false;
}

static bool validTable(const high_score_table_t *table)

Calls into this documentation:

1. Decisiontable == NULL || table->count > HIGH_SCORE_COUNT
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. FOR loopuint32_t i = 0; i < table->count; ++i

   Repeat body while the loop condition permits; then continue below.

   1. 1. Decision!validName(table->entries[i].name) || table->entries[i].score == 0
         True

         1. Exit this functionreturn false;

         False

         Continue after this decision.

      2. Decisioni != 0 && table->entries[i].score > table->entries[i - 1U].score
         True

         1. Exit this functionreturn false;

         False

         Continue after this decision.

3. Exit this functionreturn true;

static bool validTable(const high_score_table_t *table)
{
    if (table == NULL || table->count > HIGH_SCORE_COUNT) return false;
    for (uint32_t i = 0; i < table->count; ++i) {
        if (!validName(table->entries[i].name) || table->entries[i].score == 0) return false;
        if (i != 0 && table->entries[i].score > table->entries[i - 1U].score) return false;
    }
    return true;
}

static uint32_t readWord(const uint8_t *bytes)

1. Exit this functionreturn (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) | ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);

static uint32_t readWord(const uint8_t *bytes)
{
    return (uint32_t)bytes[0] | ((uint32_t)bytes[1] << 8) |
           ((uint32_t)bytes[2] << 16) | ((uint32_t)bytes[3] << 24);
}

static void writeWord(uint8_t *bytes, uint32_t value)

1. FOR loopunsigned i = 0; i < 4; ++i

   Repeat body while the loop condition permits; then continue below.

   1. Executebytes[i] = (uint8_t)(value >> (i * 8U));

static void writeWord(uint8_t *bytes, uint32_t value)
{
    for (unsigned i = 0; i < 4; ++i) bytes[i] = (uint8_t)(value >> (i * 8U));
}

static void encodeRecord(const high_score_table_t *table, uint8_t *record)

Calls into this documentation:

1. Executememset(record, 0, RECORD_BYTES);
2. ExecutewriteWord(record, RECORD_VERSION);
3. ExecutewriteWord(record + 4, table->count);
4. FOR loopuint32_t i = 0; i < table->count; ++i

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeuint8_t *entry = record + 8U + i * ENTRY_BYTES;
      2. Executememcpy(entry, table->entries[i].name, sizeof(table->entries[i].name));
      3. ExecutewriteWord(entry + HIGH_SCORE_NAME_CHARS + 1U, table->entries[i].score);
5. ExecutewriteWord(record + RECORD_CRC_OFFSET, integrity_crc32(record, RECORD_CRC_OFFSET));

static void encodeRecord(const high_score_table_t *table, uint8_t *record)
{
    memset(record, 0, RECORD_BYTES);
    writeWord(record, RECORD_VERSION);
    writeWord(record + 4, table->count);
    for (uint32_t i = 0; i < table->count; ++i) {
        uint8_t *entry = record + 8U + i * ENTRY_BYTES;
        memcpy(entry, table->entries[i].name, sizeof(table->entries[i].name));
        writeWord(entry + HIGH_SCORE_NAME_CHARS + 1U, table->entries[i].score);
    }
    writeWord(record + RECORD_CRC_OFFSET, integrity_crc32(record, RECORD_CRC_OFFSET));
}

static bool decodeRecord(const uint8_t *record, size_t record_size,
                         high_score_table_t *table)

Calls into this documentation:

1. Decisionrecord == NULL || table == NULL
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. Executeconst uint32_t version = readWord(record);
3. Decisionrecord_size == RECORD_BYTES && version == RECORD_VERSION
   True

   1. 1. DecisionreadWord(record + RECORD_CRC_OFFSET) != integrity_crc32(record, RECORD_CRC_OFFSET)
         True

         1. 1. Exit this functionreturn false;

         False

         Continue after this decision.

   False

   1. 1. Exit this functionreturn false;
4. DecisionreadWord(record + 4) > HIGH_SCORE_COUNT
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

5. Executehigh_score_table_t loaded = {0};
6. Executeloaded.count = readWord(record + 4);
7. FOR loopuint32_t i = 0; i < loaded.count; ++i

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst uint8_t *entry = record + 8U + i * ENTRY_BYTES;
      2. Executememcpy(loaded.entries[i].name, entry, sizeof(loaded.entries[i].name));
      3. Executeloaded.entries[i].score = readWord(entry + HIGH_SCORE_NAME_CHARS + 1U);
8. Decision!validTable(&loaded)
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

9. Execute*table = loaded;
10. Exit this functionreturn true;

static bool decodeRecord(const uint8_t *record, size_t record_size,
                         high_score_table_t *table)
{
    if (record == NULL || table == NULL) return false;
    const uint32_t version = readWord(record);
    if (record_size == RECORD_BYTES && version == RECORD_VERSION) {
        if (readWord(record + RECORD_CRC_OFFSET) != integrity_crc32(record, RECORD_CRC_OFFSET)) {
            return false;
        }
    } else {
        return false;
    }
    if (readWord(record + 4) > HIGH_SCORE_COUNT) return false;

    high_score_table_t loaded = {0};
    loaded.count = readWord(record + 4);
    for (uint32_t i = 0; i < loaded.count; ++i) {
        const uint8_t *entry = record + 8U + i * ENTRY_BYTES;
        memcpy(loaded.entries[i].name, entry, sizeof(loaded.entries[i].name));
        loaded.entries[i].score = readWord(entry + HIGH_SCORE_NAME_CHARS + 1U);
    }
    if (!validTable(&loaded)) return false;
    *table = loaded;
    return true;
}

high_score_result_t high_scores_load(high_score_game_t game, high_score_table_t *table)

Calls into this documentation:

1. Decisiontable == NULL
   True

   1. Exit this functionreturn HIGH_SCORES_INVALID;

   False

   Continue after this decision.

2. Execute*table = (high_score_table_t){0};
3. Decision!validGame(game)
   True

   1. Exit this functionreturn HIGH_SCORES_INVALID;

   False

   Continue after this decision.

4. Executeuint8_t record[RECORD_BYTES] = {0};
5. Executebool found = false;
6. Executesize_t record_size = 0;
7. Decision!game_storage_read_sized(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record), &record_size, &found)
   True

   1. 1. Exit this functionreturn HIGH_SCORES_IO_ERROR;

   False

   Continue after this decision.

8. Decision!found
   True

   1. Exit this functionreturn HIGH_SCORES_OK;

   False

   Continue after this decision.

9. Executehigh_score_table_t loaded = {0};
10. Decisionrecord_size == LEGACY_RECORD_BYTES && readWord(record) == 1U
    True

    1. 1. ExecuteESP_LOGW("high_scores", "Replacing unprotected version-one score table for game %u", (unsigned)game);
       2. ExecuteencodeRecord(&loaded, record);
       3. Decision!game_storage_write(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record))
          True

          1. 1. Exit this functionreturn HIGH_SCORES_IO_ERROR;

          False

          Continue after this decision.

       4. Execute*table = loaded;
       5. Exit this functionreturn HIGH_SCORES_OK;

    False

    Continue after this decision.

11. Decision!decodeRecord(record, record_size, &loaded)
    True

    1. Exit this functionreturn HIGH_SCORES_INVALID;

    False

    Continue after this decision.

12. Execute*table = loaded;
13. Exit this functionreturn HIGH_SCORES_OK;

high_score_result_t high_scores_load(high_score_game_t game, high_score_table_t *table)
{
    if (table == NULL) return HIGH_SCORES_INVALID;
    *table = (high_score_table_t){0};
    if (!validGame(game)) return HIGH_SCORES_INVALID;
    uint8_t record[RECORD_BYTES] = {0};
    bool found = false;
    size_t record_size = 0;
    if (!game_storage_read_sized(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record),
                                 &record_size, &found)) {
        return HIGH_SCORES_IO_ERROR;
    }
    if (!found) return HIGH_SCORES_OK;
    high_score_table_t loaded = {0};
    if (record_size == LEGACY_RECORD_BYTES && readWord(record) == 1U) {
        // Version-one tables were not CRC-protected, so discard them rather
        // than treating unverified scores as trusted data.
        ESP_LOGW("high_scores", "Replacing unprotected version-one score table for game %u",
                 (unsigned)game);
        encodeRecord(&loaded, record);
        if (!game_storage_write(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record))) {
            return HIGH_SCORES_IO_ERROR;
        }
        *table = loaded;
        return HIGH_SCORES_OK;
    }
    if (!decodeRecord(record, record_size, &loaded)) return HIGH_SCORES_INVALID;
    *table = loaded;
    return HIGH_SCORES_OK;
}

bool high_scores_qualifies(const high_score_table_t *table, uint32_t score)

Calls into this documentation:

1. Exit this functionreturn validTable(table) && score != 0 && (table->count < HIGH_SCORE_COUNT || score > table->entries[HIGH_SCORE_COUNT - 1U].score);

bool high_scores_qualifies(const high_score_table_t *table, uint32_t score)
{
    return validTable(table) && score != 0 &&
        (table->count < HIGH_SCORE_COUNT || score > table->entries[HIGH_SCORE_COUNT - 1U].score);
}

high_score_result_t high_scores_submit(high_score_game_t game, const char *name, uint32_t score)

Calls into this documentation:

1. Decision!validGame(game) || !validName(name)
   True

   1. Exit this functionreturn HIGH_SCORES_INVALID;

   False

   Continue after this decision.

2. Executehigh_score_table_t table;
3. Executeconst high_score_result_t loaded = high_scores_load(game, &table);
4. Decisionloaded != HIGH_SCORES_OK
   True

   1. Exit this functionreturn loaded;

   False

   Continue after this decision.

5. Decision!high_scores_qualifies(&table, score)
   True

   1. Exit this functionreturn HIGH_SCORES_NOT_QUALIFIED;

   False

   Continue after this decision.

6. Executeuint32_t position = 0;
7. WHILE loopposition < table.count && table.entries[position].score >= score

   Repeat body while the loop condition permits; then continue below.

   1. Execute++position;
8. Decisiontable.count < HIGH_SCORE_COUNT
   True

   1. Execute++table.count;

   False

   Continue after this decision.

9. FOR loopuint32_t i = table.count - 1U; i > position; --i

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executetable.entries[i] = table.entries[i - 1U];
10. Executetable.entries[position] = (high_score_entry_t){0};
11. Executememcpy(table.entries[position].name, name, strlen(name) + 1U);
12. Executetable.entries[position].score = score;
13. Executeuint8_t record[RECORD_BYTES];
14. ExecuteencodeRecord(&table, record);
15. Exit this functionreturn game_storage_write(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record)) ? HIGH_SCORES_OK : HIGH_SCORES_IO_ERROR;

high_score_result_t high_scores_submit(high_score_game_t game, const char *name, uint32_t score)
{
    if (!validGame(game) || !validName(name)) return HIGH_SCORES_INVALID;
    high_score_table_t table;
    const high_score_result_t loaded = high_scores_load(game, &table);
    if (loaded != HIGH_SCORES_OK) return loaded;
    if (!high_scores_qualifies(&table, score)) return HIGH_SCORES_NOT_QUALIFIED;
    uint32_t position = 0;
    while (position < table.count && table.entries[position].score >= score) ++position;
    if (table.count < HIGH_SCORE_COUNT) ++table.count;
    for (uint32_t i = table.count - 1U; i > position; --i) {
        table.entries[i] = table.entries[i - 1U];
    }
    table.entries[position] = (high_score_entry_t){0};
    memcpy(table.entries[position].name, name, strlen(name) + 1U);
    table.entries[position].score = score;
    uint8_t record[RECORD_BYTES];
    encodeRecord(&table, record);
    return game_storage_write(HIGH_SCORES_NAMESPACE, keys[game], record, sizeof(record))
        ? HIGH_SCORES_OK : HIGH_SCORES_IO_ERROR;
}

void drawHighScores(uint16_t *frame, high_score_game_t game,
                    const high_score_table_t *table, high_score_result_t status)

Calls into this documentation:

1. Decisionframe == NULL
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Executeclear(frame, COLOR_BLACK);
3. Executedraw_text_centred(frame, 160, 7, validGame(game) ? titles[game] : "HIGH SCORES", 2, COLOR_CYAN);
4. Executedraw_text_centred(frame, 160, 27, "TOP 5", 1, COLOR_YELLOW);
5. Decisionstatus != HIGH_SCORES_OK || !validGame(game) || !validTable(table)
   True

   1. 1. Executedraw_text_centred(frame, 160, 77, status == HIGH_SCORES_IO_ERROR ? "SCORE STORAGE ERROR" : "SCORE DATA ERROR", 1, COLOR_RED);

   False

   1. 1. Executedraw_text(frame, 30, 43, "NAME", 1, COLOR_CYAN);
      2. Executedraw_text(frame, 272, 43, "SCORE", 1, COLOR_CYAN);
      3. FOR loopuint32_t i = 0; i < HIGH_SCORE_COUNT; ++i

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst int y = 61 + (int)i * 17;
            2. Executechar rank[4];
            3. Executesnprintf(rank, sizeof(rank), "%u.", (unsigned)(i + 1U));
            4. Executedraw_text(frame, 8, y, rank, 1, COLOR_YELLOW);
            5. Executedraw_text(frame, 30, y, i < table->count ? table->entries[i].name : "---", 1, COLOR_WHITE);
            6. Decisioni < table->count
               True

               1. 1. Executechar value[11];
                  2. Executesnprintf(value, sizeof(value), "%u", (unsigned)table->entries[i].score);
                  3. Executeconst int width = (int)strlen(value) * 6 - 1;
                  4. Executedraw_text(frame, 311 - width, y, value, 1, COLOR_WHITE);

               False

               Continue after this decision.

6. Executedraw_text_centred(frame, 160, 155, "A CONTINUE BOOT BACK", 1, COLOR_WHITE);

void drawHighScores(uint16_t *frame, high_score_game_t game,
                    const high_score_table_t *table, high_score_result_t status)
{
    if (frame == NULL) return;
    clear(frame, COLOR_BLACK);
    draw_text_centred(frame, 160, 7, validGame(game) ? titles[game] : "HIGH SCORES", 2, COLOR_CYAN);
    draw_text_centred(frame, 160, 27, "TOP 5", 1, COLOR_YELLOW);
    if (status != HIGH_SCORES_OK || !validGame(game) || !validTable(table)) {
        draw_text_centred(frame, 160, 77,
            status == HIGH_SCORES_IO_ERROR ? "SCORE STORAGE ERROR" : "SCORE DATA ERROR", 1, COLOR_RED);
    } else {
        draw_text(frame, 30, 43, "NAME", 1, COLOR_CYAN);
        draw_text(frame, 272, 43, "SCORE", 1, COLOR_CYAN);
        for (uint32_t i = 0; i < HIGH_SCORE_COUNT; ++i) {
            const int y = 61 + (int)i * 17;
            char rank[4];
            snprintf(rank, sizeof(rank), "%u.", (unsigned)(i + 1U));
            draw_text(frame, 8, y, rank, 1, COLOR_YELLOW);
            draw_text(frame, 30, y, i < table->count ? table->entries[i].name : "---", 1, COLOR_WHITE);
            if (i < table->count) {
                char value[11];
                snprintf(value, sizeof(value), "%u", (unsigned)table->entries[i].score);
                const int width = (int)strlen(value) * 6 - 1;
                draw_text(frame, 311 - width, y, value, 1, COLOR_WHITE);
            }
        }
    }
    draw_text_centred(frame, 160, 155, "A CONTINUE  BOOT BACK", 1, COLOR_WHITE);
}

void cancelHighScoreEntry(void)

Calls into this documentation:

1. ExecutecancelScreenKeyboard();
2. ExecuteentryState = ENTRY_IDLE;
3. ExecuteentryPressed = false;

void cancelHighScoreEntry(void)
{
    cancelScreenKeyboard();
    entryState = ENTRY_IDLE;
    entryPressed = false;
}

void startHighScoreEntry(high_score_game_t game, uint32_t score, uint32_t now_ms)

Calls into this documentation:

1. ExecutecancelHighScoreEntry();
2. ExecuteentryGame = game;
3. ExecuteentryScore = score;
4. ExecuteentryName[0] = '\0';
5. ExecuteentryStatus = high_scores_load(game, &entryTable);
6. ExecuteentryState = ENTRY_TABLE;
7. DecisionentryStatus == HIGH_SCORES_OK && high_scores_qualifies(&entryTable, score)
   True

   1. 1. ExecutestartScreenKeyboard(NULL, 10, KEYBOARD_NAME, "ENTER NAME", now_ms);
      2. ExecuteentryState = ENTRY_NAME;

   False

   1. DecisionentryStatus != HIGH_SCORES_OK
      True

      1. 1. ExecuteESP_LOGE("high_scores", "Cannot load game %u scores: %d", (unsigned)game, (int)entryStatus);

      False

      Continue after this decision.

void startHighScoreEntry(high_score_game_t game, uint32_t score, uint32_t now_ms)
{
    cancelHighScoreEntry();
    entryGame = game;
    entryScore = score;
    entryName[0] = '\0';
    entryStatus = high_scores_load(game, &entryTable);
    entryState = ENTRY_TABLE;
    if (entryStatus == HIGH_SCORES_OK && high_scores_qualifies(&entryTable, score)) {
        startScreenKeyboard(NULL, 10, KEYBOARD_NAME, "ENTER NAME", now_ms);
        entryState = ENTRY_NAME;
    } else if (entryStatus != HIGH_SCORES_OK) {
        ESP_LOGE("high_scores", "Cannot load game %u scores: %d", (unsigned)game, (int)entryStatus);
    }
}

bool highScoreEntryActive(void)

1. Exit this functionreturn entryState != ENTRY_IDLE;

bool highScoreEntryActive(void)
{
    return entryState != ENTRY_IDLE;
}

void highScoreEntryAction(bool a_pressed)

Calls into this documentation:

1. DecisionhighScoreEntryActive()
   True

   1. ExecuteentryPressed = entryPressed || a_pressed;

   False

   Continue after this decision.

void highScoreEntryAction(bool a_pressed)
{
    // Retain the event until the next controller refresh; never use held A.
    if (highScoreEntryActive()) entryPressed = entryPressed || a_pressed;
}

static void saveEntry(void)

Calls into this documentation:

1. ExecuteentryStatus = high_scores_submit(entryGame, entryName, entryScore);
2. DecisionentryStatus == HIGH_SCORES_OK || entryStatus == HIGH_SCORES_NOT_QUALIFIED
   True

   1. 1. ExecuteentryStatus = high_scores_load(entryGame, &entryTable);
      2. ExecuteentryState = ENTRY_TABLE;

   False

   1. 1. ExecuteESP_LOGE("high_scores", "Cannot save game %u score: %d", (unsigned)entryGame, (int)entryStatus);
      2. ExecuteentryState = ENTRY_SAVE_ERROR;

static void saveEntry(void)
{
    entryStatus = high_scores_submit(entryGame, entryName, entryScore);
    if (entryStatus == HIGH_SCORES_OK || entryStatus == HIGH_SCORES_NOT_QUALIFIED) {
        entryStatus = high_scores_load(entryGame, &entryTable);
        entryState = ENTRY_TABLE;
    } else {
        ESP_LOGE("high_scores", "Cannot save game %u score: %d", (unsigned)entryGame, (int)entryStatus);
        entryState = ENTRY_SAVE_ERROR;
    }
}

bool updateHighScoreEntry(int x_offset, int y_offset, bool valid, uint32_t now_ms)

Calls into this documentation:

1. Executeconst bool pressed = entryPressed;
2. ExecuteentryPressed = false;
3. DecisionentryState == ENTRY_NAME
   True

   1. 1. Executeconst KeyboardResult result = updateScreenKeyboard(x_offset, y_offset, valid, pressed, now_ms);
      2. Decisionresult == KEYBOARD_DONE
         True

         1. 1. DecisiongetScreenKeyboardText(entryName, sizeof(entryName))
               True

               1. ExecutesaveEntry();

               False

               Continue after this decision.

         False

         1. Decisionresult == KEYBOARD_CANCELLED
            True

            1. 1. ExecutecancelHighScoreEntry();

            False

            Continue after this decision.

   False

   1. DecisionentryState == ENTRY_SAVE_ERROR && pressed
      True

      1. 1. ExecutesaveEntry();

      False

      1. DecisionentryState == ENTRY_TABLE && pressed
         True

         1. 1. ExecutecancelHighScoreEntry();

         False

         Continue after this decision.

4. Exit this functionreturn entryState == ENTRY_IDLE;

bool updateHighScoreEntry(int x_offset, int y_offset, bool valid, uint32_t now_ms)
{
    const bool pressed = entryPressed;
    entryPressed = false;
    if (entryState == ENTRY_NAME) {
        const KeyboardResult result = updateScreenKeyboard(x_offset, y_offset, valid, pressed, now_ms);
        if (result == KEYBOARD_DONE) {
            if (getScreenKeyboardText(entryName, sizeof(entryName))) saveEntry();
        } else if (result == KEYBOARD_CANCELLED) {
            cancelHighScoreEntry();
        }
    } else if (entryState == ENTRY_SAVE_ERROR && pressed) {
        saveEntry();
    } else if (entryState == ENTRY_TABLE && pressed) {
        cancelHighScoreEntry();
    }
    return entryState == ENTRY_IDLE;
}

void drawHighScoreEntry(uint16_t *frame)

Calls into this documentation:

1. Decisionframe == NULL || entryState == ENTRY_IDLE
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. DecisionentryState == ENTRY_NAME
   True

   1. 1. ExecutedrawScreenKeyboard(frame);

   False

   1. DecisionentryState == ENTRY_SAVE_ERROR
      True

      1. 1. Executeclear(frame, COLOR_BLACK);
         2. Executedraw_text_centred(frame, 160, 35, "SCORE NOT SAVED", 2, COLOR_RED);
         3. Executedraw_text_centred(frame, 160, 69, entryName, 2, COLOR_WHITE);
         4. Executedraw_text_centred(frame, 160, 103, "A RETRY", 2, COLOR_YELLOW);
         5. Executedraw_text_centred(frame, 160, 155, "BOOT BACK CANCELS ENTRY", 1, COLOR_WHITE);

      False

      1. 1. ExecutedrawHighScores(frame, entryGame, &entryTable, entryStatus);

void drawHighScoreEntry(uint16_t *frame)
{
    if (frame == NULL || entryState == ENTRY_IDLE) return;
    if (entryState == ENTRY_NAME) {
        drawScreenKeyboard(frame);
    } else if (entryState == ENTRY_SAVE_ERROR) {
        clear(frame, COLOR_BLACK);
        draw_text_centred(frame, 160, 35, "SCORE NOT SAVED", 2, COLOR_RED);
        draw_text_centred(frame, 160, 69, entryName, 2, COLOR_WHITE);
        draw_text_centred(frame, 160, 103, "A RETRY", 2, COLOR_YELLOW);
        draw_text_centred(frame, 160, 155, "BOOT BACK CANCELS ENTRY", 1, COLOR_WHITE);
    } else {
        drawHighScores(frame, entryGame, &entryTable, entryStatus);
    }
}