Channel Chaos: playable prototype (0.110.14-chaos, versionCode 297)

The Channel Chaos card is now a game, from Stage B frames 30-33 and Paul's
notes: send each signal from the chute to its screen (Orbit 1 cyan star,
Riot pink bolt, Terra green leaf, Tots amber sun), OK bins static, three
jammed screens end the run. One new thing a stage (static, power-ups,
Drift's muddled signals), no timer for Gentle's first two stages, Blaze's
bonus round every third stage, Bumble repairing a jammed screen after it.
Between rounds the screens tune in with a little Orbit ident and 'And we're
back on air!', then a cast interruption that waits for OK (Paul's two lines
as written). Cast drawn from the cast library, unchanged. Shared pause, How
to Play, result, Reduce motion and flashing, per-profile saves, Kids-suitable.

15 new tests incl. a bot on each difficulty and 0 bytes a frame. One planner
test (SmartSetupRegressionTest) fails since midnight on the base commit too:
date-dependent, unrelated. Docs: docs/channel-chaos-prototype.md and its
VERIFICATION. Not installed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-09 00:44:52 +00:00
co-authored by Claude Opus 5.5
parent 585ac726ee
commit 8c5c377988
13 changed files with 1518 additions and 10 deletions
+2 -2
View File
@@ -9,8 +9,8 @@ android {
applicationId = "tv.orbit.classic"
minSdk = 26
targetSdk = 36
versionCode = 296
versionName = "0.110.13-story-p1000"
versionCode = 297
versionName = "0.110.14-chaos"
}
buildFeatures { compose = true }
// The finished build for the TVs (Paul, 6 November 2026: the test build stuttered on the box). Not debuggable, so
@@ -73,9 +73,11 @@ internal object ArcadeGames {
listOf(Control("◀▶", "Move"), Control("OK", "Fire"), Control("Hold OK", "Auto-fire"), Control("▲", "Overdrive, when the meter is full"), BackPause),
"Keep the Orbit signal on air: each hit costs a bar.",
listOf(GameSetting("sounds", "Sound effects"))) { tv.orbit.classic.arcade.raiders.OrbiRaidersScreen(it) }
// Playable from 8 November 2026 (prototype): tv.orbit.classic.arcade.chaos.
val ChannelChaos: ArcadeGame = GameDef("ChannelChaos", "Channel Chaos", "Sort the signals", "Send every signal to its channel before the screens jam.", Mascot.Ollie,
kidsSuitable = true, original = true, launchable = false, ScoreKind.Points, keepsLevels = true, legacyRecordKey = null,
listOf(Control("◀▶▲▼", "Send a signal"), Control("OK", "Bin the static"), BackPause), "Three jammed screens and the run ends.")
kidsSuitable = true, original = true, launchable = true, ScoreKind.Points, keepsLevels = true, legacyRecordKey = null,
listOf(Control("◀▶▲▼", "Send a signal"), Control("OK", "Bin the static"), BackPause), "Three jammed screens and the run ends.",
listOf(GameSetting("sounds", "Sound effects"))) { tv.orbit.classic.arcade.chaos.ChannelChaosScreen(it) }
val Hive: ArcadeGame = GameDef("Hive", "BumbleHive", "Link, match, clear the hive", "Help Bumble fire flowers and clear the hive.", Mascot.Bumble,
kidsSuitable = true, original = true, launchable = true, ScoreKind.Points, keepsLevels = true, legacyRecordKey = null,
listOf(Control("◀▶", "Aim"), Control("OK", "Fire a flower"), Control("▼", "Swap flower"), Control("▲", "Honeybomb"), BackPause),
@@ -0,0 +1,427 @@
package tv.orbit.classic.arcade.chaos
import android.view.KeyEvent
import androidx.activity.compose.BackHandler
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.focusable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.rotate
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Shadow
import androidx.compose.ui.graphics.drawscope.scale
import androidx.compose.ui.graphics.drawscope.translate
import androidx.compose.ui.graphics.painter.BitmapPainter
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.res.imageResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.rememberTextMeasurer
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.IntSize
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.tv.material3.Text
import tv.orbit.classic.Anton
import tv.orbit.classic.Motion
import tv.orbit.classic.R
import tv.orbit.classic.arcade.ArcadeButton
import tv.orbit.classic.arcade.ArcadeColours
import tv.orbit.classic.arcade.ArcadeGameLoop
import tv.orbit.classic.arcade.ArcadeGames
import tv.orbit.classic.arcade.ArcadeKey
import tv.orbit.classic.arcade.ArcadePauseMenu
import tv.orbit.classic.arcade.ArcadePlay
import tv.orbit.classic.arcade.Control
import tv.orbit.classic.arcade.HowToPlayCard
import tv.orbit.classic.arcade.KeyCap
import tv.orbit.classic.arcade.KeyFooter
import tv.orbit.classic.arcade.PauseWhenHidden
import tv.orbit.classic.arcade.RepeatGuard
import tv.orbit.classic.arcade.RunEnd
import tv.orbit.classic.arcade.RunTracker
import tv.orbit.classic.arcade.arcadeKey
import tv.orbit.classic.arcade.onBackKey
import tv.orbit.classic.arcade.raiders.FixedStep
private enum class Stage { Title, Play, Result }
/** What the HUD shows, each its own state, so a frame redraws the field without recomposing the words. */
private class ChaosHud {
var frame by mutableLongStateOf(0L)
var score by mutableIntStateOf(0)
var chain by mutableIntStateOf(1)
var stage by mutableIntStateOf(1)
var jammed by mutableIntStateOf(0)
var bonusSecs by mutableIntStateOf(0)
var power by mutableStateOf<ChaosPower?>(null)
var powerSecs by mutableIntStateOf(0)
var autoLeft by mutableIntStateOf(0)
var hint by mutableIntStateOf(Hint.HELLO)
var hintSide by mutableIntStateOf(0)
var phase by mutableStateOf(Phase.Playing)
var drift by mutableStateOf(false)
fun read(s: ChaosSim) {
frame++
score = s.score; chain = s.chain; stage = s.stage; jammed = s.jammedCount; bonusSecs = kotlin.math.ceil(s.bonus).toInt()
power = s.timedPower; powerSecs = kotlin.math.ceil(s.powerLeft).toInt(); autoLeft = s.autoLeft
hint = s.hint; hintSide = s.hintSide; phase = s.phase; drift = s.drift > 0f
}
}
/** Ollie's hints in words (Blaze's in the bonus round). */
internal fun hintWords(hint: Int, side: Int): String? = when (hint) {
Hint.HELLO -> "Send each signal\nto its screen!"
Hint.STATIC -> "Static next!\nPress OK to bin it."
Hint.NEARLY -> "${Chan.names[side]}'s nearly\njammed. Careful!"
Hint.JAMMED -> "${Chan.names[side]} is jammed!\nKeep the rest going."
Hint.BONUS -> "Bonus round! No static,\njust points. Go go go!"
Hint.MIXED -> "Drift's muddled one:\neither screen works!"
Hint.POWER -> "A power-up! Send it\nanywhere to catch it."
else -> null
}
/** What a run reports when it ends. */
internal fun chaosRunEnd(s: ChaosSim, finished: Boolean) = RunEnd(s.score, finished, "Stage ${s.stage}")
/**
* Channel Chaos (Arcade prototype, 8 November 2026): Stage B frames 30-33 with Paul's cast and curve. Ollie keeps the
* broadcast running, Blaze hosts the bonus rounds, Drift delivers muddled signals, Bumble repairs a jammed screen.
*/
@Composable
internal fun ChannelChaosScreen(play: ArcadePlay) {
val game = ArcadeGames.ChannelChaos
val latestPlay by rememberUpdatedState(play)
val calm = Motion.reduce
val sim = remember { ChaosSim(play.difficulty, seed = 1) }
val hud = remember { ChaosHud() }
val stepper = remember { FixedStep() }
val guard = remember { RepeatGuard(setOf(ArcadeKey.Ok, ArcadeKey.Up, ArcadeKey.Down, ArcadeKey.Left, ArcadeKey.Right)) }
var stage by remember { mutableStateOf(Stage.Title) }
var paused by remember { mutableStateOf(false) }
var howTo by remember { mutableStateOf(false) }
var soundsOn by remember { mutableStateOf(play.setting("sounds")) }
var bestBefore by remember { mutableIntStateOf(play.best) }
var bestSeen by remember { mutableIntStateOf(play.best) }
var bestStage by remember { mutableIntStateOf(play.level["bestStage"]?.toIntOrNull() ?: 0) }
val tracker = remember { RunTracker { end -> bestSeen = maxOf(bestSeen, end.score); latestPlay.onRunEnd(end) } }
fun endRun(finished: Boolean) {
if (!tracker.open) return
if (sim.stage > bestStage) { bestStage = sim.stage; latestPlay.setLevel("bestStage", sim.stage.toString()) }
tracker.end(chaosRunEnd(sim, finished))
}
DisposableEffect(Unit) { onDispose { endRun(false) } }
val density = LocalDensity.current
val measurer = rememberTextMeasurer()
val art = remember(density) { ChaosArt(density, measurer) }
val logo = ImageBitmapCache.orbitLogo()
LaunchedEffect(Unit) { play.audio.preload(R.raw.power_drift_net, R.raw.power_wide_orbit) }
fun startRun() {
bestBefore = maxOf(latestPlay.best, bestSeen)
sim.calm = Motion.reduce
sim.newRun(latestPlay.difficulty, (System.nanoTime() and 0x7fffffff).toInt().coerceAtLeast(1))
guard.reset(); stepper.reset(); hud.read(sim)
tracker.begin()
paused = false; stage = Stage.Play
}
fun pause() { if (stage == Stage.Play && !paused) { paused = true; guard.reset(); stepper.reset(); latestPlay.audio.pauseAll() } }
fun resume() { paused = false; guard.reset(); stepper.reset(); latestPlay.audio.resumeAll() }
fun leave() { endRun(sim.over); latestPlay.onLeave() }
PauseWhenHidden(alive = stage == Stage.Play && !paused) { pause() }
ArcadeGameLoop(running = stage == Stage.Play && !paused) { _, dt ->
val n = stepper.ticks(dt, paused)
for (i in 0 until n) sim.step()
val ev = sim.takeEvents()
if (ev != 0) {
val audio = latestPlay.audio
if (ev and (ChaosEvents.POWER or ChaosEvents.BONUS) != 0) audio.cue(R.raw.power_drift_net, .6f, soundsOn)
if (ev and (ChaosEvents.STAGE or ChaosEvents.REPAIRED) != 0) audio.cue(R.raw.power_wide_orbit, .6f, soundsOn)
}
hud.read(sim)
if (sim.over) { endRun(true); stage = Stage.Result }
}
val playFocus = remember { FocusRequester() }
LaunchedEffect(stage, paused) { if (stage == Stage.Play && !paused) runCatching { playFocus.requestFocus() } }
BackHandler(enabled = stage == Stage.Play && !paused) { pause() }
when (stage) {
Stage.Title -> {
ChaosTitle(art, play.best, bestStage, play.difficulty.title, refocus = !howTo, onPlay = ::startRun, onHowTo = { howTo = true }, onBack = { latestPlay.onLeave() })
if (howTo) HowToPlayCard(game, firstRun = false, everyTime = null, onEveryTime = {}, onPlay = { howTo = false }, onBack = { howTo = false })
}
Stage.Play, Stage.Result -> {
Box(Modifier.fillMaxSize().focusRequester(playFocus).focusable().onPreviewKeyEvent { e ->
if (stage != Stage.Play || paused) return@onPreviewKeyEvent false
val n = e.nativeKeyEvent
val key = arcadeKey(n.keyCode)
val down = n.action == KeyEvent.ACTION_DOWN
// Back pauses, caught here (on the TV, Compose spends a Back moving focus, so a BackHandler alone misses it).
if (key == ArcadeKey.Back || key == ArcadeKey.PlayPause) { if (down && n.repeatCount == 0) pause(); return@onPreviewKeyEvent true }
if (key == ArcadeKey.Other || key == ArcadeKey.Menu) return@onPreviewKeyEvent false
// One press is one send: the remote's repeats of a held key never send again.
if (!guard.accept(key, down, n.repeatCount)) return@onPreviewKeyEvent true
when (key) {
ArcadeKey.Ok -> sim.ok()
ArcadeKey.Up -> sim.send(Chan.UP)
ArcadeKey.Left -> sim.send(Chan.LEFT)
ArcadeKey.Right -> sim.send(Chan.RIGHT)
ArcadeKey.Down -> sim.send(Chan.DOWN)
else -> {}
}
hud.read(sim)
true
}) {
ChaosPlay(art, logo, sim, hud, calm, play.reduceFlashing)
if (hud.phase == Phase.Interlude && stage == Stage.Play) InterludeCard(art, sim.interlude, sim.repaired)
if (stage == Stage.Result) ChaosResult(art, sim, bestBefore, onRetry = { endRun(sim.over); startRun() }, onBack = ::leave)
}
if (paused && stage == Stage.Play) ArcadePauseMenu(game, "Channel Chaos · Stage ${sim.stage} · ${"%,d".format(sim.score)}",
onResume = ::resume, onRestart = { endRun(false); startRun() }, onExit = ::leave,
sound = if (soundsOn) "Effects on" else "Effects off", onSound = { soundsOn = !soundsOn; latestPlay.setSetting("sounds", soundsOn) })
}
}
}
/** Orbit's own logo for the little ident: one small image (5 KB), loaded once. */
private object ImageBitmapCache {
@Composable
fun orbitLogo() = androidx.compose.ui.graphics.ImageBitmap.imageResource(R.drawable.orbit_logo)
}
// ---------- Title (frame 30) ----------
@Composable
private fun ChaosTitle(art: ChaosArt, best: Int, bestStage: Int, difficulty: String, refocus: Boolean, onPlay: () -> Unit, onHowTo: () -> Unit, onBack: () -> Unit) {
val play = remember { FocusRequester() }
LaunchedEffect(refocus) { if (refocus) runCatching { play.requestFocus() } }
Box(Modifier.fillMaxSize().onBackKey(action = onBack).background(ArcadeColours.Night)) {
BackHandler(onBack = onBack)
Column(Modifier.fillMaxSize().padding(start = 48.dp, end = 48.dp, top = 24.dp, bottom = 12.dp)) {
Row(Modifier.fillMaxWidth().weight(1f)) {
Column(Modifier.weight(1f)) {
Text("AN ORBIT ARCADE ORIGINAL", color = ArcadeColours.Muted, fontSize = 13.sp, letterSpacing = 5.sp)
// CHANNEL on a tilted test-card strip, CHAOS big with its letters knocked a little out of tune.
Box(Modifier.padding(top = 6.dp).rotate(-3f).background(androidx.compose.ui.graphics.Brush.horizontalGradient(
listOf(Color(0xFF35D6F2), Color(0xFFFF2EA6), Color(0xFF9BE564), Color(0xFFFFB52E), Color(0xFFA77BFF), Color(0xFFFF8A3D)))).padding(horizontal = 14.dp)) {
Text("CHANNEL", color = Color.White, fontFamily = Anton, fontSize = 34.sp, letterSpacing = 4.sp)
}
Row(Modifier.padding(top = 4.dp)) {
"CHAOS".forEachIndexed { i, ch ->
val dy = intArrayOf(0, 4, -3, 3, -1)[i]; val rot = floatArrayOf(-2f, 2f, -1f, 2f, -2f)[i]
Text(ch.toString(), Modifier.offset(y = dy.dp).rotate(rot).padding(end = 6.dp), color = Color(0xFFF5F7FF), fontFamily = Anton, fontSize = 86.sp,
style = TextStyle(shadow = Shadow(Color(0xFFFF4FA3), Offset(5f, 5f), 0f)))
}
}
}
Column(horizontalAlignment = Alignment.End) {
Row(verticalAlignment = Alignment.CenterVertically) {
Text("I'm your host!\nReady to tune in?", Modifier.background(ArcadeColours.Ink, RoundedCornerShape(12.dp)).padding(horizontal = 12.dp, vertical = 6.dp),
color = ArcadeColours.Night, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, textAlign = TextAlign.Center)
Canvas(Modifier.size(80.dp)) { drawImage(art.faces[Speaker.Ollie.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt())) }
}
Spacer(Modifier.height(16.dp))
Column(Modifier.width(210.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
ArcadeButton("Play", Modifier.fillMaxWidth().focusRequester(play), icon = "▶", primary = true, height = 34.dp, onClick = onPlay)
ArcadeButton("How to Play", Modifier.fillMaxWidth(), icon = "?", height = 34.dp, onClick = onHowTo)
ArcadeButton("Back to Arcade", Modifier.fillMaxWidth(), icon = "←", height = 34.dp, onClick = onBack)
}
}
}
// How it works, at a glance: the chute and its four screens in miniature.
Row(Modifier.fillMaxWidth().height(170.dp).background(ArcadeColours.PanelDeep.copy(alpha = .94f), RoundedCornerShape(11.dp))
.border(1.dp, ArcadeColours.Line, RoundedCornerShape(11.dp)).padding(14.dp), horizontalArrangement = Arrangement.spacedBy(24.dp)) {
Canvas(Modifier.width(220.dp).fillMaxHeight()) {
val k = size.height / 300f
scale(k, k, Offset.Zero) {
translate(110f / k - 60f, 0f) {
with(art) {
for (side in 0 until Chan.SCREENS) {
val dx = floatArrayOf(0f, -100f, 100f, 0f)[side]; val dy = floatArrayOf(-100f, 0f, 0f, 100f)[side]
drawRoundRect(ChaosColours.TvBody, Offset(60f + dx - 50f, 150f + dy - 32f), androidx.compose.ui.geometry.Size(100f, 64f), androidx.compose.ui.geometry.CornerRadius(10f))
drawRoundRect(ChaosColours.mixed(ChaosColours.channel[side]), Offset(60f + dx - 44f, 150f + dy - 26f), androidx.compose.ui.geometry.Size(88f, 52f), androidx.compose.ui.geometry.CornerRadius(7f))
symbol(side, Offset(60f + dx, 150f + dy), 18f)
}
drawCircle(ChaosColours.Chute, 34f, Offset(60f, 150f))
drawCircle(ChaosColours.channel[2], 20f, Offset(60f, 150f)); symbol(Chan.RIGHT, Offset(60f, 150f), 11f)
}
}
}
}
Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
Text("SEND EACH SIGNAL HOME", color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 24.sp)
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { KeyCap("◀▶▲▼"); Text("Send it to the screen", color = ArcadeColours.Ink, fontSize = 15.sp) }
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { KeyCap("OK"); Text("Bin the grey static", color = ArcadeColours.Ink, fontSize = 15.sp) }
Text("• Wrong screen? It gets static", color = ArcadeColours.Muted, fontSize = 14.sp)
Text("• Three jammed screens ends the run", color = ArcadeColours.Muted, fontSize = 14.sp)
}
}
Spacer(Modifier.height(10.dp))
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp)) {
Row { Text("Your best ", color = ArcadeColours.Muted, fontSize = 14.sp); Text(if (best > 0) "%,d".format(best) else "Not played yet", color = ArcadeColours.Ink, fontSize = 14.sp, fontWeight = FontWeight.Bold) }
Row { Text("Best stage ", color = ArcadeColours.Muted, fontSize = 14.sp); Text(if (bestStage > 0) "$bestStage" else "—", color = ArcadeColours.Ink, fontSize = 14.sp, fontWeight = FontWeight.Bold) }
Text(difficulty, Modifier.background(ArcadeColours.Cyan, RoundedCornerShape(10.dp)).padding(horizontal = 8.dp), color = ArcadeColours.Night, fontSize = 12.sp, fontWeight = FontWeight.Bold)
Text("🔒 No Household record: Channel Chaos is new since profiles", color = ArcadeColours.Muted, fontSize = 13.sp)
}
Spacer(Modifier.height(8.dp))
KeyFooter(listOf(Control("▲▼", "Choose"), Control("OK", "Select"), Control("Back", "Arcade home")))
}
}
}
// ---------- Play (frames 31 and 32) ----------
@Composable
private fun ChaosPlay(art: ChaosArt, logo: androidx.compose.ui.graphics.ImageBitmap, sim: ChaosSim, hud: ChaosHud, calm: Boolean, reduceFlashing: Boolean) {
val bonus = hud.bonusSecs > 0
Box(Modifier.fillMaxSize().background(ArcadeColours.Night)) {
Column(Modifier.fillMaxSize().padding(start = 40.dp, end = 40.dp, top = 22.dp, bottom = 10.dp)) {
Row(Modifier.fillMaxWidth().weight(1f)) {
// Left: score, chain, stage (or the bonus round's seconds), jammed screens; Ollie's hint below.
Column(Modifier.width(180.dp).fillMaxHeight(), verticalArrangement = Arrangement.spacedBy(2.dp)) {
HudLabel("SCORE")
Text("%,d".format(hud.score), color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 30.sp)
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
Text("×${hud.chain}", Modifier.background(ArcadeColours.Pink, RoundedCornerShape(12.dp)).padding(horizontal = 10.dp), color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 17.sp)
Text("chain", color = ArcadeColours.Muted, fontSize = 14.sp)
}
Spacer(Modifier.height(10.dp))
if (bonus) {
HudLabel("BONUS ROUND")
Text("${hud.bonusSecs} s", color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 30.sp)
Text("left to play", color = ArcadeColours.Muted, fontSize = 14.sp)
} else {
HudLabel("STAGE")
Text("${hud.stage}", color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 30.sp)
Spacer(Modifier.height(8.dp))
HudLabel("JAMMED")
Row(horizontalArrangement = Arrangement.spacedBy(5.dp)) {
for (i in 0 until 3) Box(Modifier.size(24.dp, 16.dp).background(if (i < hud.jammed) Color(0xFF3A1020) else Color(0xFF2A3558), RoundedCornerShape(4.dp))
.border(1.dp, if (i < hud.jammed) ChaosColours.Red else ChaosColours.TvEdge, RoundedCornerShape(4.dp)))
}
Text("${hud.jammed} of 3 screens", color = ArcadeColours.Muted, fontSize = 14.sp)
}
Spacer(Modifier.weight(1f))
// Ollie keeps the broadcast running (Blaze hosts the bonus round, happy-eyed).
val words = if (hud.phase == Phase.Reward) Interludes.BACK_ON_AIR else hintWords(hud.hint, hud.hintSide)
if (words != null) Text(words, Modifier.background(ArcadeColours.Ink, RoundedCornerShape(12.dp)).padding(horizontal = 10.dp, vertical = 6.dp),
color = ArcadeColours.Night, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, textAlign = TextAlign.Center)
Canvas(Modifier.size(64.dp)) {
val who = if (bonus) Speaker.Blaze else Speaker.Ollie
drawImage(art.faces[who.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt()))
}
}
// The field: the four screens and the chute, in the frame's own units.
Canvas(Modifier.weight(1f).fillMaxHeight()) {
hud.frame // redraw every frame, without recomposing
val k = minOf(size.width / 1100f, size.height / 890f)
val ox = (size.width - 1100f * k) / 2; val oy = (size.height - 890f * k) / 2
val t = sim.clock
translate(ox, oy) {
scale(k, k, Offset.Zero) {
translate(-410f, -40f) {
with(art) {
val tuned = sim.phase == Phase.Reward || sim.phase == Phase.Interlude
for (side in 0 until Chan.SCREENS) screen(sim, side, t, calm, tuned)
if (sim.phase == Phase.Reward) ident(logo, sim.phaseT, calm || reduceFlashing) else chute(sim, t, calm, reduceFlashing)
}
}
}
}
}
// Right: the power-up on now, and Drift when he drifts past with his muddled signal.
Column(Modifier.width(170.dp).fillMaxHeight(), horizontalAlignment = Alignment.End, verticalArrangement = Arrangement.spacedBy(4.dp)) {
HudLabel("POWER-UP")
val p = hud.power ?: if (hud.autoLeft > 0) ChaosPower.AutoTune else null
Canvas(Modifier.size(56.dp)) {
hud.frame
val now = sim.timedPower
with(art) { if (p != null) badge(p, center, size.minDimension * .3f) }
if (now != null) drawArc(ChaosColours.power.getValue(now), -90f, 360f * (sim.powerLeft / now.seconds).coerceIn(0f, 1f), false,
Offset(4f, 4f), androidx.compose.ui.geometry.Size(size.width - 8f, size.height - 8f), style = androidx.compose.ui.graphics.drawscope.Stroke(3.dp.toPx()))
}
if (p != null) {
Text(p.title, color = ArcadeColours.Ink, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, textAlign = TextAlign.End)
Text(if (p == ChaosPower.AutoTune) "${hud.autoLeft} to go" else "${hud.powerSecs} s left", color = ChaosColours.power.getValue(p), fontSize = 13.sp)
} else Text("None yet", color = ArcadeColours.Muted, fontSize = 13.sp)
if (hud.drift) {
Spacer(Modifier.height(18.dp))
Canvas(Modifier.size(70.dp)) { drawImage(art.faces[Speaker.Drift.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt())) }
Text("Drift's about…", color = ArcadeColours.Muted, fontSize = 13.sp)
}
}
}
Spacer(Modifier.height(6.dp))
KeyFooter(if (bonus) listOf(Control("◀▶▲▼", "Send to that screen"), Control("Back", "Pause"))
else listOf(Control("◀▶▲▼", "Send to that screen"), Control("OK", "Bin static"), Control("Back", "Pause")),
note = if (bonus) "No static drops in the bonus round" else null)
}
}
}
@Composable
private fun HudLabel(text: String) = Text(text, color = ArcadeColours.Muted, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 2.sp)
// ---------- Between rounds ----------
/** One of the cast's interruptions: a face and a caption (only Ollie has a mouth), shown still, waiting for OK. */
@Composable
private fun InterludeCard(art: ChaosArt, line: Interludes.Line, repaired: Int) {
Box(Modifier.fillMaxSize().background(ArcadeColours.Night.copy(alpha = .6f)), contentAlignment = Alignment.Center) {
Row(Modifier.background(ArcadeColours.PanelDeep, RoundedCornerShape(16.dp)).border(1.dp, ArcadeColours.Line, RoundedCornerShape(16.dp)).padding(22.dp),
verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(18.dp)) {
Canvas(Modifier.size(110.dp)) { drawImage(art.faces[line.who.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt())) }
Column(Modifier.widthIn(max = 420.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text(line.who.name.uppercase(), color = ArcadeColours.Muted, fontSize = 13.sp, letterSpacing = 3.sp)
Text(line.text, Modifier.background(ArcadeColours.Ink, RoundedCornerShape(12.dp)).padding(horizontal = 14.dp, vertical = 10.dp),
color = ArcadeColours.Night, fontSize = 20.sp, fontWeight = FontWeight.SemiBold)
if (repaired >= 0) Text("${Chan.names[repaired]} is back on air.", color = ArcadeColours.Green, fontSize = 15.sp)
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { KeyCap("OK"); Text("Continue", color = ArcadeColours.Ink, fontSize = 15.sp) }
}
}
}
}
// ---------- Result (frame 33) ----------
@Composable
private fun ChaosResult(art: ChaosArt, sim: ChaosSim, bestBefore: Int, onRetry: () -> Unit, onBack: () -> Unit) {
val first = remember { FocusRequester() }
LaunchedEffect(Unit) { runCatching { first.requestFocus() } }
BackHandler(onBack = onBack)
val newBest = sim.score > bestBefore && sim.score > 0
Box(Modifier.fillMaxSize().onBackKey(action = onBack).background(ArcadeColours.Night.copy(alpha = .82f)), contentAlignment = Alignment.Center) {
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp)) {
Canvas(Modifier.size(110.dp)) { drawImage(art.faces[Speaker.Ollie.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt())) }
Column(Modifier.width(520.dp).background(ArcadeColours.PanelDeep, RoundedCornerShape(14.dp)).border(1.dp, ArcadeColours.Line, RoundedCornerShape(14.dp)).padding(20.dp),
horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(6.dp)) {
Text("CHANNEL CHAOS · STAGE ${sim.stage} REACHED", color = ArcadeColours.Muted, fontSize = 13.sp, letterSpacing = 3.sp)
if (newBest) Text("NEW BEST", Modifier.background(ArcadeColours.Pink, RoundedCornerShape(14.dp)).padding(horizontal = 14.dp, vertical = 2.dp), color = ArcadeColours.Ink, fontSize = 16.sp, fontWeight = FontWeight.Bold)
Text("SCORE", color = ArcadeColours.Muted, fontSize = 13.sp, letterSpacing = 2.sp)
Text("%,d".format(sim.score), color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 54.sp)
Text(if (bestBefore > 0) "Previous best ${"%,d".format(bestBefore)}" else "Your first Channel Chaos score", color = ArcadeColours.Ink, fontSize = 14.sp)
Text("Best chain ×${sim.bestChain} · ${sim.sent} signals sent · ${sim.binned} static binned", color = ArcadeColours.Muted, fontSize = 13.sp)
Spacer(Modifier.height(6.dp))
Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
ArcadeButton("Play Again", Modifier.width(160.dp).focusRequester(first), icon = "▶", primary = true, height = 34.dp, onClick = onRetry)
ArcadeButton("Back to Arcade", Modifier.width(200.dp), icon = "←", height = 34.dp, onClick = onBack)
}
}
Canvas(Modifier.size(110.dp)) { drawImage(art.faces[Speaker.Blaze.ordinal], IntOffset.Zero, art.faceSize, IntOffset.Zero, IntSize(size.width.toInt(), size.height.toInt())) }
}
KeyFooter(listOf(Control("◀▶", "Choose"), Control("OK", "Select"), Control("Back", "Arcade home")), Modifier.align(Alignment.BottomStart).padding(start = 24.dp, end = 24.dp, bottom = 10.dp))
}
}
@@ -0,0 +1,268 @@
package tv.orbit.classic.arcade.chaos
import androidx.compose.ui.geometry.CornerRadius
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.PathEffect
import androidx.compose.ui.graphics.StrokeCap
import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
import androidx.compose.ui.graphics.drawscope.DrawScope
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.graphics.drawscope.scale
import androidx.compose.ui.graphics.drawscope.translate
import androidx.compose.ui.text.TextLayoutResult
import androidx.compose.ui.text.TextMeasurer
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.drawText
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.IntSize
import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.sp
import tv.orbit.classic.OrbCharacter
import tv.orbit.classic.OrbDir
import tv.orbit.classic.arcade.hexPath
import tv.orbit.classic.drawOrbBee
import tv.orbit.classic.drawOrbChaser
import tv.orbit.classic.drawOrbMascot
import tv.orbit.classic.starPath
import kotlin.math.PI
import kotlin.math.cos
import kotlin.math.sin
/** Channel identity by colour AND symbol (Stage B): Orbit 1 is a cyan star, so it can't be mixed up with Tots' amber sun. */
internal object ChaosColours {
val channel = arrayOf(Color(0xFF35D6F2), Color(0xFFFF2EA6), Color(0xFF9BE564), Color(0xFFFFB52E))
val TvBody = Color(0xFF2A3558)
val TvEdge = Color(0xFF7FB2FF)
val Plate = Color(0xFF0C1F4A)
val Line = Color(0xFF3D63B8)
val Chute = Color(0xFF1E3E7A)
val Static = Color(0xFFB9C2D6)
val Red = Color(0xFFFF6B6B)
val Navy = Color(0xFF14213D)
val Ink = Color(0xFFF4F6FB)
val power = mapOf(ChaosPower.Freeze to Color(0xFF8FE3FF), ChaosPower.AutoTune to Color(0xFF2BB3A8), ChaosPower.Sweep to Color(0xFF9BE564),
ChaosPower.DoublePoints to Color(0xFFE85DFF), ChaosPower.Reception to Color(0xFF4F8BFF))
fun mixed(c: Color) = c.copy(alpha = .42f)
}
/** The cast, drawn once into small bitmaps from the cast library (it builds little lists as it draws). Only Ollie has a mouth. */
internal fun castFace(who: Speaker, px: Int, density: Density, happy: Boolean = false): ImageBitmap {
val image = ImageBitmap(px, px)
CanvasDrawScope().draw(density, LayoutDirection.Ltr, androidx.compose.ui.graphics.Canvas(image), Size(px.toFloat(), px.toFloat())) {
val c = Offset(px / 2f, px / 2f); val r = px * .32f
when (who) {
Speaker.Ollie -> drawOrbMascot(c, r, OrbDir.Right)
Speaker.Blaze -> drawOrbChaser(c, r * 1.1f, OrbCharacter.Blaze, OrbDir.Up, false, false, false, 0f, lookAt = if (happy) Offset(0f, -1f) else Offset(.4f, -.6f))
Speaker.Drift -> drawOrbChaser(c, r * 1.1f, OrbCharacter.Drift, OrbDir.Left, false, false, false, .3f, lookAt = Offset(-.6f, .4f))
Speaker.Bumble -> drawOrbBee(c, r)
}
}
return image
}
/**
* The play field's drawing, in the Stage B frame's own units (the 1920×1080 frame, cropped to the screens and chute:
* x 410-1510, y 40-930). Paths, noise and names are made once; a frame draws without allocating.
*/
internal class ChaosArt(density: Density, measurer: TextMeasurer) {
val faces = Speaker.entries.map { castFace(it, 128, density) }.toTypedArray()
val faceSize = IntSize(128, 128)
private val names: Array<TextLayoutResult> = Chan.names.map { measurer.measure(it, TextStyle(fontSize = 28.sp, fontWeight = FontWeight.SemiBold), density = density) }.toTypedArray()
private val nameScale = 28f / names[0].size.height.coerceAtLeast(1) * 1.2f
private val jammedWord = measurer.measure("JAMMED", TextStyle(fontSize = 28.sp, fontWeight = FontWeight.Bold), density = density)
private val five = measurer.measure("×5", TextStyle(fontSize = 28.sp, fontWeight = FontWeight.SemiBold), density = density)
private val arrows = arrayOf("▲", "◀", "▶", "▼").map { measurer.measure(it, TextStyle(fontSize = 20.sp, fontWeight = FontWeight.Bold), density = density) }.toTypedArray()
// Symbols at unit size (about 2 across), scaled where they're drawn.
private val star = starPath(Offset.Zero, 1f, .45f, 0f)
private val bolt = Path().apply { moveTo(.25f, -1f); lineTo(-.55f, .12f); lineTo(-.02f, .12f); lineTo(-.3f, 1f); lineTo(.58f, -.18f); lineTo(.06f, -.18f); close() }
private val leaf = Path().apply { moveTo(-.8f, .8f); cubicTo(-.9f, -.3f, -.1f, -.95f, .9f, -.9f); cubicTo(.95f, .1f, .3f, .9f, -.8f, .8f); close() }
private val hex = hexPath(Offset.Zero, 1f)
private val spiral = Path().apply {
for (i in 0 until 36) {
val a = (200 + i * 9) * PI / 180; val r = 138 - i * 2.2
val x = (cos(a) * r).toFloat(); val y = (sin(a) * r).toFloat()
if (i == 0) moveTo(x, y) else lineTo(x, y)
}
}
private val dashes = Stroke(3f, pathEffect = PathEffect.dashPathEffect(floatArrayOf(4f, 10f)))
private val thin = Stroke(2f)
private val ring = Stroke(5f, cap = StrokeCap.Round)
private val rays = Stroke(.16f, cap = StrokeCap.Round)
private val leafVein = Stroke(.12f, cap = StrokeCap.Round)
/** TV static: 140 specks per screen, in unit coordinates, picked once. */
private val noise = FloatArray(140 * 3).also { a -> val r = java.util.Random(7); for (i in 0 until 140) { a[i * 3] = r.nextFloat(); a[i * 3 + 1] = r.nextFloat(); a[i * 3 + 2] = r.nextFloat() } }
private val shades = arrayOf(Color(0xFFFFFFFF), Color(0xFFC9D2E6), Color(0xFF8D99B6), Color(0xFF5E6A85))
/** Where the screens sit in the frame: the centre x and top of each TV (Stage B frame 31). */
val tvX = floatArrayOf(960f, 560f, 1360f, 960f)
val tvTop = floatArrayOf(80f, 395f, 395f, 702f)
val chuteX = 960f
val chuteY = 500f
// ---------- symbols, signals ----------
fun DrawScope.symbol(side: Int, c: Offset, s: Float, colour: Color = Color.White) {
translate(c.x, c.y) {
scale(s, s, Offset.Zero) {
when (side) {
Chan.UP -> drawPath(star, colour)
Chan.LEFT -> drawPath(bolt, colour)
Chan.RIGHT -> { drawPath(leaf, colour); drawLine(Color(0x8C1C6B46), Offset(-.8f, .8f), Offset(.45f, -.45f), .12f, StrokeCap.Round) }
else -> {
for (k in 0 until 8) { val a = k * PI.toFloat() / 4; drawLine(colour, Offset(cos(a) * .62f, sin(a) * .62f), Offset(cos(a) * .98f, sin(a) * .98f), .16f, StrokeCap.Round) }
drawCircle(colour, .46f, Offset.Zero)
}
}
}
}
}
/** A signal: its channel's colour and symbol; static is a grey fuzz with eyes; a power-up rides in its hexagon. */
fun DrawScope.signal(sim: ChaosSim, i: Int, c: Offset, r: Float, alpha: Float, bonus: Boolean) {
when (val k = sim.kind[i]) {
Chan.STATIC -> staticSprite(c, r, alpha)
Chan.POWER -> { val p = sim.power[i]; if (p != null) badge(p, c, r * .9f, alpha) }
Chan.MIXED -> {
val a = ChaosColours.channel[sim.mixA[i]]; val b = ChaosColours.channel[sim.mixB[i]]
drawCircle(a, r * 1.25f, c, alpha = .16f * alpha)
drawArc(a, 90f, 180f, true, Offset(c.x - r, c.y - r), Size(r * 2, r * 2), alpha = alpha)
drawArc(b, 270f, 180f, true, Offset(c.x - r, c.y - r), Size(r * 2, r * 2), alpha = alpha)
symbol(sim.mixA[i], Offset(c.x - r * .42f, c.y), r * .32f)
symbol(sim.mixB[i], Offset(c.x + r * .42f, c.y), r * .32f)
drawCircle(Color.White, r * 1.16f, c, alpha = .8f * alpha, style = dashes)
}
else -> {
val col = ChaosColours.channel[k]
drawCircle(col, r * 1.25f, c, alpha = .16f * alpha)
drawCircle(col, r, c, alpha = alpha)
drawCircle(Color.White, r * .3f, Offset(c.x - r * .3f, c.y - r * .35f), alpha = .25f * alpha)
symbol(k, Offset(c.x, c.y + r * .04f), r * .56f)
if (bonus) drawCircle(Color.White, r * 1.16f, c, alpha = .8f * alpha, style = dashes)
}
}
}
fun DrawScope.staticSprite(c: Offset, r: Float, alpha: Float = 1f) {
drawCircle(ChaosColours.Static, r, c, alpha = alpha)
for (k in 0 until 8) { val a = k * .785f; drawCircle(Color(0xFF8D99B6), r * .22f, Offset(c.x + cos(a) * r * .9f, c.y + sin(a) * r * .9f), alpha = alpha) }
drawCircle(Color.White, r * .22f, Offset(c.x - r * .3f, c.y - r * .1f), alpha = alpha); drawCircle(Color.White, r * .22f, Offset(c.x + r * .3f, c.y - r * .1f), alpha = alpha)
drawCircle(ChaosColours.Navy, r * .11f, Offset(c.x - r * .28f, c.y - r * .08f), alpha = alpha); drawCircle(ChaosColours.Navy, r * .11f, Offset(c.x + r * .32f, c.y - r * .08f), alpha = alpha)
}
/** A power-up badge in the hexagon family: its colour and its family's symbol. */
fun DrawScope.badge(p: ChaosPower, c: Offset, r: Float, alpha: Float = 1f) {
val col = ChaosColours.power.getValue(p)
translate(c.x, c.y) {
scale(r, r, Offset.Zero) {
drawPath(hex, col, alpha = alpha)
drawPath(hex, Color.White, alpha = .5f * alpha, style = Stroke(.08f))
val ink = ChaosColours.Navy
when (p) {
ChaosPower.Freeze -> { drawLine(ink, Offset(-.35f, -.5f), Offset(.35f, .5f), .12f); drawLine(ink, Offset(.35f, -.5f), Offset(-.35f, .5f), .12f); drawLine(ink, Offset(-.4f, -.5f), Offset(.4f, -.5f), .12f); drawLine(ink, Offset(-.4f, .5f), Offset(.4f, .5f), .12f) }
ChaosPower.AutoTune -> { drawArc(ink, 160f, 220f, false, Offset(-.45f, -.45f), Size(.9f, .9f), style = Stroke(.12f)); drawLine(ink, Offset.Zero, Offset(.25f, -.25f), .12f, StrokeCap.Round) }
ChaosPower.Sweep -> for (k in 0 until 8) { val a = k * .785f; drawLine(ink, Offset(cos(a) * .2f, sin(a) * .2f), Offset(cos(a) * .55f, sin(a) * .55f), .1f, StrokeCap.Round) }
ChaosPower.DoublePoints -> { translate(-.18f, -.1f) { scale(.32f, .32f, Offset.Zero) { drawPath(star, Color.White) } }; translate(.2f, .14f) { scale(.26f, .26f, Offset.Zero) { drawPath(star, Color.White) } } }
ChaosPower.Reception -> drawPath(hex, Color.White, alpha = .9f, style = Stroke(.1f))
}
}
}
}
// ---------- the screens ----------
/** One channel's screen and its name plate with the interference meter. Jammed: thick static and JAMMED. */
fun DrawScope.screen(sim: ChaosSim, side: Int, time: Float, calm: Boolean, tuned: Boolean) {
val cx = tvX[side]; val top = tvTop[side]; val x = cx - 150f
val col = ChaosColours.channel[side]
val bonus = sim.bonus > 0f
if (side != Chan.DOWN) {
drawLine(Color(0xFFAEBBD2), Offset(cx - 16f, top), Offset(cx - 34f, top - 22f), 4f, StrokeCap.Round)
drawLine(Color(0xFFAEBBD2), Offset(cx + 16f, top), Offset(cx + 34f, top - 22f), 4f, StrokeCap.Round)
}
if (bonus || tuned) drawRoundRect(col, Offset(x - 14f, top - 14f), Size(328f, 178f), CornerRadius(30f), alpha = .22f)
drawRoundRect(ChaosColours.TvBody, Offset(x, top), Size(300f, 150f), CornerRadius(20f))
drawRoundRect(ChaosColours.TvEdge, Offset(x, top), Size(300f, 150f), CornerRadius(20f), style = thin)
drawRoundRect(if (sim.jammed[side] && !tuned) Color(0xFF2B2F3D) else ChaosColours.mixed(col), Offset(x + 10f, top + 10f), Size(280f, 130f), CornerRadius(12f))
if (!sim.jammed[side] || tuned) {
drawCircle(col, 52f, Offset(cx, top + 75f), alpha = .5f)
symbol(side, Offset(cx, top + 75f), 40f)
}
// Interference: specks across the screen, more as the meter rises; they shimmer (still under Reduce motion).
val level = if (tuned) 0f else if (sim.jammed[side]) 1f else sim.meter[side]
val n = (level * 140).toInt()
val shift = if (calm) 0f else (time * 9f) % 1f
for (i in 0 until n) {
val ux = (noise[i * 3] + shift * (i % 3) * .37f) % 1f
drawRect(shades[i % 4], Offset(x + 12f + ux * 268f, top + 12f + noise[i * 3 + 1] * 120f), Size(7f, 4.2f), alpha = .55f + noise[i * 3 + 2] * .4f)
}
for (k in 0 until 18) drawRect(Color.White, Offset(x + 10f, top + 10f + k * 7f), Size(280f, 2f), alpha = .05f)
if (sim.jammed[side] && !tuned) translate(cx - jammedWord.size.width * nameScale / 2, top + 50f) { scale(nameScale, nameScale, Offset.Zero) { drawText(jammedWord, ChaosColours.Red) } }
// The name plate.
val py = top + 158f
drawRoundRect(ChaosColours.Plate, Offset(x, py), Size(300f, 56f), CornerRadius(14f))
drawRoundRect(ChaosColours.Line, Offset(x, py), Size(300f, 56f), CornerRadius(14f), style = thin)
translate(x + 22f, py + 10f) { scale(nameScale, nameScale, Offset.Zero) { drawText(names[side], ChaosColours.Ink) } }
if (bonus) translate(x + 300f - 22f - five.size.width * nameScale, py + 10f) { scale(nameScale, nameScale, Offset.Zero) { drawText(five, col) } }
else {
val mx = x + 168f; val mw = 110f
drawRoundRect(Color(0xFF081A3C), Offset(mx, py + 20f), Size(mw, 16f), CornerRadius(8f))
drawRoundRect(Color(0xFF2A4A80), Offset(mx, py + 20f), Size(mw, 16f), CornerRadius(8f), style = Stroke(1.5f))
val m = if (sim.jammed[side]) 1f else sim.meter[side]
if (m > 0f) drawRoundRect(if (m >= .6f) ChaosColours.Red else Color(0xFF9FAAC4), Offset(mx + 2f, py + 22f), Size((mw - 4f) * m, 12f), CornerRadius(6f))
}
}
// ---------- the chute ----------
fun DrawScope.chute(sim: ChaosSim, time: Float, calm: Boolean, reduceFlashing: Boolean) {
val c = Offset(chuteX, chuteY)
drawCircle(ChaosColours.Chute, 138f, c, alpha = .6f); drawCircle(ChaosColours.TvEdge, 138f, c, alpha = .25f, style = Stroke(3f))
drawCircle(ChaosColours.Chute, 108f, c, alpha = .66f); drawCircle(ChaosColours.TvEdge, 108f, c, alpha = .4f, style = Stroke(3f))
drawCircle(ChaosColours.Chute, 78f, c, alpha = .74f); drawCircle(ChaosColours.TvEdge, 78f, c, alpha = .55f, style = Stroke(3f))
translate(c.x, c.y) { drawPath(spiral, if (sim.bonus > 0f) Color.White else ChaosColours.channel[0], alpha = .35f, style = dashes) }
val bonus = sim.bonus > 0f
// The next two, spiralling in.
signal(sim, 2, Offset(c.x - 150f, c.y - 150f), 20f, .6f, bonus)
signal(sim, 1, Offset(c.x - 98f, c.y - 82f), 30f, 1f, bonus)
drawCircle(Color(0xFF081A3C), 62f, c); drawCircle(Color.White, 62f, c, alpha = .4f, style = Stroke(3f))
// The time left for the middle signal, as a ring round it (none on Gentle's untimed stages).
if (sim.timed && sim.phase == Phase.Playing) {
val f = (sim.left / sim.leftTotal).coerceIn(0f, 1f)
drawArc(if (f < .3f) ChaosColours.Red else Color.White, -90f, 360f * f, false, Offset(c.x - 70f, c.y - 70f), Size(140f, 140f), alpha = .8f, style = ring)
}
if (sim.phase == Phase.Playing) signal(sim, 0, c, 44f, 1f, bonus)
// Where the last one went: a soft line to that screen, green or red. A steady line with Reduce flashing on.
if (sim.lastSide >= 0 && sim.lastT < .35f) {
val a = if (reduceFlashing || calm) .5f else 1f - sim.lastT / .35f
val to = Offset(tvX[sim.lastSide], tvTop[sim.lastSide] + 75f)
drawLine(if (sim.lastGood) Color(0xFF6EDCAA) else ChaosColours.Red, c, to, 6f, StrokeCap.Round, alpha = a * .6f)
}
// The arrow chips between the chute and each screen.
chip(0, Offset(960f, 330f)); chip(3, Offset(960f, 672f)); chip(1, Offset(764f, 500f)); chip(2, Offset(1156f, 500f))
}
private fun DrawScope.chip(i: Int, c: Offset) {
drawRoundRect(Color(0xFF13306B), Offset(c.x - 24f, c.y - 21f), Size(48f, 42f), CornerRadius(8f))
drawRoundRect(ChaosColours.TvEdge, Offset(c.x - 24f, c.y - 21f), Size(48f, 42f), CornerRadius(8f), style = thin)
val t = arrows[i]; val k = 1.3f
translate(c.x - t.size.width * k / 2, c.y - t.size.height * k / 2) { scale(k, k, Offset.Zero) { drawText(t, ChaosColours.Ink) } }
}
/** The reward: every screen on its own channel, and the little Orbit ident in the chute. */
fun DrawScope.ident(logo: ImageBitmap, t: Float, calm: Boolean) {
val c = Offset(chuteX, chuteY)
val grow = if (calm) 1f else (t / .6f).coerceIn(0f, 1f)
drawCircle(Color(0xFF081A3C), 140f, c)
drawCircle(ChaosColours.channel[0], 140f, c, alpha = .35f, style = Stroke(4f))
val w = 220f * (.6f + .4f * grow); val h = w * logo.height / logo.width.coerceAtLeast(1)
drawImage(logo, IntOffset.Zero, IntSize(logo.width, logo.height), IntOffset((c.x - w / 2).toInt(), (c.y - h / 2).toInt()), IntSize(w.toInt(), h.toInt()), alpha = .4f + .6f * grow)
}
}
@@ -0,0 +1,433 @@
package tv.orbit.classic.arcade.chaos
import tv.orbit.classic.arcade.Difficulty
import tv.orbit.classic.arcade.raiders.SeededRandom
/**
* Channel Chaos (Arcade prototype, 8 November 2026), from the approved Stage B frames 30-33 and Paul's notes: signals drop
* into the tuning chute and the remote sends each to its channel's screen. ▲ Orbit 1 (cyan star), ◀ Riot (pink bolt),
* ▶ Terra (green leaf), ▼ Tots (amber sun). OK bins grey static. A wrong screen, static sent to a screen, or a signal left
* too long puts interference on a screen; a full meter jams it, and three jammed screens end the run.
*
* "Increasingly chaotic without becoming frustrating" (Paul): one new thing a stage. Stage 1 plain signals, slowly; stage 2
* static; stage 3 power-ups; from stage 4 Drift's muddled deliveries. Every third stage ends in Blaze's bonus round. On
* Gentle the first two stages have no timer at all.
*
* Between rounds: the four screens tune in, a little Orbit ident, "And we're back on air!" ([Phase.Reward]), then one of the
* cast's interruptions ([Phase.Interlude]), which waits for OK. Pure rules, seeded, fixed 60 Hz step, no allocation in play.
*/
internal object Chan {
const val UP = 0 // Orbit 1
const val LEFT = 1 // Riot
const val RIGHT = 2 // Terra
const val DOWN = 3 // Tots
const val SCREENS = 4
const val STATIC = 4
/** A power-up badge riding the chute: any direction or OK collects it. */
const val POWER = 5
/** Drift's muddled delivery: two channels at once, and either of their screens takes it (for double points). */
const val MIXED = 6
val names = arrayOf("Orbit 1", "Riot", "Terra", "Tots")
}
/** Channel Chaos's power-ups (Stage B power-up family sheet). One timed at a time; a new one replaces it. */
internal enum class ChaosPower(val title: String, val line: String, val seconds: Float, val weight: Int) {
Freeze("Channel Freeze", "Signals stop falling", 8f, 20),
AutoTune("Auto Tune", "Next 5 signals send themselves", 0f, 18),
Sweep("Signal Sweep", "Clears static from the chute and screens", 0f, 22),
DoublePoints("Double Points", "Every match scores twice", 12f, 22),
Reception("Perfect Reception", "Wrong sends add no static", 10f, 18);
val timed get() = seconds > 0f
}
/** How hard the chute pushes (Arcade Settings › Difficulty; Kids start on Gentle). */
internal class ChaosTuning(val time: Float, val static: Float, val hurt: Float, val untimedStages: Int) {
companion object {
/** Gentle: "give players time to think": no timer for the first two stages, then half again as long. */
val Gentle = ChaosTuning(1.6f, .6f, .6f, 2)
val Normal = ChaosTuning(1f, 1f, 1f, 0)
val Tricky = ChaosTuning(.78f, 1.3f, 1.2f, 0)
fun of(d: Difficulty) = when (d) { Difficulty.Gentle -> Gentle; Difficulty.Normal -> Normal; Difficulty.Tricky -> Tricky }
}
}
/** What happened this tick, for sounds; read and cleared by the screen. */
internal object ChaosEvents {
const val MATCH = 1
const val WRONG = 2
const val BIN = 4
const val MISSED = 8
const val JAMMED = 16
const val STAGE = 32
const val BONUS = 64
const val POWER = 128
const val OVER = 256
const val REPAIRED = 512
}
/** Ollie's hints during play (Blaze's in the bonus round), as numbers; the screen has the words. */
internal object Hint {
const val NONE = 0
const val HELLO = 1
const val STATIC = 2
const val NEARLY = 3 // a screen is nearly jammed: hintSide says which
const val JAMMED = 4
const val BONUS = 6
const val MIXED = 7
const val POWER = 8
}
/** Who's speaking in an interruption between rounds. Only Ollie has a mouth; the others speak in captions. */
internal enum class Speaker { Ollie, Blaze, Drift, Bumble }
/** The interruptions between rounds. Paul's two are as he wrote them; the rest are in the same spirit. */
internal object Interludes {
class Line(val who: Speaker, val text: String)
val FASTER = Line(Speaker.Blaze, "FASTER! WE'RE LOSING VIEWERS!")
val SUPPOSED = Line(Speaker.Drift, "Oh. Was that supposed to go somewhere?")
val ALL = arrayOf(
FASTER,
SUPPOSED,
Line(Speaker.Blaze, "Bigger! Louder! MORE CHANNELS!"),
Line(Speaker.Drift, "I found this signal under a cloud. Is it yours?"),
Line(Speaker.Blaze, "Nobody blink. The ratings are watching."),
Line(Speaker.Drift, "I sent one to the moon. It seemed happy there."),
Line(Speaker.Ollie, "Steady hands. The viewers are with us."),
)
/** Before Blaze's bonus round, always his. */
val BONUS = Line(Speaker.Blaze, "Bonus round! No static, just points. Go go go!")
/** When Bumble rushes in to repair a jammed screen. */
val REPAIR = Line(Speaker.Bumble, "Hold still, transmitter! Bumble's on it!")
/** The level-complete reward's last word. */
const val BACK_ON_AIR = "And we're back on air!"
}
/** Where a run stands. */
internal enum class Phase { Playing, Reward, Interlude, Over }
internal class ChaosSim(difficulty: Difficulty = Difficulty.Normal, var seed: Int = 1) {
var difficulty = difficulty; private set
var tuning = ChaosTuning.of(difficulty); private set
private val rng = SeededRandom(seed)
/** Reduce motion: the reward holds still (the screens show their channels at once) and nothing slides in. */
var calm = false
// ---------- the chute: the middle signal and the next two ----------
val kind = IntArray(3)
/** A MIXED signal's two channels. */
val mixA = IntArray(3)
val mixB = IntArray(3)
val power = arrayOfNulls<ChaosPower>(3)
/** Seconds before the middle signal falls out unsent ([timed] false: no timer, Gentle's first stages). */
var left = 0f; private set
var leftTotal = 1f; private set
val timed get() = stage > tuning.untimedStages || bonus > 0f
// ---------- the screens ----------
val meter = FloatArray(Chan.SCREENS)
val jammed = BooleanArray(Chan.SCREENS)
var lastSide = -1; private set
var lastGood = false; private set
var lastT = 9f; private set
// ---------- the run ----------
var phase = Phase.Playing; private set
var phaseT = 0f; private set
var score = 0; private set
var streak = 0; private set
val chain get() = minOf(6, 1 + streak / 4)
var bestChain = 1; private set
var stage = 1; private set
var stageSent = 0; private set
var sent = 0; private set
var binned = 0; private set
val over get() = phase == Phase.Over
/** Blaze's bonus round: seconds left (0 when it isn't on). */
var bonus = 0f; private set
private var bonusNext = false
var timedPower: ChaosPower? = null; private set
var powerLeft = 0f; private set
var autoLeft = 0; private set
private var autoIn = 0f
/** Drift drifting past (seconds he's still about): from stage 4 his deliveries come muddled. */
var drift = 0f; private set
private var driftIn = 8f
var hint = Hint.HELLO; private set
var hintSide = 0; private set
var hintT = 4f; private set
private var seenStatic = false
private var seenMixed = false
private var seenPower = false
/** The interruption showing between rounds. */
var interlude: Interludes.Line = Interludes.FASTER; private set
/** The screen Bumble repaired at the end of this round, or -1. */
var repaired = -1; private set
private var lineAt = 0
var events = 0
var clock = 0f; private set
var ticks = 0L; private set
init { newRun(difficulty, seed) }
fun newRun(difficulty: Difficulty = this.difficulty, seed: Int = this.seed) {
this.difficulty = difficulty; tuning = ChaosTuning.of(difficulty); this.seed = seed
rng.reseed(seed)
meter.fill(0f); jammed.fill(false)
phase = Phase.Playing; phaseT = 0f
score = 0; streak = 0; bestChain = 1; stage = 1; stageSent = 0; sent = 0; binned = 0
bonus = 0f; bonusNext = false; timedPower = null; powerLeft = 0f; autoLeft = 0; autoIn = 0f; drift = 0f; driftIn = 8f
seenStatic = false; seenMixed = false; seenPower = false; lastSide = -1; lastT = 9f; clock = 0f; ticks = 0
repaired = -1; lineAt = rng.nextInt(Interludes.ALL.size)
say(Hint.HELLO, 0)
for (i in 0 until 3) fill(i)
startCurrent()
}
// ---------- making signals ----------
/** Seconds a signal waits in the middle: 3.4 s at stage 1, 12% quicker each stage, never under 0.75 s (× difficulty). */
fun signalTime(): Float = maxOf(.75f, 3.4f * Math.pow(.88, (stage - 1).toDouble()).toFloat()) * tuning.time
/** Static from stage 2 (one new thing at a time): 8% then more each stage, at most 35%; none in the bonus round. */
fun staticChance(): Float = if (bonus > 0f || stage < 2) 0f else minOf(.35f, .03f + stage * .025f) * tuning.static
/** Power-ups from stage 3. */
fun powerChance(): Float = if (bonus > 0f || stage < 3) 0f else .05f
/** Drift's muddled deliveries from stage 4, while he's drifting past. */
fun mixedChance(): Float = if (bonus > 0f || stage < 4 || drift <= 0f) 0f else .3f
private fun liveChannel(): Int {
var n = 0
for (s in 0 until Chan.SCREENS) if (!jammed[s]) n++
if (n == 0) return 0
var pick = rng.nextInt(n)
for (s in 0 until Chan.SCREENS) if (!jammed[s]) { if (pick == 0) return s; pick-- }
return 0
}
private fun fill(i: Int) {
power[i] = null
val r = rng.nextFloat()
val st = staticChance(); val pw = powerChance(); val mx = mixedChance()
when {
r < st -> kind[i] = Chan.STATIC
r < st + pw -> { kind[i] = Chan.POWER; power[i] = pickPower() }
r < st + pw + mx && !queueHasMixed() -> {
val a = liveChannel(); var b = liveChannel()
if (b == a) b = (a + 1 + rng.nextInt(Chan.SCREENS - 1)) % Chan.SCREENS
if (jammed[b]) { kind[i] = a; return }
kind[i] = Chan.MIXED; mixA[i] = a; mixB[i] = b
}
else -> kind[i] = liveChannel()
}
}
private fun queueHasMixed(): Boolean { for (k in kind) if (k == Chan.MIXED) return true; return false }
private fun pickPower(): ChaosPower {
var total = 0
for (p in POWERS) total += p.weight
var pick = rng.nextInt(total)
for (p in POWERS) { if (pick < p.weight) return p; pick -= p.weight }
return ChaosPower.Sweep
}
/** Counts each signal arriving in the middle (the screen's little drop-in, and the tests' player). */
var arrivals = 0L; private set
private fun startCurrent() {
arrivals++
leftTotal = signalTime(); left = leftTotal
when (kind[0]) {
Chan.STATIC -> if (!seenStatic) { seenStatic = true; say(Hint.STATIC, 0) }
Chan.MIXED -> if (!seenMixed) { seenMixed = true; say(Hint.MIXED, 0) }
Chan.POWER -> if (!seenPower) { seenPower = true; say(Hint.POWER, 0) }
}
}
/** The middle signal is done with: the queue moves up and a new one joins at the back. */
private fun advance() {
for (i in 0 until 2) { kind[i] = kind[i + 1]; mixA[i] = mixA[i + 1]; mixB[i] = mixB[i + 1]; power[i] = power[i + 1] }
fill(2)
startCurrent()
}
/** Whether the middle signal belongs on [side]. */
fun accepts(side: Int): Boolean = when (kind[0]) {
Chan.MIXED -> side == mixA[0] || side == mixB[0]
Chan.STATIC, Chan.POWER -> false
else -> kind[0] == side
}
/** The screen the middle signal belongs on (for the bot and Auto Tune), or -1 for static and power-ups. */
fun home(): Int = when (kind[0]) { Chan.MIXED -> mixA[0]; Chan.STATIC, Chan.POWER -> -1; else -> kind[0] }
// ---------- the remote ----------
/** ▲ ◀ ▶ ▼: send the middle signal to that screen. */
fun send(side: Int) {
if (phase != Phase.Playing) return
when (kind[0]) {
Chan.POWER -> { collect(power[0]!!); advance(); return }
Chan.STATIC -> { hurt(side, .3f); streak = 0; mark(side, false); events = events or ChaosEvents.WRONG }
else -> if (accepts(side)) match(side) else {
hurt(side, .3f)
streak = 0; mark(side, false); events = events or ChaosEvents.WRONG
}
}
sent++
if (phase == Phase.Playing) advance()
}
/** OK: bin the static (or take a power-up). On a channel's signal, it's thrown away, which its screen notices. */
fun ok() {
when (phase) {
Phase.Reward -> { skipReward(); return }
Phase.Interlude -> { nextRound(); return }
Phase.Over -> return
Phase.Playing -> {}
}
when (kind[0]) {
Chan.POWER -> collect(power[0]!!)
Chan.STATIC -> { binned++; streak++; bestChain = maxOf(bestChain, chain); score += 5 * chain; events = events or ChaosEvents.BIN }
else -> { hurt(home(), .15f); streak = 0; events = events or ChaosEvents.WRONG }
}
advance()
}
private fun match(side: Int) {
streak++
bestChain = maxOf(bestChain, chain)
val mult = (if (bonus > 0f) 5 else 1) * (if (timedPower == ChaosPower.DoublePoints) 2 else 1) * (if (kind[0] == Chan.MIXED) 2 else 1)
score += 10 * chain * stage * mult
meter[side] = maxOf(0f, meter[side] - .12f)
mark(side, true)
events = events or ChaosEvents.MATCH
stageSent++
if (bonus <= 0f && stageSent >= STAGE_SIGNALS) endRound()
}
private fun mark(side: Int, good: Boolean) { lastSide = side; lastGood = good; lastT = 0f }
/** Interference on a screen: none in the bonus round or under Perfect Reception. Full jams it; three jammed ends the run. */
private fun hurt(side: Int, amount: Float) {
if (bonus > 0f || timedPower == ChaosPower.Reception || side < 0 || jammed[side]) return
val before = meter[side]
meter[side] = minOf(1f, meter[side] + amount * tuning.hurt)
if (before < .7f && meter[side] >= .7f && meter[side] < 1f) say(Hint.NEARLY, side)
if (meter[side] >= 1f) {
jammed[side] = true
events = events or ChaosEvents.JAMMED
say(Hint.JAMMED, side)
if (jammedCount >= 3) { phase = Phase.Over; events = events or ChaosEvents.OVER; return }
// Its signals stop coming: any already in the chute for it go elsewhere.
for (i in 0 until 3) {
if (kind[i] == side) kind[i] = liveChannel()
if (kind[i] == Chan.MIXED && (mixA[i] == side || mixB[i] == side)) kind[i] = liveChannel()
}
}
}
val jammedCount: Int get() { var n = 0; for (j in jammed) if (j) n++; return n }
// ---------- between rounds ----------
/** A stage (or the bonus round) is done: the reward, then an interruption, then the next round. */
private fun endRound() {
val afterBonus = bonus > 0f
bonus = 0f; stageSent = 0; timedPower = null; powerLeft = 0f; autoLeft = 0
// After the bonus round, Bumble rushes in to repair a jammed screen, if there is one.
repaired = -1
if (afterBonus) for (s in 0 until Chan.SCREENS) if (jammed[s]) { jammed[s] = false; meter[s] = .4f; repaired = s; events = events or ChaosEvents.REPAIRED; break }
// Every third stage is followed by Blaze's bonus round.
bonusNext = !afterBonus && stage % 3 == 0
if (!afterBonus && !bonusNext) stage++
if (afterBonus) stage++
interlude = when {
repaired >= 0 -> Interludes.REPAIR
bonusNext -> Interludes.BONUS
else -> Interludes.ALL[lineAt++ % Interludes.ALL.size]
}
phase = Phase.Reward; phaseT = 0f
events = events or ChaosEvents.STAGE
}
/** OK during the reward: straight to the interruption. */
private fun skipReward() { phase = Phase.Interlude; phaseT = 0f }
/** OK on the interruption: the next round starts. */
private fun nextRound() {
phase = Phase.Playing; phaseT = 0f
if (bonusNext) { bonus = BONUS_SECONDS; bonusNext = false; say(Hint.BONUS, 0); events = events or ChaosEvents.BONUS }
for (i in 0 until 3) fill(i)
startCurrent()
}
private fun collect(p: ChaosPower) {
events = events or ChaosEvents.POWER
when (p) {
ChaosPower.Sweep -> {
for (s in 0 until Chan.SCREENS) if (!jammed[s]) meter[s] = 0f
for (i in 1 until 3) if (kind[i] == Chan.STATIC) kind[i] = liveChannel()
}
ChaosPower.AutoTune -> { autoLeft = 5; autoIn = AUTO_DELAY }
else -> { timedPower = p; powerLeft = p.seconds }
}
}
private fun say(h: Int, side: Int) { hint = h; hintSide = side; hintT = 4f }
// ---------- time ----------
fun step() {
if (phase == Phase.Over) return
ticks++
val dt = STEP
clock += dt
phaseT += dt
if (lastT < 9f) lastT += dt
if (phase == Phase.Reward) { if (phaseT >= REWARD_SECONDS) skipReward(); return }
// The interruption waits for OK.
if (phase == Phase.Interlude) return
if (hintT > 0f) { hintT -= dt; if (hintT <= 0f) hint = Hint.NONE }
if (timedPower != null) { powerLeft -= dt; if (powerLeft <= 0f) { timedPower = null; powerLeft = 0f } }
if (bonus > 0f) { bonus -= dt; if (bonus <= 0f) { bonus = .0001f; endRound(); return } }
if (drift > 0f) drift = maxOf(0f, drift - dt) else if (stage >= 4 && bonus <= 0f) { driftIn -= dt; if (driftIn <= 0f) { drift = 8f; driftIn = 18f + rng.nextFloat() * 10f } }
if (autoLeft > 0) {
autoIn -= dt
if (autoIn <= 0f) {
autoIn = AUTO_DELAY; autoLeft--
if (home() >= 0) send(home()) else ok()
return
}
}
if (!timed || timedPower == ChaosPower.Freeze) return
left -= dt
if (left <= 0f) {
// Left too long: it falls onto a screen as interference.
events = events or ChaosEvents.MISSED
streak = 0
when (kind[0]) {
Chan.POWER -> {}
Chan.STATIC -> hurt(liveChannel(), .22f)
else -> hurt(home(), .22f)
}
if (phase == Phase.Playing) advance()
}
}
fun takeEvents(): Int { val e = events; events = 0; return e }
companion object {
const val STEP = 1f / 60f
const val STAGE_SIGNALS = 16
const val BONUS_SECONDS = 15f
const val AUTO_DELAY = .35f
/** The four screens tuning in, the little ident and "And we're back on air!"; OK skips it. */
const val REWARD_SECONDS = 3.2f
private val POWERS = ChaosPower.entries.toTypedArray()
}
}
@@ -84,6 +84,6 @@ class ArcadeSessionTest {
assertTrue(resetAllowed(ResetAction.ResetLevelProgress, sky, "p", "p", false))
assertTrue(resetAllowed(ResetAction.ResetLevelProgress, hive, "p", "p", false))
// A coming-soon card has nothing to clear.
assertFalse(resetAllowed(ResetAction.ClearHighScores, ArcadeGames.ChannelChaos, "p", "p", false))
assertFalse(resetAllowed(ResetAction.ClearHighScores, ArcadeGames.NightShift, "p", "p", false))
}
}
@@ -57,21 +57,21 @@ class KidsArcadeTest {
}
@Test fun pickRecentAndHighScoresFollowTheFilter() {
val chosen = kids.withKidsArcade(KidsArcade.Chosen, setOf("Pairs", "Snake", "ChannelChaos"))
val chosen = kids.withKidsArcade(KidsArcade.Chosen, setOf("Pairs", "Snake", "NightShift"))
val visible = arcadeVisible(chosen)
// Star Chase isn't chosen, so it can't be the pick.
assertEquals("Snake", arcadePick(visible)!!.id)
assertEquals("OrbMan", arcadePick(arcadeVisible(grown))!!.id)
// Recent keeps only games this profile can still see and play.
assertEquals(listOf("Pairs", "Snake"), recentVisible(listOf("Blast", "Pairs", "ChannelChaos", "Snake", "Gone"), visible).map { it.id })
assertEquals(listOf("Pairs", "Snake"), recentVisible(listOf("Blast", "Pairs", "NightShift", "Snake", "Gone"), visible).map { it.id })
assertNull(arcadePick(emptyList()))
}
@Test fun theFamilyLineSaysWhatKidsReallySee() {
// The audit: "On: the games chosen for Kids" promised a choice that didn't exist.
assertEquals("Off: no Arcade for Kids", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Off)))
assertEquals("Kids-suitable games: 8 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.KidsSuitable)))
assertEquals("Chosen games: 2 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Chosen, setOf("Pairs", "Sky", "ChannelChaos"))))
assertEquals("Kids-suitable games: 9 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.KidsSuitable)))
assertEquals("Chosen games: 2 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Chosen, setOf("Pairs", "Sky", "NightShift"))))
assertEquals("Chosen games: none chosen yet, so no Arcade", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Chosen, emptySet())))
}
@@ -79,7 +79,7 @@ class KidsArcadeTest {
assertEquals(ArcadeGames.all.size, ArcadeGames.all.map { it.id }.toSet().size)
assertEquals(5, ArcadeGames.originals.size); assertEquals(8, ArcadeGames.classics.size)
// BumbleHive and (Stage D) Orbi-Raiders are the Originals that play; every Classic does.
assertEquals(listOf("OrbiRaiders", "Hive"), ArcadeGames.originals.filter { it.launchable }.map { it.id })
assertEquals(listOf("OrbiRaiders", "ChannelChaos", "Hive"), ArcadeGames.originals.filter { it.launchable }.map { it.id })
assertTrue(ArcadeGames.classics.all { it.launchable })
ArcadeGames.all.forEach { g ->
assertTrue(g.id, g.controls.isNotEmpty()); assertTrue(g.id, g.title.isNotBlank()); assertTrue(g.id, g.goal.isNotBlank())
@@ -54,4 +54,15 @@ class TitleTextFitsTest {
assertTrue("$label is ${"%.0f".format(w)} dp, room $room", w <= room)
}
}
@Test fun channelChaosButtonsAndCardsFitAtTheLargestFontScale() {
val font = Font(Font.SANS_SERIF, Font.BOLD, 1).deriveFont(14f * 1.3f)
for ((label, column) in listOf("▶ Play" to 210, "? How to Play" to 210, "← Back to Arcade" to 210, "▶ Play Again" to 160, "← Back to Arcade" to 200)) {
val room = column - 2 * 12.0 - 4
assertTrue("$label is ${"%.0f".format(width(font, label))} dp, room $room", width(font, label) <= room)
}
// The interruptions' captions wrap inside their 420 dp card; no single word may be wider than it.
val caption = Font(Font.SANS_SERIF, Font.BOLD, 1).deriveFont(20f * 1.3f)
for (l in tv.orbit.classic.arcade.chaos.Interludes.ALL) for (w in l.text.split(' ')) assertTrue(w, width(caption, w) < 420 - 28)
}
}
@@ -0,0 +1,38 @@
package tv.orbit.classic.arcade.chaos
import org.junit.Assert.assertTrue
import org.junit.Test
import tv.orbit.classic.arcade.Difficulty
/**
* "Increasingly chaotic without becoming frustrating" (Paul). Three players through every difficulty: a young one (slow,
* often wrong), an ordinary one and a sharp one. Reported: how far each gets, and how often they clear the first bonus
* round (stage 3 and its bonus). Gentle must let the young player through the opening comfortably.
*/
class ChaosBalanceTest {
private class Player(val name: String, val think: Float, val slips: Float)
private val players = listOf(Player("young", 1.6f, .12f), Player("ordinary", 1.0f, .06f), Player("sharp", .6f, .03f))
private fun run(d: Difficulty, p: Player, seed: Int): Pair<Int, Float> {
val sim = ChaosSim(d, seed)
val bot = ChaosBot(p.think, p.slips, seed)
var t = 0
while (!sim.over && t < 60 * 60 * 20) { bot.tick(sim); sim.step(); t++ }
return sim.stage to t / 60f
}
@Test fun theCurveOnEachDifficulty() {
val report = StringBuilder("Channel Chaos (bot, 24 seeds each):\n")
val firstBonus = HashMap<String, Double>()
for (d in Difficulty.entries) for (p in players) {
val runs = (1..24).map { run(d, p, it * 7919) }
val past3 = 100.0 * runs.count { it.first >= 4 } / runs.size
firstBonus["${d.name}/${p.name}"] = past3
report.append("%-7s %-9s mean stage %5.1f | past the first bonus round %5.1f%% | mean minutes %5.1f%n".format(
d.title, p.name, runs.map { it.first }.average(), past3, runs.map { it.second }.average() / 60))
}
println(report)
assertTrue(report.toString(), firstBonus["Gentle/young"]!! >= 75.0)
assertTrue(report.toString(), firstBonus["Gentle/young"]!! >= firstBonus["Normal/young"]!! && firstBonus["Normal/ordinary"]!! >= firstBonus["Tricky/ordinary"]!!)
}
}
@@ -0,0 +1,29 @@
package tv.orbit.classic.arcade.chaos
/**
* A player for the tests: it looks at each new signal for [think] seconds, then presses; [slips] of the time it presses the
* wrong way (a different screen, or OK on a signal). It always answers the between-rounds OK. It allocates nothing.
*/
internal class ChaosBot(private val think: Float, private val slips: Float, seed: Int) {
private var waited = 0f
private var seen = -1L
private var s = seed.toLong() * 2654435761L + 1
private fun roll(): Float { s = (s * 6364136223846793005L + 1442695040888963407L); return ((s ushr 33) and 0xFFFFFF).toFloat() / 0xFFFFFF }
fun tick(sim: ChaosSim) {
if (sim.phase == Phase.Reward || sim.phase == Phase.Interlude) { if (sim.phaseT > .8f) sim.ok(); return }
if (sim.phase != Phase.Playing) return
// A new signal in the middle: the bot starts thinking again.
if (sim.arrivals != seen) { seen = sim.arrivals; waited = 0f }
waited += ChaosSim.STEP
if (waited < think) return
waited = -1e9f
val home = sim.home()
val slip = roll() < slips
when {
home < 0 -> if (slip) sim.send((roll() * 4).toInt().coerceIn(0, 3)) else sim.ok()
slip -> sim.send((home + 1 + (roll() * 3).toInt().coerceIn(0, 2)) % Chan.SCREENS)
else -> sim.send(home)
}
}
}
@@ -0,0 +1,161 @@
package tv.orbit.classic.arcade.chaos
import org.junit.Assert.*
import org.junit.Test
import tv.orbit.classic.arcade.Difficulty
/** Channel Chaos's rules: sending, static, jams, the curve, the rounds and the cast's interruptions. */
class ChaosSimTest {
private fun sim(d: Difficulty = Difficulty.Normal, seed: Int = 5) = ChaosSim(d, seed)
/** Plays [n] presses well: the right screen, or OK for static and power-ups; OK through the cards between rounds. */
private fun playWell(s: ChaosSim, n: Int) { repeat(n) { if (s.phase == Phase.Playing) { if (s.home() >= 0) s.send(s.home()) else s.ok() } } }
/** Plays well until [done], at most [limit] presses (so a test can never hang). */
private fun until(s: ChaosSim, limit: Int = 500, done: () -> Boolean) {
var n = 0
while (!done() && n++ < limit && !s.over) { if (s.phase == Phase.Playing) playWell(s, 1) else s.ok() }
}
@Test fun eachChannelHasItsOwnColourAndShape() {
assertEquals(listOf("Orbit 1", "Riot", "Terra", "Tots"), Chan.names.toList())
assertEquals(4, ChaosColours.channel.toSet().size)
assertEquals(androidx.compose.ui.graphics.Color(0xFF35D6F2), ChaosColours.channel[Chan.UP])
}
@Test fun theRightScreenScoresAndBuildsTheChainTheWrongOneAddsInterference() {
val s = sim()
s.send(s.home())
assertEquals(10, s.score); assertEquals(1, s.streak)
repeat(7) { s.send(s.home()) }
assertEquals(3, s.chain)
val wrong = (s.home() + 1) % 4
s.send(wrong)
assertEquals(1, s.chain); assertEquals(.3f, s.meter[wrong], 1e-4f)
}
@Test fun oneNewThingAStage() {
val s = sim()
assertEquals(0f, s.staticChance(), 0f); assertEquals(0f, s.powerChance(), 0f); assertEquals(0f, s.mixedChance(), 0f)
until(s) { s.stage == 2 && s.phase == Phase.Playing }
assertTrue(s.staticChance() > 0f); assertEquals(0f, s.powerChance(), 0f)
until(s) { s.stage == 3 && s.phase == Phase.Playing }
assertTrue(s.powerChance() > 0f); assertEquals(0f, s.mixedChance(), 0f)
assertTrue(s.signalTime() < 3.4f)
}
@Test fun okBinsStaticAndSendingStaticHurts() {
val s = sim(seed = 3)
s.kind[0] = Chan.STATIC
s.ok(); assertEquals(1, s.binned); assertEquals(5, s.score)
s.kind[0] = Chan.STATIC
s.send(Chan.LEFT); assertEquals(.3f, s.meter[Chan.LEFT], 1e-4f)
}
@Test fun aFullMeterJamsAScreenAndThreeJammedEndTheRun() {
val s = sim()
for (side in 0 until 3) {
var g = 0
while (!s.jammed[side] && g++ < 20) { s.kind[0] = Chan.STATIC; s.send(side) }
assertTrue(s.jammed[side])
if (!s.over) for (i in 0 until 3) assertTrue(s.kind[i] != side)
}
assertTrue(s.over); assertEquals(Phase.Over, s.phase)
}
@Test fun leftTooLongASignalFallsOntoItsScreen() {
val s = sim()
val home = s.home()
repeat((s.leftTotal / ChaosSim.STEP).toInt() + 3) { s.step() }
assertEquals(.22f, s.meter[home], 1e-4f)
}
@Test fun gentleGivesTimeToThinkInTheFirstStages() {
val g = sim(Difficulty.Gentle)
assertFalse(g.timed)
val before = g.arrivals
repeat(60 * 60) { g.step() }
assertEquals("a minute and the signal's still waiting", before, g.arrivals)
assertEquals(0f, g.meter.sum(), 0f)
until(g) { g.stage == 3 && g.phase == Phase.Playing }
assertTrue(g.timed)
assertTrue(g.signalTime() > sim(Difficulty.Normal).signalTime())
}
@Test fun betweenRoundsTheRewardThenAnInterruptionThatWaitsForOk() {
val s = sim()
playWell(s, ChaosSim.STAGE_SIGNALS)
assertEquals(Phase.Reward, s.phase)
repeat((ChaosSim.REWARD_SECONDS * 60).toInt() + 2) { s.step() }
assertEquals(Phase.Interlude, s.phase)
repeat(60 * 30) { s.step() }
assertEquals("waits for OK", Phase.Interlude, s.phase)
s.send(Chan.UP); assertEquals(Phase.Interlude, s.phase)
s.ok(); assertEquals(Phase.Playing, s.phase); assertEquals(2, s.stage)
until(s) { s.phase == Phase.Reward }
s.ok(); assertEquals("OK skips the reward", Phase.Interlude, s.phase)
}
@Test fun paulsTwoLinesAreThereAsWritten() {
val texts = Interludes.ALL.map { it.who to it.text }
assertTrue(texts.contains(Speaker.Blaze to "FASTER! WE'RE LOSING VIEWERS!"))
assertTrue(texts.contains(Speaker.Drift to "Oh. Was that supposed to go somewhere?"))
assertEquals("And we're back on air!", Interludes.BACK_ON_AIR)
assertTrue(Interludes.ALL.size >= 6)
}
@Test fun blazesBonusRoundAfterEveryThirdStageThenBumbleRepairs() {
val s = sim()
until(s) { s.phase == Phase.Reward && s.interlude == Interludes.BONUS }
assertEquals(3, s.stage); assertEquals(Interludes.BONUS, s.interlude)
s.ok(); s.ok()
assertTrue(s.bonus > 0f)
assertEquals(0f, s.staticChance(), 0f)
s.meter.fill(0f)
val w = (s.home().coerceAtLeast(0) + 1) % 4; s.send(w); assertEquals("no harm in the bonus round", 0f, s.meter[w], 0f)
s.jammed[Chan.RIGHT] = true; s.meter[Chan.RIGHT] = 1f
repeat((ChaosSim.BONUS_SECONDS * 60).toInt() + 5) { s.step() }
assertEquals(Phase.Reward, s.phase)
assertEquals(Chan.RIGHT, s.repaired); assertFalse(s.jammed[Chan.RIGHT])
assertEquals(Interludes.REPAIR, s.interlude); assertEquals(Speaker.Bumble, s.interlude.who)
s.ok(); s.ok(); assertEquals(4, s.stage)
}
@Test fun powerUpsDoWhatTheySay() {
val s = sim()
until(s) { s.stage == 3 && s.phase == Phase.Playing }
s.kind[0] = Chan.POWER; s.power[0] = ChaosPower.Freeze; s.ok()
assertEquals(ChaosPower.Freeze, s.timedPower)
val a = s.arrivals
repeat(60 * 5) { s.step() }
assertEquals("frozen", a, s.arrivals)
s.meter[0] = .5f; s.kind[0] = Chan.POWER; s.power[0] = ChaosPower.Sweep; s.ok(); assertEquals(0f, s.meter[0], 0f)
s.kind[0] = Chan.POWER; s.power[0] = ChaosPower.Reception; s.ok()
if (s.home() >= 0) { val w = (s.home() + 1) % 4; s.send(w); assertEquals(0f, s.meter[w], 0f) }
s.kind[0] = Chan.POWER; s.power[0] = ChaosPower.AutoTune; s.ok()
val done = s.sent + s.binned
repeat(60 * 3) { s.step() }
assertTrue(s.sent + s.binned > done)
}
@Test fun driftsMuddledSignalGoesToEitherScreenForDouble() {
val s = sim()
s.kind[0] = Chan.MIXED; s.mixA[0] = Chan.LEFT; s.mixB[0] = Chan.DOWN
assertTrue(s.accepts(Chan.LEFT) && s.accepts(Chan.DOWN) && !s.accepts(Chan.UP))
s.send(Chan.DOWN); assertEquals(20, s.score)
}
@Test fun steadyPlayAllocatesNothing() {
val s = ChaosSim(Difficulty.Normal, 9)
val bot = ChaosBot(.7f, .05f, 9)
fun tick() { bot.tick(s); s.step(); if (s.over) s.newRun() }
repeat(3_000) { tick() }
val mx = java.lang.management.ManagementFactory.getThreadMXBean() as com.sun.management.ThreadMXBean
val t = Thread.currentThread().id
val before = mx.getThreadAllocatedBytes(t)
repeat(10_000) { tick() }
val bytes = mx.getThreadAllocatedBytes(t) - before
println("Channel Chaos: 10,000 ticks allocated $bytes bytes")
assertTrue("allocated $bytes", bytes < 4 * 1024)
}
}
+42
View File
@@ -0,0 +1,42 @@
# Channel Chaos prototype: verification (9 November 2026)
Branch `arcade-channel-chaos` from `story-p1000` (`585ac72`), 0.110.14-chaos, versionCode 297. Not installed, no adb, nothing
pushed or merged. What it is: `docs/channel-chaos-prototype.md`.
| | 0.110.13-story-p1000 (296) | 0.110.14-chaos (297) |
|---|---|---|
| Build (debug, release) | passed | passed |
| Kotlin unit tests | 965 run, 24 skipped, 0 failed (8 Nov) | **980 run, 24 skipped, 1 failed** (see below) |
| Lint | 0 errors, 87 warnings | **0 errors, 87 warnings** (no new ones) |
| Release APK | 47,892,063 bytes | 47,941,211 bytes (**+49,148**) |
**The one failure is not Channel Chaos's.** `SmartSetupRegressionTest.sakuraIsBalancedFromItsOwnContentAndRepeatsFarLess`
(the channel planner) started failing after midnight on 9 November. It fails the same on the untouched `585ac72`, which
passed it the evening before, so it depends on today's date somewhere in the planner or the test. It needs a look on its
own, but has nothing to do with this branch.
## New tests
- `ChaosSimTest` (13): each channel its own colour and shape (Orbit 1 cyan); right screen scores and builds the chain, wrong
adds interference; one new thing a stage; OK bins static, sending static hurts; a full meter jams, three end the run, a
jammed screen's signals stop; a signal left too long falls on its screen; Gentle's untimed first stages; the reward then an
interruption that waits for OK (arrows do nothing, OK skips the reward); Paul's two lines as written; Blaze's bonus round
after stage 3 (no static, no harm) then Bumble's repair; the power-ups; Drift's muddled signal; **0 bytes a frame** (464
over 10,000 ticks, from new runs).
- `ChaosBalanceTest` (1): **the bot on each difficulty**, three players (young 1.6 s and 12% slips, ordinary 1.0 s and 6%,
sharp 0.6 s and 3%), 24 seeds each:
| | young | ordinary | sharp |
|---|---|---|---|
| Gentle | stage 11.0, 100% past the first bonus round | stage 42 (20 min cap) | stage 61 (cap) |
| Normal | stage 7.0, 100% | stage 11.0, 100% | stage 54 (cap) |
| Tricky | stage 5.0, 100% | stage 9.0, 100% | stage 13.2, 100% |
- `TitleTextFitsTest` (+1): the title and result buttons and the interruption captions fit at font scale 1.3 (the result's
Back to Arcade was widened from 170 to 200 dp after it failed).
- Changed: `KidsArcadeTest` (9 Kids-suitable games now; Originals that play: Orbi-Raiders, Channel Chaos, BumbleHive) and
`ArcadeSessionTest` (a coming-soon example is now Night Shift).
## Not checked
Nothing seen running: drawing, focus, the cards, the ident and sound on the TV.
+97
View File
@@ -0,0 +1,97 @@
# Channel Chaos (prototype, 8-9 November 2026)
Branch `arcade-channel-chaos` from `story-p1000` (`585ac72`), version 0.110.14-chaos, versionCode 297. For testing only:
not installed. Built from the approved Stage B frames (`design/arcade/stage-b`: 30-title, 31-play, 32-bonus-round,
33-result, and the Channel Chaos row of the power-up family) and Paul's notes.
## How it plays
Signals drop into the tuning chute in the middle; the next two spiral in behind. The remote sends the one in the middle to
the screen in that direction:
| Key | Screen | Colour and symbol |
|---|---|---|
| ▲ | Orbit 1 | cyan star (cyan, not orange, so it never looks like Tots) |
| ◀ | Riot | pink bolt (its channel mark) |
| ▶ | Terra | green leaf (its channel mark) |
| ▼ | Tots | amber sun (the Tots palette's sun) |
OK bins grey static (the Orbi-Raiders static sprite's look). A wrong screen, static sent to a screen, OK on a real signal,
or a signal left too long puts interference on a screen; its name plate's meter turns red near full, a full one jams the
screen (its signals stop coming), and three jammed screens end the run. A right send clears a little interference.
**Score**: 10 × chain × stage a match (chain ×1 to ×6, up by one every four in a row; any slip resets it). Binning static
is 5 × chain. Blaze's bonus round ×5, Double Points ×2, Drift's muddled signal ×2.
## The curve (Paul: "increasingly chaotic without becoming frustrating")
One new thing a stage, 16 signals a stage:
- **Stage 1**: plain signals, slowly (3.4 s each).
- **Stage 2**: static arrives.
- **Stage 3**: power-ups ride the chute (send or OK catches them).
- **Stage 4 on**: Drift drifts past now and then, and his deliveries come muddled: half one channel, half another, either
screen takes it.
- **After every third stage**: Blaze's bonus round, 15 s, no static, no harm, every match ×5.
- Each stage the signals come 12% quicker (never under 0.75 s) and static grows (to 35% at most).
Difficulty: **Gentle** has no timer at all for the first two stages ("give players time to think"), then signals wait 1.6×
as long, less static and less interference. **Tricky** is 0.78× the time, more static, more interference.
The bot through each difficulty (24 seeds each; see VERIFICATION): a young player (1.6 s to decide, 12% slips) gets past the
first bonus round every time on Gentle and averages stage 11; on Normal an ordinary player (1 s, 6%) averages stage 11.
## The cast (Paul's roles)
- **Ollie** tries to keep the broadcast running: hosts, and his hints sit bottom left ("Static next! Press OK to bin it.",
"Riot's nearly jammed. Careful!"). The only one with a mouth.
- **Blaze** hosts the bonus rounds, happy-eyed, and shouts between rounds.
- **Drift** somehow delivers signals to the wrong place: his muddled two-channel signals, and his lines between rounds.
- **Bumble** rushes in to repair broken transmitters: after each bonus round, one jammed screen is repaired (back with a
little interference).
All four are the cast library's own drawings (`drawOrbMascot`, `drawOrbChaser` for Blaze and Drift, `drawOrbBee`), drawn
once into small bitmaps; nothing is redrawn. Blaze, Drift and Bumble speak only in caption bubbles.
## Between rounds
1. **The reward** (3.2 s, OK skips): all four screens tune to their channels at once (no static, a soft glow), the little
Orbit ident in the chute (Orbit's own 5 KB logo, growing in; still under Reduce motion or Reduce flashing), and Ollie:
"And we're back on air!"
2. **An interruption** from the cast, waiting for OK (never mid-play). Paul's two as written, and more in the same spirit:
- Blaze: "FASTER! WE'RE LOSING VIEWERS!"
- Drift: "Oh. Was that supposed to go somewhere?"
- Blaze: "Bigger! Louder! MORE CHANNELS!"
- Drift: "I found this signal under a cloud. Is it yours?"
- Blaze: "Nobody blink. The ratings are watching."
- Drift: "I sent one to the moon. It seemed happy there."
- Ollie: "Steady hands. The viewers are with us."
- Before a bonus round, Blaze: "Bonus round! No static, just points. Go go go!"
- After Bumble's repair, Bumble: "Hold still, transmitter! Bumble's on it!"
## Power-ups (the Stage B family's Channel Chaos row)
One timed at a time. Channel Freeze (the middle signal stops falling, 8 s), Auto Tune (the next 5 send themselves), Signal
Sweep (clears interference on every working screen and static from the chute), Double Points (12 s), Perfect Reception (wrong
sends add no interference, 10 s). Each is its hexagon badge with its family's symbol.
## Shared parts and rules
The Arcade's pause menu, How to Play, Reduce motion (no shimmer, the ident still) and Reduce flashing (the send line steady),
the sound ceiling, per-profile saves (runs to High Scores as "Stage n", the best stage), Kids-suitable (in Kids' games,
Gentle by default). Back pauses (caught in the game's own key handler). One press is one send: a held key's repeats never
send again. The interruptions wait for OK; buttons spell their words out.
## For Paul
- **Title**: frame 30 has High Scores and Settings buttons on the title. They're left out here (the Arcade menu has both);
Play, How to Play and Back to Arcade remain. Add them if you want them on the game's own title.
- **Drift's role**: his muddled signal accepts either of its two channels for double points. If you meant something
trickier (a signal that looks like one channel but belongs to another), that's a small change.
- **Bumble**: repairs one jammed screen after each bonus round. More often, or as a power-up, are easy changes.
- **Endless**: the run goes on until three screens jam; there's no final stage yet.
- **Sound**: the existing Arcade cues only; no new sounds.
## Not checked
Nothing seen running: drawing, focus, the cards, the ident and sound on the TV are checked only by the compiler and tests.