From 84fc494b6ff70fbabb74af01aa66f6f6b1697060 Mon Sep 17 00:00:00 2001 From: Pauljd Date: Mon, 9 Nov 2026 10:02:02 +0000 Subject: [PATCH] 0.114.0 (versionCode 304): Comet Trail Constellations; Night Cap in Skydoku; the remaining approved Classic modes complete Co-Authored-By: Claude Opus 5.5 --- android/app/build.gradle.kts | 4 +- .../main/java/tv/orbit/classic/OrbitArcade.kt | 116 ++++++++++++++++-- .../tv/orbit/classic/arcade/ArcadeStore.kt | 4 + .../java/tv/orbit/classic/SnakeGameTest.kt | 41 +++++++ .../orbit/classic/arcade/TitleTextFitsTest.kt | 2 +- docs/classics-modes.md | 49 ++++++++ 6 files changed, 202 insertions(+), 14 deletions(-) diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts index 7493b598..532861ed 100644 --- a/android/app/build.gradle.kts +++ b/android/app/build.gradle.kts @@ -9,8 +9,8 @@ android { applicationId = "tv.orbit.classic" minSdk = 26 targetSdk = 36 - versionCode = 303 - versionName = "0.113.0-classic-challenges" + versionCode = 304 + versionName = "0.114.0-classic-modes" } buildFeatures { compose = true } // The finished build for the TVs (Paul, 6 November 2026: the test build stuttered on the box). Not debuggable, so diff --git a/android/app/src/main/java/tv/orbit/classic/OrbitArcade.kt b/android/app/src/main/java/tv/orbit/classic/OrbitArcade.kt index 0350b343..97b4a202 100644 --- a/android/app/src/main/java/tv/orbit/classic/OrbitArcade.kt +++ b/android/app/src/main/java/tv/orbit/classic/OrbitArcade.kt @@ -17,6 +17,8 @@ import tv.orbit.classic.arcade.classicPace import tv.orbit.classic.arcade.classicPanel import tv.orbit.classic.arcade.gameKeys import tv.orbit.classic.arcade.previousLine +import tv.orbit.classic.arcade.SNAKE_CONSTELLATIONS_SCORES +import tv.orbit.classic.arcade.SpeechBubble import android.view.KeyEvent import androidx.activity.compose.BackHandler @@ -77,7 +79,17 @@ internal data class SnakeCell(val x: Int, val y: Int) * was lost); it's taken on the next step. */ internal data class SnakeGame(val width: Int, val height: Int, val body: List, val heading: SnakeDirection, val wanted: SnakeDirection, val food: SnakeCell, val score: Int = 0, val alive: Boolean = true, - val queued: SnakeDirection? = null) { + val queued: SnakeDirection? = null, + /** Constellations (Phase 2): the stars of this constellation in the order to collect them, and which is next. Classic: none. */ + val pattern: List = emptyList(), val nextStar: Int = 0, + /** Which constellation this is (by [Constellations]), and how many have been lit. */ + val constellation: Int = 0, val lit: Int = 0, + /** A pair of wormholes: into one, out of the other, still heading the same way. */ + val wormholes: List = emptyList(), + /** Stardust (Gentle): the tail never grows past this; 0 means it grows for ever, as in Classic. */ + val maxLen: Int = 0, + /** The constellation just lit, for Luna to name; null until the first. */ + val named: String? = null) { /** A turn back on yourself is ignored, as it could only ever end the game. A turn while one is waiting goes next. */ fun turn(direction: SnakeDirection): SnakeGame { if (wanted != heading) return if (direction == wanted || direction == wanted.opposite) this else copy(queued = direction) @@ -87,20 +99,43 @@ internal data class SnakeGame(val width: Int, val height: Int, val body: List 0 && it.size > maxLen) it.take(maxLen) else it } + if (pattern.isNotEmpty()) return starStep(grown, eating, random) return copy(body = grown, heading = wanted, wanted = queued ?: wanted, queued = null, food = if (eating) nextFood(width, height, grown, random) ?: food else food, score = if (eating) score + 10 else score, alive = grown.size < width * height) } + /** Constellations: the next star in order is the food; the last lights the constellation, Luna names it, and a new one appears. */ + private fun starStep(grown: List, eating: Boolean, random: java.util.Random): SnakeGame { + val moved = copy(body = grown, heading = wanted, wanted = queued ?: wanted, queued = null) + if (!eating) return moved + val n = nextStar + 1 + if (n < pattern.size) return moved.copy(nextStar = n, food = pattern[n], score = score + 10) + val c = (constellation + 1) % Constellations.size + val placed = placeConstellation(c, width, height, grown.toSet() + wormholes, random) + return moved.copy(score = score + 10 + CONSTELLATION_BONUS * pattern.size, lit = lit + 1, named = Constellations[constellation].first, + constellation = c, pattern = placed, nextStar = 0, food = placed.first()) + } + /** Starts at a walking pace and quickens noticeably with every bite, up to a limit. */ val tickMs get() = (150L - score / 10 * 5).coerceAtLeast(50L) companion object { + /** A Constellations game: two wormholes, the first constellation, and stardust on Gentle. */ + fun constellations(width: Int, height: Int, random: java.util.Random, gentle: Boolean): SnakeGame { + val g = start(width, height, random) + val holes = listOf(SnakeCell(width / 6, height / 5), SnakeCell(width - 1 - width / 6, height - 1 - height / 5)) + val first = placeConstellation(0, width, height, g.body.toSet() + holes, random) + return g.copy(wormholes = holes, pattern = first, nextStar = 0, food = first.first(), maxLen = if (gentle) STARDUST_LENGTH else 0) + } + fun start(width: Int, height: Int, random: java.util.Random): SnakeGame { val y = height / 2 val body = List(4) { SnakeCell(width / 4 - it, y) } @@ -124,13 +159,40 @@ internal data class SnakeGame(val width: Int, val height: Int, val body: List>>> = listOf( + "The Telly" to listOf(0 to 0, 4 to 0, 4 to 3, 0 to 3, 2 to 5), + "Ollie's Ring" to listOf(0 to 2, 2 to 0, 5 to 0, 7 to 2, 5 to 4, 2 to 4), + "The Big Dish" to listOf(0 to 0, 1 to 2, 3 to 3, 5 to 2, 6 to 0, 3 to 1), + "The Comet" to listOf(0 to 0, 2 to 1, 4 to 2, 6 to 3, 8 to 4), + "Bumble's Hive" to listOf(1 to 0, 3 to 0, 4 to 2, 3 to 4, 1 to 4, 0 to 2), + "The Remote" to listOf(1 to 0, 1 to 2, 0 to 4, 2 to 4, 1 to 6)) + +/** Where a constellation goes: somewhere it fits, clear of [taken]; tried at random, then anywhere free. */ +internal fun placeConstellation(index: Int, width: Int, height: Int, taken: Set, random: java.util.Random): List { + val shape = Constellations[index].second + val w = shape.maxOf { it.first } + 1; val h = shape.maxOf { it.second } + 1 + repeat(80) { + val ox = 1 + random.nextInt((width - w - 1).coerceAtLeast(1)); val oy = 1 + random.nextInt((height - h - 1).coerceAtLeast(1)) + val cells = shape.map { (x, y) -> SnakeCell(ox + x, oy + y) } + if (cells.none { it in taken } && cells.all { it.x in 0 until width && it.y in 0 until height }) return cells + } + val free = (0 until height).flatMap { y -> (0 until width).map { x -> SnakeCell(x, y) } }.filter { it !in taken }.shuffled(random) + return free.take(shape.size) +} + /** A new backdrop every ten bites, going round. */ internal fun snakeBackdrop(score: Int) = (score / 100) % SNAKE_BACKDROPS /** Where each piece of the snake is drawn, partway between two steps, so it glides from cell to cell rather than jumping. */ internal fun snakeLine(game: SnakeGame, before: List?, progress: Float): List> = game.body.mapIndexed { index, cell -> - val from = before?.getOrNull(index)?.takeIf { game.alive } ?: cell + // Out of a wormhole the head appears at once, rather than sliding across the sky. + val from = before?.getOrNull(index)?.takeIf { game.alive && kotlin.math.abs(it.x - cell.x) + kotlin.math.abs(it.y - cell.y) <= 1 } ?: cell (from.x + (cell.x - from.x) * progress) to (from.y + (cell.y - from.y) * progress) } @@ -147,6 +209,21 @@ private fun SnakeField(game: SnakeGame, modifier: Modifier, before: List + if (i < game.nextStar) drawPath(starPath(at(st.x.toFloat(), st.y.toFloat()), cell * .3f, cell * .13f, 0f), Color(0xFFFFDE59).copy(alpha = .8f)) + else if (i > game.nextStar) drawCircle(Color.White.copy(alpha = .35f), cell * .12f, at(st.x.toFloat(), st.y.toFloat())) + } + } + for ((k, w) in game.wormholes.withIndex()) { + val c = at(w.x.toFloat(), w.y.toFloat()) + drawCircle(Color(0xFFA77BFF).copy(alpha = .25f), cell * .75f, c) + drawCircle(Color(0xFFA77BFF), cell * .45f, c, style = androidx.compose.ui.graphics.drawscope.Stroke(cell * .1f)) + drawCircle(if (k == 0) Color(0xFF35D6F2) else Color(0xFFFF4FA3), cell * .15f, c) + } drawPath(starPath(at(game.food.x.toFloat(), game.food.y.toFloat()), cell * .5f, cell * .22f, 0f), Color(0xFFFFDE59)) val line = snakeLine(game, before, progress) val tail = line.drop(1) @@ -172,12 +249,15 @@ internal fun SnakeScreen(play: ArcadePlay) { var stage by remember { mutableStateOf(ClassicStage.Title) } var paused by remember { mutableStateOf(false) } var howTo by remember { mutableStateOf(false) } - var bestBefore by remember { mutableIntStateOf(play.best) } + // Classic, or Constellations (Phase 2): chosen on the title, remembered, each with its own High Scores. + var stars by remember { mutableStateOf(play.level["mode"] == "Constellations") } + val table = if (stars) SNAKE_CONSTELLATIONS_SCORES else gameDef.id + var bestBefore by remember { mutableIntStateOf(play.bestIn(table)) } val focus = remember { FocusRequester() } val pace = classicPace(play.difficulty) PauseWhenHidden(stage == ClassicStage.Play && !paused) { paused = true } - val run = rememberRun(play.onRunEnd) { RunEnd(game.score, finished = false) } - fun startRun() { bestBefore = latestPlay.best; game = SnakeGame.start(30, 22, random); before = null; progress = 1f; run.begin(); paused = false; stage = ClassicStage.Play } + val run = rememberRun({ end -> if (game.pattern.isNotEmpty()) latestPlay.onRunEndIn(SNAKE_CONSTELLATIONS_SCORES, end) else latestPlay.onRunEnd(end) }) { RunEnd(game.score, finished = false) } + fun startRun() { bestBefore = latestPlay.bestIn(table); game = if (stars) SnakeGame.constellations(30, 22, random, gentle = latestPlay.difficulty == tv.orbit.classic.arcade.Difficulty.Gentle) else SnakeGame.start(30, 22, random); before = null; progress = 1f; run.begin(); paused = false; stage = ClassicStage.Play } fun leave() { run.end(RunEnd(game.score, finished = !game.alive)); latestPlay.onLeave() } // Steps on the clock (Difficulty sets its pace; Normal as it always was), drawn on every frame between them. var sinceStep by remember { mutableLongStateOf(0L) } @@ -198,12 +278,19 @@ internal fun SnakeScreen(play: ArcadePlay) { LaunchedEffect(playing) { play.audio.music(R.raw.snake_theme, playing, base = .5f, gameOn = musicOn) } DisposableEffect(Unit) { onDispose { play.audio.stopMusic() } } LaunchedEffect(stage, paused) { if (stage == ClassicStage.Play && !paused) runCatching { focus.requestFocus() } } + // Luna names each constellation as it lights up, for a moment. + var named by remember { mutableStateOf(null) } + LaunchedEffect(game.lit) { if (game.lit > 0) { named = game.named; kotlinx.coroutines.delay(2_500); named = null } } BackHandler(stage == ClassicStage.Play && !paused) { paused = true } if (stage == ClassicStage.Title) { - ClassicTitle(gameDef, ArcadeLook.comet(0), OrbCharacter.Blaze.colour, "Stars! I'm starving!", listOf("Your best" to if (play.best > 0) "%,d".format(play.best) else "Not played yet"), + val best = play.bestIn(table) + ClassicTitle(gameDef, ArcadeLook.comet(0), OrbCharacter.Blaze.colour, if (stars) "Join the stars up, in order!" else "Stars! I'm starving!", + listOf("Your best" to if (best > 0) "%,d".format(best) else "Not played yet"), timed = true, difficulty = play.difficulty, refocus = !howTo, onPlay = ::startRun, onHowTo = { howTo = true }, onBack = { latestPlay.onLeave() }, - note = "He speeds up with every star, and the sky changes every hundred points.") + mode = if (stars) "Constellations" else "Classic", modes = 2, onMode = { stars = !stars; latestPlay.setLevel("mode", if (stars) "Constellations" else "Classic") }, + note = if (stars) "Each constellation's stars wait in a pattern: collect them in order to light it up for a big bonus, and Luna names it. Two wormholes take Blaze across the sky. On Gentle his tail is stardust: it never grows past twelve." + else "He speeds up with every star, and the sky changes every hundred points.") if (howTo) HowToPlayCard(gameDef, firstRun = false, everyTime = null, onEveryTime = {}, onPlay = { howTo = false }, onBack = { howTo = false }) return } @@ -227,11 +314,18 @@ internal fun SnakeScreen(play: ArcadePlay) { HudLabel("BEST"); HudValue("%,d".format(maxOf(bestBefore, game.score))) Spacer(Modifier.height(6.dp)) HudLabel("TAIL"); HudValue("${game.body.size - 1}") + if (game.pattern.isNotEmpty()) { + Spacer(Modifier.height(6.dp)) + HudLabel("CONSTELLATION"); Text("Star ${game.nextStar + 1} of ${game.pattern.size}", color = ArcadeColours.Ink, fontSize = 16.sp, fontWeight = FontWeight.SemiBold) + HudLabel("LIT ${game.lit}") + Spacer(Modifier.weight(1f)) + if (named != null) { SpeechBubble("That's ${named}!"); Canvas(Modifier.size(48.dp)) { drawOrbChaser(center, size.minDimension * .38f, OrbCharacter.Luna, OrbDir.Down, false, false, false, 0f) } } + } }) { SnakeField(game, Modifier.fillMaxSize().classicPanel().padding(6.dp), before, progress) } - if (stage == ClassicStage.Result) ClassicResult(gameDef, "COMET TRAIL · ${game.body.size - 1} TAIL PUFFS", "SCORE", "%,d".format(game.score), - newBest = game.score > bestBefore && game.score > 0, previous = previousLine(gameDef.scoreKind, bestBefore, gameDef.title), detail = null, + if (stage == ClassicStage.Result) ClassicResult(gameDef, if (game.pattern.isNotEmpty()) "COMET TRAIL · CONSTELLATIONS · ${game.lit} LIT" else "COMET TRAIL · ${game.body.size - 1} TAIL PUFFS", "SCORE", "%,d".format(game.score), + newBest = game.score > bestBefore && game.score > 0, previous = previousLine(gameDef.scoreKind, bestBefore, if (game.pattern.isNotEmpty()) "Constellations" else gameDef.title), detail = null, cheer = Mascot.Zip, onAgain = ::startRun, onBack = ::leave) if (paused && stage == ClassicStage.Play) ArcadePauseMenu(gameDef, "Comet Trail · ${"%,d".format(game.score)}", onResume = { paused = false }, onRestart = { run.end(RunEnd(game.score, finished = false)); startRun() }, onExit = ::leave, diff --git a/android/app/src/main/java/tv/orbit/classic/arcade/ArcadeStore.kt b/android/app/src/main/java/tv/orbit/classic/arcade/ArcadeStore.kt index 2d64305a..6cb042d5 100644 --- a/android/app/src/main/java/tv/orbit/classic/arcade/ArcadeStore.kt +++ b/android/app/src/main/java/tv/orbit/classic/arcade/ArcadeStore.kt @@ -122,6 +122,9 @@ internal const val PAIRS_SHOWTIME_SCORES = "PairsShowtime" /** Blast Off's Challenges: the furthest of the twenty cleared. */ internal const val BLAST_CHALLENGE_SCORES = "BlastChallenge" +/** Comet Trail's Constellations: points. */ +internal const val SNAKE_CONSTELLATIONS_SCORES = "SnakeConstellations" + /** * One of a game's High Scores tables: the game's own (its id, its score kind), or a mode's, kept under its own record id so * the two never mix (Paul: "preserve existing scores and make new modes separate"). [format] writes a score for the page. @@ -140,6 +143,7 @@ internal val modeTables: Map> = mapOf( "Pairs" to listOf(ScoreTable(PAIRS_CHALLENGE_SCORES, "Challenge", ScoreKind.Points) { tv.orbit.classic.pairsLine(it) }, ScoreTable(PAIRS_SHOWTIME_SCORES, "Showtime", ScoreKind.Points)), "Blast" to listOf(ScoreTable(BLAST_CHALLENGE_SCORES, "Challenges", ScoreKind.Points) { tv.orbit.classic.blastChallengeLine(it) }), + "Snake" to listOf(ScoreTable(SNAKE_CONSTELLATIONS_SCORES, "Constellations", ScoreKind.Points)), "Sky" to listOf(ScoreTable(SKY_CHALLENGE_SCORES, "Challenge", ScoreKind.Points) { tv.orbit.classic.challengeLine(it) }), ) diff --git a/android/app/src/test/java/tv/orbit/classic/SnakeGameTest.kt b/android/app/src/test/java/tv/orbit/classic/SnakeGameTest.kt index fc1de781..43faf61c 100644 --- a/android/app/src/test/java/tv/orbit/classic/SnakeGameTest.kt +++ b/android/app/src/test/java/tv/orbit/classic/SnakeGameTest.kt @@ -103,4 +103,45 @@ class SnakeGameTest { assertEquals(old, SnakeGame.nextFood(5, 4, body, r1)) assertNull(SnakeGame.nextFood(1, 2, listOf(SnakeCell(0, 0), SnakeCell(0, 1)), r1)) } + + // ---------- Constellations (Phase 2) ---------- + + @Test fun constellationsStartWithWormholesAndTheFirstPattern() { + val g = SnakeGame.constellations(30, 22, java.util.Random(4), gentle = false) + assertEquals(2, g.wormholes.size); assertEquals(Constellations[0].second.size, g.pattern.size) + assertEquals(g.pattern.first(), g.food); assertEquals(0, g.maxLen) + assertTrue(g.pattern.none { it in g.body || it in g.wormholes }) + // Classic has none of it. + val c = SnakeGame.start(30, 22, java.util.Random(4)) + assertTrue(c.pattern.isEmpty() && c.wormholes.isEmpty()) + assertEquals(STARDUST_LENGTH, SnakeGame.constellations(30, 22, java.util.Random(4), gentle = true).maxLen) + } + + @Test fun starsInOrderLightTheConstellationAndLunaNamesIt() { + val r = java.util.Random(6) + var g = SnakeGame.constellations(30, 22, r, gentle = false) + val size = g.pattern.size + // Put each star just ahead of Blaze in turn. + repeat(size) { + val head = g.body.first() + val ahead = SnakeCell(head.x + g.wanted.dx, head.y + g.wanted.dy) + g = g.copy(pattern = g.pattern.toMutableList().also { p -> p[g.nextStar] = ahead }, food = ahead).step(r) + } + assertEquals(1, g.lit); assertEquals(Constellations[0].first, g.named) + assertEquals(1, g.constellation); assertEquals(0, g.nextStar); assertEquals(Constellations[1].second.size, g.pattern.size) + assertEquals(size * 10 + CONSTELLATION_BONUS * size, g.score) + } + + @Test fun aWormholeTakesBlazeAcrossTheSky() { + val g = game(3 to 5, 2 to 5).copy(wormholes = listOf(SnakeCell(4, 5), SnakeCell(7, 2))) + val next = g.step(java.util.Random(1)) + assertEquals(SnakeCell(7, 2), next.body.first()); assertTrue(next.alive) + } + + @Test fun stardustKeepsTheTailShortOnGentle() { + var g = game(3 to 5, 2 to 5, food = 4 to 5).copy(maxLen = 3) + val r = java.util.Random(2) + repeat(4) { val h = g.body.first(); g = g.copy(food = SnakeCell(h.x + 1, h.y)).step(r) } + assertEquals(3, g.body.size) + } } diff --git a/android/app/src/test/java/tv/orbit/classic/arcade/TitleTextFitsTest.kt b/android/app/src/test/java/tv/orbit/classic/arcade/TitleTextFitsTest.kt index f168d5cb..4fe3bfca 100644 --- a/android/app/src/test/java/tv/orbit/classic/arcade/TitleTextFitsTest.kt +++ b/android/app/src/test/java/tv/orbit/classic/arcade/TitleTextFitsTest.kt @@ -90,7 +90,7 @@ class TitleTextFitsTest { @Test fun theModeButtonSpellsEachModeOutInFull() { // The mode's whole name on the button, after its ◆, in the title's 210 dp column. val label = Font(Font.SANS_SERIF, Font.BOLD, 1).deriveFont(14f * 1.3f) - for (mode in listOf("Classic", "Signal Run", "Challenge", "Challenges", "40-Line Sprint", "Daily Challenge", "Daily · Draw Three", "Orbit Deck", "Showtime") + tv.orbit.classic.PairsMode.entries.map { it.title }) { + for (mode in listOf("Classic", "Signal Run", "Challenge", "Challenges", "40-Line Sprint", "Daily Challenge", "Daily · Draw Three", "Orbit Deck", "Showtime", "Broadcast", "Wind Down", "Constellations") + tv.orbit.classic.PairsMode.entries.map { it.title }) { val w = width(label, "◆ $mode") assertTrue("Mode · $mode is ${"%.0f".format(w)} dp", w <= 230 - 2 * 12 - 4) } diff --git a/docs/classics-modes.md b/docs/classics-modes.md index 7e958343..f4c600ba 100644 --- a/docs/classics-modes.md +++ b/docs/classics-modes.md @@ -55,3 +55,52 @@ unchanged (`ModeTablesTest`). Checks: 1,022 unit tests run, 24 skipped, 0 failed; lint 0 errors, 87 warnings (none new); release APK 48,039,519 bytes (+32,772 on 0.112.0); every mode name and new button fits at the largest font scale. Not installed; nothing seen running. + +## More modes (0.114.0, versionCode 304) + +Each separate, with its own High Scores (Family Play excepted: it's everyone's game), Classic untouched. + +- **Skydoku's 8×8** brings in **Night Cap** (Luna in her late-night cap) as its eighth. +- **Patience: Orbit Deck** (`PatienceOrbit`, games won): + - The four suits are Channel Chaos's channels, each with its mark: Orbit 1's star, Riot's bolt, Tots' sun, Terra's leaf. + - Orbit 1 and Terra are cool and Riot and Tots warm, so columns go warm, cool, warm, as red and black did. + - Ollie is on the aces, Zip on the jacks, Luna on the queens and Blaze on the kings. + - Ollie hints the best move he can see, in order: a card home, a run that uncovers a card, the turned card, a king into + a space. + - Undo is in the pause menu on Gentle. Three cards turn at a time on Tricky. +- **Pairs: Showtime** (`PairsShowtime`, points): + - Five boards, from 4×3 up to 6×5. + - A match scores 100 times the streak, and a miss starts the streak again. Each board cleared adds 500. + - From the second board there's one special pair: + - Drift swaps two face-down cards. + - Bumble flashes a pair open. + - Zip lights up a row. + - In one board in 25, the wizard of page 999, worth 999. +- **Pairs: Family Play for 2, 3 or 4**: + - Shared turns on one remote, on a 6×4 board. + - Find a pair and go again; a miss passes the turn. Most pairs wins. + - No High Scores. +- **Block Drop: Broadcast** (`BlocksBroadcast`, points): + - Every piece is one channel's colour. + - A cleared row with four or more of one channel is a Channel Bonus (+250 × level). + - Three bonuses set off a power-up, in turn: Signal Bomb (clears the 3×3 where the piece landed), Rewind (takes the + piece back), Freeze (8 s without gravity), Tuner (the next piece is a bar) and Clear Picture (the bottom row goes). + - They go off at once: the remote has no spare button to hold one for later. + - On Tricky, a row of static pushes up every 25 seconds. +- **Block Drop: Wind Down** (`BlocksWindDown`, points): + - No gravity: pieces move only when you send them. + - No game over: a full stack fades away and play goes on. +- **Comet Trail: Constellations** (`SnakeConstellations`, points): + - Each of six constellations (The Telly, Ollie's Ring, The Big Dish, The Comet, Bumble's Hive, The Remote) shows its + stars in a pattern. + - Collect them in order: each joins up to the last. The last lights it, for +20 a star, and Luna names it. + - Two wormholes take Blaze across the sky. + - On Gentle his tail is stardust and never grows past 12. + +Checks: +- Unit tests: 1,037 run, 24 skipped, 0 failed. +- Lint: 0 errors, 87 warnings (none new). +- Release APK: 48,072,287 bytes (+32,768 on 0.113.0). +- Layout: every mode name fits its button at the largest font scale. + +Not installed; nothing seen running.