Night Shift power-ups from the pause menu: Moonbeam, Sleepy Time, Star Magnet, Night Vision, one each a level, none a move

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-09 10:21:17 +00:00
co-authored by Claude Opus 5.5
parent 0c915fc118
commit d81033681d
4 changed files with 125 additions and 15 deletions
@@ -101,7 +101,7 @@ internal fun ArcadeScrim(content: @Composable BoxScope.() -> Unit) {
*/
@Composable
internal fun ArcadePauseMenu(game: ArcadeGame, line: String, onResume: () -> Unit, onRestart: () -> Unit, onExit: () -> Unit,
sound: String? = null, onSound: (() -> Unit)? = null, extra: Pair<String, () -> Unit>? = null) {
sound: String? = null, onSound: (() -> Unit)? = null, extra: Pair<String, () -> Unit>? = null, extraIcon: String = "↶") {
var howTo by remember { mutableStateOf(false) }
if (howTo) { HowToPlayCard(game, firstRun = false, everyTime = null, onEveryTime = {}, onPlay = { howTo = false }, onBack = { howTo = false }); return }
val first = remember { FocusRequester() }
@@ -116,7 +116,7 @@ internal fun ArcadePauseMenu(game: ArcadeGame, line: String, onResume: () -> Uni
Spacer(Modifier.height(2.dp))
ArcadeButton("Resume", Modifier.fillMaxWidth().focusRequester(first), icon = "▶", onClick = onResume)
// A game's own line, where it has one (Patience's Undo on Gentle).
if (extra != null) ArcadeButton(extra.first, Modifier.fillMaxWidth(), icon = "↶", onClick = extra.second)
if (extra != null) ArcadeButton(extra.first, Modifier.fillMaxWidth(), icon = extraIcon, onClick = extra.second)
ArcadeButton("Restart Level", Modifier.fillMaxWidth(), icon = "↻", onClick = onRestart)
ArcadeButton("How to Play", Modifier.fillMaxWidth(), icon = "?", onClick = { howTo = true })
if (sound != null && onSound != null) ArcadeButton("Sound", Modifier.fillMaxWidth(), icon = "♪", detail = sound, onClick = onSound)
@@ -35,6 +35,18 @@ internal fun sides(piece: Char, turns: Int): Int {
/** Only these turn under OK: the star and the mast stay put. */
internal fun turnable(piece: Char) = piece == 'I' || piece == 'L' || piece == 'T'
/** Sleepy Time's doze, in hops. */
internal const val SLEEPY_HOPS = 10
/** Night Shift's power-ups: how many each level gives (Sleepy Time only where there are clouds). */
internal enum class NightPower(val title: String, val line: String) {
Moonbeam("Moonbeam", "Turns the nearest piece the light needs"),
SleepyTime("Sleepy Time", "The clouds doze for ten hops"),
StarMagnet("Star Magnet", "Nite Owl flies to the next piece to turn"),
NightVision("Night Vision", "Shows the way the light should go");
fun forLevel(level: NightLevel) = if (this == SleepyTime && level.clouds.isEmpty()) 0 else 1
}
internal class NightLevel(val rows: List<String>, val solution: List<String>, val par: Int, val clouds: List<List<Pair<Int, Int>>>) {
fun piece(i: Int) = rows[i / NW][i % NW * 2]
fun turns(i: Int) = rows[i / NW][i % NW * 2 + 1] - '0'
@@ -58,25 +70,50 @@ internal fun cloudAt(lane: List<Pair<Int, Int>>, hops: Int): Int {
}
/** One level being played. Turns count as moves; hops don't, but each hop moves the clouds on. */
internal class NightGame(val level: NightLevel, val turns: IntArray = IntArray(NW * NH) { level.turns(it) }, val owl: Int = start(level), val moves: Int = 0, val hops: Int = 0) {
internal class NightGame(val level: NightLevel, val turns: IntArray = IntArray(NW * NH) { level.turns(it) }, val owl: Int = start(level), val moves: Int = 0, val hops: Int = 0,
/** The clouds' own clock: a tick a hop, except while Sleepy Time has them dozing ([dozeFor] hops left). */
val cloudClock: Int = hops, val dozeFor: Int = 0) {
fun piece(i: Int) = level.piece(i)
/** Nite Owl hops to the next tile, if there is one; the clouds drift on a tile. */
fun hop(dx: Int, dy: Int): NightGame {
val x = owl % NW + dx; val y = owl / NW + dy
if (x !in 0 until NW || y !in 0 until NH) return this
return NightGame(level, turns, y * NW + x, moves, hops + 1)
return NightGame(level, turns, y * NW + x, moves, hops + 1, if (dozeFor > 0) cloudClock else cloudClock + 1, (dozeFor - 1).coerceAtLeast(0))
}
/** OK: the piece under Nite Owl turns a quarter, clockwise. Nothing there to turn, nothing happens. */
fun turn(): NightGame {
if (!turnable(piece(owl))) return this
val t = turns.copyOf(); t[owl] = (t[owl] + 1) % 4
return NightGame(level, t, owl, moves + 1, hops)
return NightGame(level, t, owl, moves + 1, hops, cloudClock, dozeFor)
}
/** The tiles the level's solution lights (clouds aside): the pieces that matter. */
fun solutionLit(): BooleanArray = NightGame(NightLevel(level.solution, level.solution, level.par, emptyList())).lit()
private fun solutionTurns(i: Int) = level.solution[i / NW][i % NW * 2 + 1] - '0'
/** The pieces the light needs that aren't turned the right way yet, nearest Nite Owl first. */
fun wrongPieces(): List<Int> {
val need = solutionLit()
return (0 until NW * NH).filter { need[it] && turnable(piece(it)) && sides(piece(it), turns[it]) != sides(piece(it), solutionTurns(it)) }
.sortedBy { kotlin.math.abs(it % NW - owl % NW) + kotlin.math.abs(it / NW - owl / NW) }
}
// ---------- the power-ups (frame 41), each optional and limited per level; none counts as a move ----------
/** Moonbeam: the nearest piece the light needs turns the right way, free. */
fun moonbeam(): NightGame {
val i = wrongPieces().firstOrNull() ?: return this
val t = turns.copyOf(); t[i] = solutionTurns(i)
return NightGame(level, t, owl, moves, hops, cloudClock, dozeFor)
}
/** Sleepy Time: the clouds doze where they are for the next ten hops. */
fun sleepyTime() = NightGame(level, turns, owl, moves, hops, cloudClock, SLEEPY_HOPS)
/** Star Magnet: Nite Owl is drawn straight to the next piece the light needs. */
fun starMagnet(): NightGame = wrongPieces().firstOrNull()?.let { NightGame(level, turns, it, moves, hops, cloudClock, dozeFor) } ?: this
/** The tiles a cloud sits on now ([at] hops), each blocking the light. */
fun cloudTiles(at: Int = hops): IntArray = IntArray(level.clouds.size) { cloudAt(level.clouds[it], at) }
fun cloudTiles(at: Int = cloudClock): IntArray = IntArray(level.clouds.size) { cloudAt(level.clouds[it], at) }
/** Every tile the light reaches: from the star along its beam, through pieces whose sides meet; clouds stop it. */
fun lit(): BooleanArray {
@@ -102,10 +102,23 @@ internal fun NightShiftScreen(play: ArcadePlay) {
var paused by remember { mutableStateOf(false) }
var howTo by remember { mutableStateOf(false) }
var finished by remember { mutableStateOf<Triple<Int, Int, Int>?>(null) } // stars, moves, par
// The level's power-ups (from the pause menu), and whether Night Vision is showing the way.
var powers by remember { mutableStateOf(NightPower.entries.associateWith { it.forLevel(game.level) }) }
var nightVision by remember { mutableStateOf(false) }
var powerMenu by remember { mutableStateOf(false) }
val par = nightPar(game.level, play.difficulty)
val focus = remember { FocusRequester() }
fun startLevel(c: Int, l: Int) { chapter = c; levelIx = l; game = NightGame(NightChapters[c].levels[l]); paused = false; finished = null; stage = NightStage.Play }
fun startLevel(c: Int, l: Int) {
chapter = c; levelIx = l; game = NightGame(NightChapters[c].levels[l]); paused = false; finished = null; stage = NightStage.Play
powers = NightPower.entries.associateWith { it.forLevel(game.level) }; nightVision = false; powerMenu = false
}
fun use(p: NightPower) {
if ((powers[p] ?: 0) <= 0) return
powers = powers + (p to (powers[p] ?: 0) - 1)
when (p) { NightPower.Moonbeam -> game = game.moonbeam(); NightPower.SleepyTime -> game = game.sleepyTime(); NightPower.StarMagnet -> game = game.starMagnet(); NightPower.NightVision -> nightVision = true }
powerMenu = false; paused = false
}
// A finished level: its best saved (more stars, or fewer moves), and the profile's total stars in the High Scores.
LaunchedEffect(game) {
if (stage != NightStage.Play || !game.won) return@LaunchedEffect
@@ -145,7 +158,7 @@ internal fun NightShiftScreen(play: ArcadePlay) {
if (next != null) game = next
next != null
}
NightPlay(game, chapter, levelIx, par, keys, still = Motion.reduce || play.reduceFlashing)
NightPlay(game, chapter, levelIx, par, keys, still = Motion.reduce || play.reduceFlashing, powers = powers, nightVision = nightVision)
if (stage == NightStage.Complete) finished?.let { (stars, moves, p) ->
NightComplete(chapter, levelIx, stars, moves, p, last = chapter == NightChapters.lastIndex && levelIx == NightChapters[chapter].levels.lastIndex,
onNext = {
@@ -156,9 +169,10 @@ internal fun NightShiftScreen(play: ArcadePlay) {
},
onReplay = { startLevel(chapter, levelIx) }, onChapters = { stage = NightStage.Chapters })
}
if (paused && stage == NightStage.Play) ArcadePauseMenu(gameDef, "Chapter ${chapter + 1} · Level ${levelIx + 1} · ${game.moves} moves",
if (paused && stage == NightStage.Play && powerMenu) NightPowerMenu(powers, onUse = ::use, onBack = { powerMenu = false })
else if (paused && stage == NightStage.Play) ArcadePauseMenu(gameDef, "Chapter ${chapter + 1} · Level ${levelIx + 1} · ${game.moves} moves",
onResume = { paused = false }, onRestart = { startLevel(chapter, levelIx) }, onExit = { latestPlay.onLeave() },
extra = "Chapters" to { paused = false; stage = NightStage.Chapters })
extra = "Power-ups (${powers.values.sum()} left)" to { powerMenu = true }, extraIcon = "✦")
}
}
}
@@ -320,10 +334,12 @@ private fun NightChaptersPage(saved: Map<String, String>, current: Int, onPlay:
@Suppress("ModifierParameter") // [keys] is the screen's key handling, not a layout modifier
@Composable
private fun NightPlay(game: NightGame, chapter: Int, level: Int, par: Int, keys: Modifier, still: Boolean) {
private fun NightPlay(game: NightGame, chapter: Int, level: Int, par: Int, keys: Modifier, still: Boolean, powers: Map<NightPower, Int>, nightVision: Boolean) {
val on = remember(game) { game.lit() }
val clouds = remember(game) { game.cloudTiles() }
val nextClouds = remember(game) { game.cloudTiles(game.hops + 1) }
// Where the clouds go on the next hop (nowhere while they doze).
val nextClouds = remember(game) { game.cloudTiles(if (game.dozeFor > 0) game.cloudClock else game.cloudClock + 1) }
val way = remember(game.level, nightVision) { if (nightVision) game.solutionLit() else null }
Column(Modifier.fillMaxSize().then(keys).padding(start = 32.dp, end = 32.dp, top = 22.dp, bottom = 10.dp)) {
Row(Modifier.fillMaxWidth().weight(1f), horizontalArrangement = Arrangement.spacedBy(18.dp)) {
Column(Modifier.width(176.dp).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(2.dp)) {
@@ -347,9 +363,20 @@ private fun NightPlay(game: NightGame, chapter: Int, level: Int, par: Int, keys:
}
Box(Modifier.weight(1f).fillMaxHeight(), contentAlignment = Alignment.Center) {
Canvas(Modifier.fillMaxHeight().aspectRatio(NW / NH.toFloat()).background(NightColours.Panel.copy(alpha = .6f), RoundedCornerShape(14.dp))
.border(1.dp, NightColours.TileEdge, RoundedCornerShape(14.dp)).padding(8.dp)) { drawBoard(game, on, clouds, nextClouds, still) }
.border(1.dp, NightColours.TileEdge, RoundedCornerShape(14.dp)).padding(8.dp)) { drawBoard(game, on, clouds, nextClouds, still, way) }
}
Column(Modifier.width(110.dp).fillMaxHeight(), horizontalAlignment = Alignment.End) {
Column(Modifier.width(150.dp).fillMaxHeight(), horizontalAlignment = Alignment.End, verticalArrangement = Arrangement.spacedBy(4.dp)) {
// The level's power-ups (frame 41): used from the pause menu, so no Menu key is needed.
Text("POWER-UPS", color = NightColours.Muted, fontSize = 14.sp, letterSpacing = 2.sp)
for (p in NightPower.entries) {
val n = powers[p] ?: 0
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
Text(p.title, color = if (n > 0) NightColours.Ink else NightColours.Muted.copy(alpha = .6f), fontSize = 14.sp)
Text("×$n", color = NightColours.Muted, fontSize = 14.sp)
}
}
if (game.dozeFor > 0) Text("Clouds dozing: ${game.dozeFor}", color = NightColours.Glow, fontSize = 13.sp)
Text("Pause to use one", color = NightColours.Muted, fontSize = 13.sp)
Spacer(Modifier.weight(1f))
// Luna in her Night Cap keeps Nite Owl company.
Canvas(Modifier.size(80.dp)) { drawNightCap(center + Offset(0f, size.height * .08f), size.minDimension * .34f) }
@@ -361,7 +388,7 @@ private fun NightPlay(game: NightGame, chapter: Int, level: Int, par: Int, keys:
}
/** The board: tiles, beam pieces (lit where the light reaches), the star and mast, the clouds and where they go next, and Nite Owl. */
private fun DrawScope.drawBoard(game: NightGame, on: BooleanArray, clouds: IntArray, nextClouds: IntArray, still: Boolean) {
private fun DrawScope.drawBoard(game: NightGame, on: BooleanArray, clouds: IntArray, nextClouds: IntArray, still: Boolean, way: BooleanArray? = null) {
val cell = minOf(size.width / NW, size.height / NH)
val ox = (size.width - cell * NW) / 2; val oy = (size.height - cell * NH) / 2
val pad = cell * .05f
@@ -372,6 +399,8 @@ private fun DrawScope.drawBoard(game: NightGame, on: BooleanArray, clouds: IntAr
if (nextClouds.contains(i) && !clouds.contains(i))
drawRoundRect(NightColours.Muted.copy(alpha = .55f), Offset(x + pad * 2.5f, y + pad * 2.5f), Size(cell - 5 * pad, cell - 5 * pad), CornerRadius(cell * .1f),
style = Stroke(1.5f, pathEffect = androidx.compose.ui.graphics.PathEffect.dashPathEffect(floatArrayOf(6f, 5f))))
// Night Vision: the way the light should go, softly outlined.
if (way != null && way[i]) drawRoundRect(NightColours.Star.copy(alpha = .35f), Offset(x + pad * 1.5f, y + pad * 1.5f), Size(cell - 3 * pad, cell - 3 * pad), CornerRadius(cell * .12f), style = Stroke(2f))
val c = Offset(x + cell / 2, y + cell / 2)
val p = game.piece(i)
when (p) {
@@ -451,3 +480,28 @@ private fun NightComplete(chapter: Int, level: Int, stars: Int, moves: Int, par:
KeyFooter(listOf(Control("◀▶", "Choose"), Control("OK", "Select"), Control("Back", "Chapters")), Modifier.align(Alignment.BottomStart).padding(start = 24.dp, end = 24.dp, bottom = 10.dp))
}
}
// ---------- Power-ups (from the pause menu) ----------
@Composable
private fun NightPowerMenu(powers: Map<NightPower, Int>, onUse: (NightPower) -> Unit, onBack: () -> Unit) {
val first = remember { FocusRequester() }
LaunchedEffect(Unit) { runCatching { first.requestFocus() } }
BackHandler(onBack = onBack)
tv.orbit.classic.arcade.ArcadeScrim {
Column(Modifier.width(360.dp).onBackKey(action = onBack).background(NightColours.Panel, RoundedCornerShape(12.dp)).border(1.dp, NightColours.TileEdge, RoundedCornerShape(12.dp)).padding(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text("POWER-UPS", color = NightColours.Ink, fontFamily = Anton, fontSize = 26.sp)
Text("Optional: par and stars work without them.", color = NightColours.Muted, fontSize = 13.sp)
NightPower.entries.forEachIndexed { k, p ->
val n = powers[p] ?: 0
Column {
ArcadeButton(p.title, Modifier.fillMaxWidth().then(if (k == 0) Modifier.focusRequester(first) else Modifier), detail = "×$n", enabled = n > 0, onClick = { onUse(p) })
Text(p.line, Modifier.padding(start = 12.dp, top = 2.dp), color = NightColours.Muted, fontSize = 12.sp)
}
}
ArcadeButton("Back", Modifier.fillMaxWidth(), icon = "←", onClick = onBack)
}
KeyFooter(listOf(Control("▲▼", "Choose"), Control("OK", "Use"), Control("Back", "Back")), Modifier.align(Alignment.BottomStart).padding(start = 32.dp, end = 32.dp, bottom = 16.dp))
}
}
@@ -89,4 +89,23 @@ class NightShiftLevelsTest {
assertEquals(24, NightProgress.totalStars(saved)); assertEquals("First Light done · The Quiet Mast in progress", chapterStatus(saved))
assertTrue(NightProgress.better(2 to 20, 3, 30)); assertTrue(NightProgress.better(2 to 20, 2, 19)); assertFalse(NightProgress.better(2 to 20, 2, 25))
}
@Test fun thePowerUpsHelpWithoutCountingAsMoves() {
val lv = NightChapters[2].levels[3]
val g = NightGame(lv)
val wrong = g.wrongPieces()
assertTrue(wrong.isNotEmpty())
// Moonbeam turns the nearest needed piece right, free.
val m = g.moonbeam()
assertEquals(wrong.size - 1, m.wrongPieces().size); assertEquals(0, m.moves)
// Star Magnet takes Owl to the next piece to turn.
assertEquals(wrong.first(), g.starMagnet().owl)
// Sleepy Time: the clouds stay put for ten hops, then drift again.
var s = g.sleepyTime(); val before = s.cloudTiles().toList()
repeat(SLEEPY_HOPS) { s = s.hop(if (s.owl % NW == 0) 1 else -1, 0) }
assertEquals(before, s.cloudTiles().toList())
assertNotEquals(before, s.hop(if (s.owl % NW == 0) 1 else -1, 0).cloudTiles().toList())
// One of each a level, Sleepy Time only where there are clouds.
assertEquals(0, NightPower.SleepyTime.forLevel(NightChapters[0].levels[0])); assertEquals(1, NightPower.SleepyTime.forLevel(lv))
}
}