BumbleHive: Hard mode gets its own High Scores table

Paul chose a separate list. Hard runs are saved only under their own record
(HiveHard) in the profile's Arcade file; Normal's stay under Hive exactly as
before, so the "· Hard" marker is gone. High Scores shows a Normal / HARD
switch on BumbleHive's row (Left/Right), and the Top 10 says which table it
is. Clear high scores for BumbleHive clears both. Kids filtering and
per-profile storage are unchanged.

5 new tests (tables never mix, Normal's data untouched, files from before).
853 run, 24 skipped, 0 failed; Node 28 passed; lint unchanged; release APK
unchanged in size.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-08 21:45:28 +00:00
co-authored by Claude Opus 5.5
parent 38986efda9
commit 9ea20b5a2a
8 changed files with 176 additions and 16 deletions
@@ -133,6 +133,7 @@ internal fun OrbitArcade(modifier: Modifier, onPlaying: (Boolean) -> Unit, onExi
writeSetting = { key, on -> update { d -> d.withGame(game.id) { it.copy(settings = it.settings + (key to on)) } } },
writeLevel = { key, value -> update { d -> d.withGame(game.id) { it.copy(level = it.level + (key to value)) } } },
onRunEnd = { end -> update { recordRun(it, game.id, game.scoreKind, end, System.currentTimeMillis()) } },
onRunEndIn = { table, end -> if (table in scoreTables(game.id)) update { recordRun(it, table, game.scoreKind, end, System.currentTimeMillis()) } },
onLeave = { session = SessionState.Exited; playing = null },
difficulty = difficultyFor(data, profile.kind), autoFire = autoFireFor(data), reduceFlashing = reduceFlashingFor(data),
kept = record.kept, writeKept = { values -> update { d -> d.withGame(game.id) { it.copy(kept = it.kept + values) } } })
@@ -193,7 +194,8 @@ internal fun OrbitArcade(modifier: Modifier, onPlaying: (Boolean) -> Unit, onExi
if (page == ArcadePage.Play) chosen?.let { InfoPanel(it, data.game(it.id), household, note.takeIf { _ -> !it.launchable }) }
KeyFooter(when (page) {
ArcadePage.Play -> listOf(Control("◀▶▲▼", "Browse"), Control("OK", "Play"), Control("Menu", "Game settings"), Control("Back", "Orbit TV"))
ArcadePage.HighScores -> listOf(Control("▲▼", "Choose a game"), Control("OK", "See top 10"), Control("Back", "Orbit TV"))
ArcadePage.HighScores -> listOfNotNull(Control("▲▼", "Choose a game"), Control("◀▶", "BumbleHive Normal / Hard").takeIf { visible.any { it.id == ArcadeGames.Hive.id } },
Control("OK", "See top 10"), Control("Back", "Orbit TV"))
else -> listOf(Control("▲▼", "Choose"), Control("OK", "Select"), Control("Back", "Orbit TV"))
}, note = if (profile.kind == ProfileKind.Kids && page == ArcadePage.Play) "Kids profile: only Kids games are shown" else null)
}
@@ -13,6 +13,7 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
@@ -39,6 +40,8 @@ private fun PageTitle(title: String, line: String) {
@Composable
internal fun HighScoresPage(profile: Profile, visible: List<ArcadeGame>, data: ArcadeProfileData, household: Map<String, HouseholdRecord>) {
var topTen by remember { mutableStateOf<ArcadeGame?>(null) }
// BumbleHive's row shows Normal's table or Hard's, switched with ◀▶ (Hard has its own High Scores).
var hiveHard by remember { mutableStateOf(false) }
val now = remember { System.currentTimeMillis() }
PageTitle("HIGH SCORES", "${profile.name}, on this TV")
Row(Modifier.fillMaxSize(), horizontalArrangement = Arrangement.spacedBy(10.dp)) {
@@ -47,7 +50,11 @@ internal fun HighScoresPage(profile: Profile, visible: List<ArcadeGame>, data: A
Text("Game", Modifier.weight(1f), color = ArcadeColours.Muted, fontSize = 12.sp)
listOf("Your best" to 90, "2nd" to 64, "3rd" to 64, "Played" to 64).forEach { (t, w) -> Text(t, Modifier.width(w.dp), color = ArcadeColours.Muted, fontSize = 12.sp, maxLines = 1) }
}
visible.forEach { g -> ScoreRow(g, data.game(g.id), now) { topTen = g } }
visible.forEach { g ->
val table = scoreTable(g, hiveHard)
ScoreRow(g, data.game(table), now, tableLabel = scoreTableLabel(g, hiveHard),
onSide = if (scoreTables(g.id).size > 1) { _ -> hiveHard = !hiveHard } else null) { topTen = g }
}
}
Column(Modifier.width(150.dp).fillMaxHeight().background(ArcadeColours.PanelDeep.copy(alpha = .85f), RoundedCornerShape(10.dp)).border(1.dp, ArcadeColours.Line, RoundedCornerShape(10.dp)).padding(8.dp)) {
Text("🔒 Household Records", color = ArcadeColours.Cyan, fontSize = 13.sp, fontWeight = FontWeight.SemiBold)
@@ -55,21 +62,42 @@ internal fun HighScoresPage(profile: Profile, visible: List<ArcadeGame>, data: A
visible.forEach { g -> Text(householdLine(g, household) ?: "—", Modifier.fillMaxWidth().height(rowHeight).padding(top = 3.dp), color = ArcadeColours.Ink, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, textAlign = androidx.compose.ui.text.style.TextAlign.End) }
}
}
topTen?.let { g -> TopTen(g, data.game(g.id), now, onClose = { topTen = null }) }
topTen?.let { g -> TopTen(g, data.game(scoreTable(g, hiveHard)), now, title = scoreTableTitle(g, hiveHard), onClose = { topTen = null }) }
}
/** Which High Scores table a game's row shows: BumbleHive Hard's when chosen, otherwise the game's own. */
internal fun scoreTable(game: ArcadeGame, hard: Boolean): String = if (hard && scoreTables(game.id).size > 1) HIVE_HARD_SCORES else game.id
/** The switch on BumbleHive's row, so it's always clear which table is showing; null for games with one table. */
internal fun scoreTableLabel(game: ArcadeGame, hard: Boolean): String? = if (scoreTables(game.id).size > 1) (if (hard) "◀ HARD ▶" else "◀ Normal ▶") else null
/** The Top 10's heading. */
internal fun scoreTableTitle(game: ArcadeGame, hard: Boolean): String = game.title.uppercase() + (if (scoreTables(game.id).size > 1 && hard) " HARD" else "") + " · TOP 10"
private val rowHeight = 22.dp
@Composable
private fun ScoreRow(game: ArcadeGame, record: GameRecord, now: Long, onOpen: () -> Unit) {
private fun ScoreRow(game: ArcadeGame, record: GameRecord, now: Long, tableLabel: String? = null, onSide: ((Int) -> Unit)? = null, onOpen: () -> Unit) {
var focused by remember { mutableStateOf(false) }
val corner = RoundedCornerShape(6.dp)
val runs = rankRuns(record.runs, game.scoreKind)
Row(Modifier.fillMaxWidth().height(rowHeight).onFocusChanged { focused = it.isFocused }.background(if (focused) ArcadeColours.FocusFill else ArcadeColours.Panel.copy(alpha = .35f), corner)
.border(if (focused) 2.dp else 0.dp, if (focused) ArcadeColours.Yellow else ArcadeColours.Panel, corner).clickable(onClick = onOpen).padding(horizontal = 8.dp), verticalAlignment = Alignment.CenterVertically) {
.border(if (focused) 2.dp else 0.dp, if (focused) ArcadeColours.Yellow else ArcadeColours.Panel, corner).then(if (onSide != null) Modifier.onPreviewKeyEvent { e ->
val k = e.nativeKeyEvent
val side = when (k.keyCode) { android.view.KeyEvent.KEYCODE_DPAD_LEFT -> -1; android.view.KeyEvent.KEYCODE_DPAD_RIGHT -> 1; else -> 0 }
if (side != 0 && k.action == android.view.KeyEvent.ACTION_DOWN) onSide(side)
side != 0
} else Modifier)
.clickable(onClick = onOpen).padding(horizontal = 8.dp), verticalAlignment = Alignment.CenterVertically) {
Canvas(Modifier.size(16.dp)) { drawMascot(game.mascot, center, size.minDimension * .4f) }
Spacer(Modifier.width(6.dp))
Text(game.title, Modifier.weight(1f), color = ArcadeColours.Ink, fontSize = 13.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
Text(game.title, Modifier.weight(1f, fill = tableLabel == null), color = ArcadeColours.Ink, fontSize = 13.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
if (tableLabel != null) {
val hard = tableLabel.contains("HARD")
Text(tableLabel, Modifier.padding(start = 6.dp).background(if (hard) ArcadeColours.Pink else ArcadeColours.Panel, RoundedCornerShape(8.dp)).padding(horizontal = 6.dp),
color = ArcadeColours.Ink, fontSize = 11.sp, fontWeight = FontWeight.Bold, maxLines = 1)
Spacer(Modifier.weight(1f))
}
val best = bestLine(game, record)
if (best == null) Text(if (game.launchable) "Not played yet" else "Coming soon", Modifier.width(282.dp), color = ArcadeColours.Muted, fontSize = 12.sp)
else {
@@ -83,14 +111,14 @@ private fun ScoreRow(game: ArcadeGame, record: GameRecord, now: Long, onOpen: ()
}
@Composable
private fun TopTen(game: ArcadeGame, record: GameRecord, now: Long, onClose: () -> Unit) {
private fun TopTen(game: ArcadeGame, record: GameRecord, now: Long, title: String = "${game.title.uppercase()} · TOP 10", onClose: () -> Unit) {
val close = remember { FocusRequester() }
LaunchedEffect(Unit) { runCatching { close.requestFocus() } }
BackHandler(onBack = onClose)
ArcadeScrim {
Column(Modifier.width(320.dp).background(ArcadeColours.PanelDeep, RoundedCornerShape(12.dp)).border(1.dp, ArcadeColours.Line, RoundedCornerShape(12.dp)).padding(16.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)) {
Text("${game.title.uppercase()} · TOP 10", color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 22.sp)
Text(title, color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 22.sp)
if (game.scoreKind == ScoreKind.Wins || game.scoreKind == ScoreKind.Solved) Text(formatScore(game.scoreKind, record.count) + " in all", color = ArcadeColours.Yellow, fontSize = 14.sp, fontWeight = FontWeight.SemiBold)
val runs = rankRuns(record.runs, game.scoreKind)
if (runs.isEmpty()) Text("Nothing saved yet.", color = ArcadeColours.Muted, fontSize = 13.sp)
@@ -32,6 +32,8 @@ internal class ArcadePlay(
/** What the game keeps through a level reset ([GameRecord.kept]), and where it writes it. */
val kept: Map<String, String> = emptyMap(),
private val writeKept: (Map<String, String>) -> Unit = {},
/** Saves a run into another of the game's High Scores tables ([scoreTables]): BumbleHive Hard's. */
val onRunEndIn: (String, RunEnd) -> Unit = { _, end -> onRunEnd(end) },
) {
fun setting(key: String) = readSetting(key)
fun setSetting(key: String, on: Boolean) = writeSetting(key, on)
@@ -87,6 +87,15 @@ internal fun recordRun(data: ArcadeProfileData, gameId: String, kind: ScoreKind,
internal fun markPlayed(data: ArcadeProfileData, gameId: String, nowMs: Long): ArcadeProfileData =
data.withGame(gameId) { it.copy(lastPlayedMs = nowMs) }.copy(recent = (listOf(gameId) + data.recent.filter { it != gameId }).take(6))
/**
* BumbleHive Hard's own High Scores table (Paul, 8 November 2026): its runs are kept under this record id, apart from
* Normal's (the game's own id, "Hive"), so the two never mix. It isn't a game of its own: it has no card or settings.
*/
internal const val HIVE_HARD_SCORES = "HiveHard"
/** The High Scores tables a game keeps: BumbleHive has Normal's and Hard's; every other game has one. */
internal fun scoreTables(gameId: String): List<String> = if (gameId == "Hive") listOf("Hive", HIVE_HARD_SCORES) else listOf(gameId)
/** The four things the Reset screen can do, each confirmed on its own. */
internal enum class ResetAction(val title: String) {
RestartLevel("Restart level"), ResetLevelProgress("Reset level progress"), ClearHighScores("Clear high scores"), ResetSettings("Reset settings")
@@ -96,7 +105,8 @@ internal enum class ResetAction(val title: String) {
internal fun applyReset(data: ArcadeProfileData, gameId: String, action: ResetAction, nowMs: Long): ArcadeProfileData = when (action) {
ResetAction.RestartLevel -> data
ResetAction.ResetLevelProgress -> data.withGame(gameId) { it.copy(level = emptyMap(), unlocks = emptySet(), levelsResetMs = nowMs) }
ResetAction.ClearHighScores -> data.withGame(gameId) { it.copy(runs = emptyList(), count = 0, scoresResetMs = nowMs) }
// Clearing BumbleHive's high scores clears both its tables, Normal and Hard.
ResetAction.ClearHighScores -> scoreTables(gameId).fold(data) { d, id -> d.withGame(id) { it.copy(runs = emptyList(), count = 0, scoresResetMs = nowMs) } }
ResetAction.ResetSettings -> data.withGame(gameId) { it.copy(settings = emptyMap(), howToEveryTime = false, settingsResetMs = nowMs) }
}
@@ -43,6 +43,14 @@ import tv.orbit.classic.arcade.rememberRun
import java.io.File
import java.util.concurrent.atomic.AtomicBoolean
/**
* Where a finished BumbleHive run is saved: Normal's into the game's own High Scores (as before), Hard's only into
* [tv.orbit.classic.arcade.HIVE_HARD_SCORES].
*/
internal class HiveRunRouter(private val normal: (RunEnd) -> Unit, private val table: (String, RunEnd) -> Unit) {
fun report(mode: HiveMode, end: RunEnd) { if (mode == HiveMode.Hard) table(tv.orbit.classic.arcade.HIVE_HARD_SCORES, end) else normal(end) }
}
/** game.js ran at the screen's frame rate; the port runs its rules on a fixed 60 Hz step, at most five steps a frame. */
internal class HiveClock {
private var acc = 0.0
@@ -115,8 +123,9 @@ internal fun BumbleHiveScreen(play: ArcadePlay) {
var liveLevel by remember { mutableIntStateOf(0) }
var liveScore by remember { mutableIntStateOf(0) }
var liveMode by remember { mutableStateOf(HiveMode.Normal) }
fun detail(level: Int, mode: HiveMode) = if (mode == HiveMode.Hard) "Level $level · Hard" else "Level $level"
val run = rememberRun(play.onRunEnd) { RunEnd(liveScore, finished = false, detail = detail(liveLevel, liveMode)) }
// Each mode's runs go to its own High Scores table: Normal's as before, Hard's apart (never mixed).
val router = remember { HiveRunRouter({ latestPlay.onRunEnd(it) }, { table, end -> latestPlay.onRunEndIn(table, end) }) }
val run = rememberRun({ end -> router.report(liveMode, end) }) { RunEnd(liveScore, finished = false, detail = "Level $liveLevel") }
val tones = remember { arrayOfNulls<String>(Sfx.COUNT) }
val save = remember { readHiveSave(play.level, play.kept, play::setting) }
val saver = remember { HiveSaver { latestPlay }.also { it.prime(save) } }
@@ -126,7 +135,7 @@ internal fun BumbleHiveScreen(play: ArcadePlay) {
override fun sound(id: Int) { val f = tones[id] ?: return; latestPlay.audio.cueFile(f, 1f, save.sound) }
override fun persist() = saver.write(save)
override fun runStart(level: Int) { liveLevel = level; liveScore = 0; liveMode = simRef[0]?.mode ?: HiveMode.Normal; run.begin() }
override fun runEnd(level: Int, score: Int, finished: Boolean) { liveScore = score; run.end(RunEnd(score, finished, detail(level, simRef[0]?.mode ?: HiveMode.Normal))) }
override fun runEnd(level: Int, score: Int, finished: Boolean) { liveScore = score; run.end(RunEnd(score, finished, "Level $level")) }
override fun leave() = latestPlay.onLeave()
}
}
@@ -0,0 +1,89 @@
package tv.orbit.classic.arcade.hive
import org.json.JSONObject
import org.junit.Assert.*
import org.junit.Test
import tv.orbit.classic.arcade.ArcadeGames
import tv.orbit.classic.arcade.ArcadeProfileData
import tv.orbit.classic.arcade.ArcadeRun
import tv.orbit.classic.arcade.GameRecord
import tv.orbit.classic.arcade.HIVE_HARD_SCORES
import tv.orbit.classic.arcade.ResetAction
import tv.orbit.classic.arcade.RunEnd
import tv.orbit.classic.arcade.ScoreKind
import tv.orbit.classic.arcade.applyReset
import tv.orbit.classic.arcade.decodeArcade
import tv.orbit.classic.arcade.encodeArcade
import tv.orbit.classic.arcade.recordRun
import tv.orbit.classic.arcade.scoreTable
import tv.orbit.classic.arcade.scoreTableLabel
import tv.orbit.classic.arcade.scoreTableTitle
import tv.orbit.classic.arcade.scoreTables
/** BumbleHive Hard has its own High Scores table (Paul, 8 November 2026); Normal's stays exactly as it was. */
class HiveScoresTest {
/** A profile's file as it is today: Normal BumbleHive runs, levels and settings, and another game. */
private val existing = ArcadeProfileData("p2abc9")
.withGame("Hive") { GameRecord(runs = listOf(ArcadeRun(2400, 1_000L, "Level 12"), ArcadeRun(1900, 2_000L, "Level 11")), level = mapOf("normal" to "{\"unlocked\":12}"),
settings = mapOf("sound" to true), firstRunSeen = true, lastPlayedMs = 2_000L) }
.withGame("Snake") { GameRecord(runs = listOf(ArcadeRun(140, 3_000L))) }
@Test fun eachModeReportsToItsOwnTableOnly() {
val normal = ArrayList<RunEnd>(); val tables = ArrayList<Pair<String, RunEnd>>()
val router = HiveRunRouter({ normal += it }, { t, e -> tables += t to e })
router.report(HiveMode.Normal, RunEnd(500, true, "Level 3"))
router.report(HiveMode.Hard, RunEnd(800, true, "Level 2"))
assertEquals(listOf(RunEnd(500, true, "Level 3")), normal)
assertEquals(listOf(HIVE_HARD_SCORES to RunEnd(800, true, "Level 2")), tables)
}
@Test fun hardRunsNeverReachNormalsTableAndNormalsDataIsUntouched() {
val before = existing.game("Hive")
val beforeFile = JSONObject(encodeArcade(existing)).getJSONObject("games").getJSONObject("Hive").toString()
var d = existing
for (i in 1..12) d = recordRun(d, HIVE_HARD_SCORES, ScoreKind.Points, RunEnd(9000 + i, true, "Level $i"), 10_000L + i)
// Normal's record is the same object's worth, field for field, and the same in the file.
assertEquals(before, d.game("Hive"))
val back = decodeArcade(encodeArcade(d), "p2abc9")!!
assertEquals(beforeFile, JSONObject(encodeArcade(back)).getJSONObject("games").getJSONObject("Hive").toString())
assertEquals(listOf(2400, 1900), back.game("Hive").runs.map { it.score })
// Hard's table has its own top 10, with no Normal run in it, and no "· Hard" marker needed.
val hard = back.game(HIVE_HARD_SCORES).runs
assertEquals(10, hard.size)
assertTrue(hard.all { it.score > 9000 && it.detail?.contains("Hard") == false })
// And Normal runs never reach Hard's.
val n = recordRun(back, "Hive", ScoreKind.Points, RunEnd(3000, true, "Level 13"), 99_999L)
assertEquals(back.game(HIVE_HARD_SCORES), n.game(HIVE_HARD_SCORES))
assertEquals(3000, n.game("Hive").runs.first().score)
}
@Test fun aFileFromBeforeHasAnEmptyHardTable() {
val old = decodeArcade(encodeArcade(existing), "p2abc9")!!
assertTrue(old.game(HIVE_HARD_SCORES).runs.isEmpty())
assertEquals(existing.game("Hive"), old.game("Hive"))
}
@Test fun theHighScoresRowSwitchesTablesAndSaysWhichIsShowing() {
val hive = ArcadeGames.Hive
assertEquals(listOf("Hive", HIVE_HARD_SCORES), scoreTables("Hive"))
assertEquals("Hive", scoreTable(hive, hard = false)); assertEquals(HIVE_HARD_SCORES, scoreTable(hive, hard = true))
assertEquals("◀ Normal ▶", scoreTableLabel(hive, false)); assertEquals("◀ HARD ▶", scoreTableLabel(hive, true))
assertEquals("BUMBLEHIVE HARD · TOP 10", scoreTableTitle(hive, true)); assertEquals("BUMBLEHIVE · TOP 10", scoreTableTitle(hive, false))
// Every other game has one table and no switch.
for (g in ArcadeGames.all.filter { it.id != "Hive" }) {
assertEquals(listOf(g.id), scoreTables(g.id)); assertEquals(g.id, scoreTable(g, true)); assertNull(scoreTableLabel(g, true))
}
// Hard's table is not a game: no card, nothing for Kids filtering to show or hide on its own.
assertNull(ArcadeGames.byId(HIVE_HARD_SCORES))
}
@Test fun clearingBumbleHiveScoresClearsBothTablesAndOnlyThem() {
val d = recordRun(existing, HIVE_HARD_SCORES, ScoreKind.Points, RunEnd(700, true, "Level 1"), 5L)
val cleared = applyReset(d, "Hive", ResetAction.ClearHighScores, 6L)
assertTrue(cleared.game("Hive").runs.isEmpty()); assertTrue(cleared.game(HIVE_HARD_SCORES).runs.isEmpty())
assertEquals(existing.game("Hive").level, cleared.game("Hive").level)
assertEquals(d.game("Snake"), cleared.game("Snake"))
val snake = applyReset(d, "Snake", ResetAction.ClearHighScores, 6L)
assertEquals(d.game("Hive"), snake.game("Hive")); assertEquals(d.game(HIVE_HARD_SCORES), snake.game(HIVE_HARD_SCORES))
}
}
+12 -1
View File
@@ -5,7 +5,18 @@ worktree `/home/pauljd/Documents/OrbitTV/orbit-arcade`. Version unchanged (0.110
a release. Nothing pushed, merged or installed; no TV or adb used; `orbit-tv` and `orbit-tv-release` left alone. What it
is: `docs/bumblehive-native.md`.
## Checks
## Update: Hard's own High Scores (8 November 2026, second commit)
Paul chose a separate High Scores table for Hard. Same Gradle run afterwards: **853 run, 24 skipped, 0 failed** (5 new in
`HiveScoresTest`), Node 28 passed, lint 0 errors and 85 warnings (unchanged, no new kinds), release APK 47,793,763 bytes
(unchanged to the byte), debug +82 bytes.
`HiveScoresTest`: each mode reports only to its own table; a dozen Hard runs leave Normal's record and its JSON in the file
identical, and Normal runs leave Hard's alone; a file from before reads with an empty Hard table; the row's switch, label and
Top 10 title (every other game has one table and no switch, and `HiveHard` is not a game); Clear high scores clears both
BumbleHive tables and nothing else.
## Checks (first commit)
One Gradle run (`assembleDebug assembleRelease testDebugUnitTest lintDebug`, orbit-tv's `.tooling`), against `760c957`
built the same way in a scratch worktree.
+12 -3
View File
@@ -13,7 +13,7 @@ Compose Canvas like the other Arcade games, replacing the WebView, and playing e
the old localStorage, the Barlow font is read from it, and keeping it makes a rollback to the WebView build safe.
- Shared Arcade parts: the pause menu (Resume, Restart Level, How to Play, Sound, Exit to Arcade), How to Play, a result
card in the Arcade's style, Reduce motion, the Quiet / Wind Down sound ceiling, per-profile saves in `ArcadeStore`,
High Scores (each level played is a run; Hard runs say "· Hard").
High Scores (each level played is a run; Hard has its own table, below).
| File | What it is |
|---|---|
@@ -110,8 +110,17 @@ Chosen on BumbleHive's title (**MODE: NORMAL / MODE: HARD**, right of Play); rem
| Layouts | the 200 levels | the same shapes, rows and random draws; with more colours the flowers are coloured differently |
| Save | Normal's unlocks, stars, bests, page | its own, starting at level 1; never reads or writes Normal's |
Honeybombs, the daily spin and the skin, guide and sound choices belong to the profile, whichever mode. High Scores has one
BumbleHive list; Hard runs are marked "· Hard".
Honeybombs, the daily spin and the skin, guide and sound choices belong to the profile, whichever mode.
### Hard's own High Scores (Paul, 8 November 2026)
- Hard runs are saved only into a separate table, record id `HiveHard` (`HIVE_HARD_SCORES`) in the profile's Arcade file;
Normal runs stay under `Hive`, exactly as before. The two never mix, and no "· Hard" marker is needed.
- High Scores: BumbleHive's row shows a **◀ Normal ▶** / **◀ HARD ▶** switch (Hard in pink); ◀▶ on that row changes
table, and the Top 10 is headed "BUMBLEHIVE HARD · TOP 10". The footer says so when BumbleHive is visible.
- `HiveHard` isn't a game: no card, no settings, nothing extra for Kids filtering (it follows BumbleHive's visibility).
- Reset › Clear high scores for BumbleHive clears both tables; nothing else touches `HiveHard`.
- Existing files simply have no `HiveHard` yet: Normal's data is read and written unchanged.
## Known gaps