Orbit Rush prototype (0.119.0, versionCode 310): three lanes, Asteroid Alley, three hazards, one power-up, lane warnings, bot-checked dodgeable, zero allocation

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-09 11:45:32 +00:00
co-authored by Claude Opus 5.5
parent aab877afc9
commit a457cd04c2
7 changed files with 527 additions and 7 deletions
+2 -2
View File
@@ -9,8 +9,8 @@ android {
applicationId = "tv.orbit.classic"
minSdk = 26
targetSdk = 36
versionCode = 309
versionName = "0.118.0-new-originals"
versionCode = 310
versionName = "0.119.0-orbit-rush"
}
buildFeatures { compose = true }
// The finished build for the TVs (Paul, 6 November 2026: the test build stuttered on the box). Not debuggable, so
@@ -122,6 +122,14 @@ internal object ArcadeGames {
tv.orbit.classic.arcade.daily.ArcadeDailyScreen(it)
}
// Paul's idea, 9 November 2026: a prototype to try for feel, plain shapes first.
val OrbitRush: ArcadeGame = GameDef("OrbitRush", "Orbit Rush", "Outrun the static storm", "Blaze races down three lanes through Asteroid Alley, a static storm behind.", Mascot.Blaze,
kidsSuitable = true, original = true, launchable = true, ScoreKind.Points, keepsLevels = false, legacyRecordKey = null,
listOf(Control("◀▶", "Change lane"), Control("▲", "Rise over"), Control("▼", "Dive under"), Control("OK", "Use the power-up"), BackPause),
"Red lane: change lanes. Yellow: rise. Cyan: dive.", listOf(GameSetting("sounds", "Sound effects"))) {
tv.orbit.classic.arcade.rush.OrbitRushScreen(it)
}
// Classics: the eight Kotlin games, unchanged, each in a thin wrapper.
val OrbMan: ArcadeGame = GameDef("OrbMan", "Star Chase", "Maze chase starring Ollie", "Help Ollie clear the stars, and dodge Blaze, Zip, Drift and Luna.", Mascot.Ollie,
kidsSuitable = true, original = false, launchable = true, ScoreKind.Points, keepsLevels = false, legacyRecordKey = "orb_man_best",
@@ -152,7 +160,7 @@ internal object ArcadeGames {
listOf(Control("◀▶▲▼", "Point"), Control("OK", "Pick up / put down"), Control("OK twice", "Send a card home"), Control("Back", "Put back, or pause")),
"Klondike, one card at a time: build each suit home, ace to king.") { PatienceScreen(it) }
val originals = listOf(OrbiRaiders, ChannelChaos, Hive, NightShift, Orbiteroids, QuizNight, TestCardTangle, Codebreaker, Daily)
val originals = listOf(OrbiRaiders, ChannelChaos, Hive, NightShift, Orbiteroids, QuizNight, TestCardTangle, Codebreaker, Daily, OrbitRush)
val classics = listOf(OrbMan, Blast, Sky, Snake, Blocks, Bricks, Pairs, Patience)
val all = originals + classics
@@ -0,0 +1,233 @@
package tv.orbit.classic.arcade.rush
import android.view.KeyEvent
import androidx.activity.compose.BackHandler
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
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.drawWithCache
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.geometry.CornerRadius
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
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.graphicsLayer
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.font.FontWeight
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.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.ClassicResult
import tv.orbit.classic.arcade.ClassicTitle
import tv.orbit.classic.arcade.Control
import tv.orbit.classic.arcade.HowToPlayCard
import tv.orbit.classic.arcade.KeyFooter
import tv.orbit.classic.arcade.Mascot
import tv.orbit.classic.arcade.PauseWhenHidden
import tv.orbit.classic.arcade.RunEnd
import tv.orbit.classic.arcade.RunTracker
import tv.orbit.classic.arcade.gameKeys
import tv.orbit.classic.arcade.orbiteroids.OrbiteroidsArt
import tv.orbit.classic.arcade.previousLine
import tv.orbit.classic.arcade.raiders.FixedStep
import tv.orbit.classic.arcade.raiders.Pilot
import tv.orbit.classic.arcade.raiders.pilotFace
import tv.orbit.classic.ArcadeBackdrop
import tv.orbit.classic.starPath
/** Orbit Rush's colours: plain shapes first (the prototype), each hazard its own colour and shape, unlike Orbiteroids'. */
internal object RColours {
val Rock = Color(0xFFC2662D); val RockDark = Color(0xFF7A3A16)
val Low = Color(0xFF3F6FD8); val Panel = Color(0xFF9EC1FF)
val Tall = Color(0xFFE040A0)
val Star = Color(0xFFFFDE59)
val Shield = Color(0xFF22C3D8)
val Track = Color(0xFF16245A); val Edge = Color(0xFF3D63B8)
/** The warning on a lane before each hazard: red means change lane, yellow means rise, cyan means dive. */
fun warn(kind: Int) = when (kind) { RKind.ROCK -> Color(0xFFFF6B6B); RKind.LOW -> Color(0xFFFFDE59); else -> Color(0xFF35D6F2) }
}
private enum class RStage { Title, Play, Result }
/** HUD numbers, read once a frame; Compose redraws only what changed. */
private class RHud {
var score by mutableIntStateOf(0); var hull by mutableIntStateOf(RushSim.HULL); var stars by mutableIntStateOf(0)
var shieldHeld by mutableStateOf(false); var shieldSecs by mutableIntStateOf(0); var frame by mutableIntStateOf(0)
fun read(s: RushSim) { score = s.score; hull = s.hull; stars = s.stars; shieldHeld = s.shieldHeld; shieldSecs = kotlin.math.ceil(s.shieldFor).toInt(); frame++ }
}
@Composable
internal fun OrbitRushScreen(play: ArcadePlay) {
val gameDef = ArcadeGames.OrbitRush
val latestPlay by rememberUpdatedState(play)
val calm = Motion.reduce
val steady = calm || play.reduceFlashing
val density = LocalDensity.current
val art = remember(density) { OrbiteroidsArt(pilotFace(Pilot.Blaze, 96, density)) }
val sim = remember { RushSim(play.difficulty) }
val hud = remember { RHud() }
val stepper = remember { FixedStep() }
var stage by remember { mutableStateOf(RStage.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) }
val tracker = remember { RunTracker { end -> latestPlay.onRunEnd(end) } }
fun endRun(finished: Boolean) { tracker.end(RunEnd(sim.score, finished, "${sim.distance.toInt()} m")) }
DisposableEffect(Unit) { onDispose { endRun(false) } }
LaunchedEffect(Unit) { play.audio.preload(R.raw.power_wide_orbit) }
fun startRun() { bestBefore = maxOf(latestPlay.best, bestBefore); sim.newRun(latestPlay.difficulty, System.nanoTime()); stepper.reset(); hud.read(sim); tracker.begin(); paused = false; stage = RStage.Play }
fun pause() { if (stage == RStage.Play && !paused) { paused = true; stepper.reset() } }
fun leave() { endRun(sim.over); latestPlay.onLeave() }
PauseWhenHidden(stage == RStage.Play && !paused) { pause() }
ArcadeGameLoop(running = stage == RStage.Play && !paused) { _, dt ->
val n = stepper.ticks(dt, paused)
var ev = 0
for (i in 0 until n) { sim.step(); ev = ev or sim.events }
if (ev and (REvents.POWER or REvents.SHIELD_ON) != 0) latestPlay.audio.cue(R.raw.power_wide_orbit, .6f, soundsOn)
hud.read(sim)
if (sim.over) { endRun(true); stage = RStage.Result }
}
val focus = remember { FocusRequester() }
LaunchedEffect(stage, paused) { if (stage == RStage.Play && !paused) runCatching { focus.requestFocus() } }
BackHandler(stage == RStage.Play && !paused) { pause() }
if (stage == RStage.Title) {
ClassicTitle(gameDef, ArcadeBackdrop.DeepSpace, tv.orbit.classic.OrbCharacter.Blaze.colour, "The storm's behind us. Go!",
listOf("Your best" to if (play.best > 0) "%,d".format(play.best) else "Not played yet"), timed = true, difficulty = play.difficulty,
refocus = !howTo, onPlay = ::startRun, onHowTo = { howTo = true }, onBack = { latestPlay.onLeave() }, kicker = "AN ORBIT ARCADE ORIGINAL · PROTOTYPE",
mode = "Asteroid Alley",
note = "Blaze flies on his own. ◀▶ change lane round a rock, ▲ rises over a low satellite, ▼ dives under a tall signal gate. Each lane lights up before something arrives: red, change lane; yellow, rise; cyan, dive. Grab a shield and OK puts it on.")
if (howTo) HowToPlayCard(gameDef, firstRun = false, everyTime = null, onEveryTime = {}, onPlay = { howTo = false }, onBack = { howTo = false })
return
}
// Moves act on the press (a held key repeats only for lanes, never for rise and dive).
val keys = Modifier.focusRequester(focus).focusable().gameKeys(enabled = stage == RStage.Play && !paused, pause = ::pause) { key, native ->
if (native.action != KeyEvent.ACTION_DOWN) return@gameKeys key != ArcadeKey.Other
when (key) {
ArcadeKey.Left -> sim.left(); ArcadeKey.Right -> sim.right()
ArcadeKey.Up -> if (native.repeatCount == 0) sim.rise(); ArcadeKey.Down -> if (native.repeatCount == 0) sim.dive()
ArcadeKey.Ok -> if (native.repeatCount == 0) sim.usePower()
else -> return@gameKeys false
}
true
}
Box(Modifier.fillMaxSize().then(keys)) {
Box(Modifier.fillMaxSize().rushSky())
Canvas(Modifier.fillMaxSize()) { hud.frame; drawRush(art, sim, calm, steady) }
Column(Modifier.fillMaxSize().padding(start = 32.dp, end = 32.dp, top = 20.dp, bottom = 10.dp)) {
Row(Modifier.fillMaxWidth()) {
Column(Modifier.weight(1f)) {
Text("SCORE", color = ArcadeColours.Muted, fontSize = 16.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 2.sp)
Text("%,d".format(hud.score), color = ArcadeColours.Ink, fontFamily = Anton, fontSize = 30.sp)
Text("★ ${hud.stars}", color = RColours.Star, fontSize = 16.sp, fontWeight = FontWeight.SemiBold)
}
Column(horizontalAlignment = Alignment.End) {
Text("HULL", color = ArcadeColours.Muted, fontSize = 16.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 2.sp)
Row(horizontalArrangement = Arrangement.spacedBy(3.dp)) { for (i in 0 until RushSim.HULL) Box(Modifier.size(28.dp, 10.dp).background(if (i < hud.hull) Color(0xFF4CD98A) else Color(0xFF1C2A5A), RoundedCornerShape(3.dp))) }
Spacer(Modifier.height(6.dp))
Text(when { hud.shieldSecs > 0 -> "Orbit Shield on: ${hud.shieldSecs} s"; hud.shieldHeld -> "OK: Orbit Shield"; else -> "No power-up" },
color = if (hud.shieldHeld || hud.shieldSecs > 0) RColours.Shield else ArcadeColours.Muted, fontSize = 15.sp, fontWeight = FontWeight.SemiBold)
}
}
Spacer(Modifier.weight(1f))
KeyFooter(listOf(Control("◀▶", "Lane"), Control("▲", "Rise"), Control("▼", "Dive"), Control("OK", "Power-up"), Control("Back", "Pause")), note = "Asteroid Alley · prototype")
}
if (stage == RStage.Result) ClassicResult(gameDef, "ORBIT RUSH · ${sim.distance.toInt()} M THROUGH ASTEROID ALLEY", "SCORE", "%,d".format(sim.score),
newBest = sim.score > bestBefore && sim.score > 0, previous = previousLine(gameDef.scoreKind, bestBefore, gameDef.title),
detail = "${sim.stars} stars · ${sim.dodged} dodged · the static storm caught up", cheer = Mascot.Zip, onAgain = { endRun(sim.over); startRun() }, onBack = ::leave)
if (paused && stage == RStage.Play) ArcadePauseMenu(gameDef, "Orbit Rush · ${sim.distance.toInt()} m · ${"%,d".format(sim.score)}",
onResume = { paused = false; stepper.reset() }, onRestart = { endRun(false); startRun() }, onExit = ::leave,
sound = if (soundsOn) "Effects on" else "Effects off", onSound = { soundsOn = !soundsOn; latestPlay.setSetting("sounds", soundsOn) })
}
}
/** The sky and the track's lanes, drawn once in their own layer: only what moves is drawn each frame. */
private fun Modifier.rushSky(): Modifier = graphicsLayer().drawWithCache {
val w = size.width; val h = size.height
val rnd = java.util.Random(7)
val stars = FloatArray(120 * 3) { k -> when (k % 3) { 0 -> rnd.nextFloat() * w; 1 -> rnd.nextFloat() * h * .4f; else -> .5f + rnd.nextFloat() * 1.5f } }
val horizon = h * HORIZON; val base = h
val track = Path().apply { moveTo(w / 2 - LANE_W * w * .2f * 1.5f, horizon); lineTo(w / 2 + LANE_W * w * .2f * 1.5f, horizon); lineTo(w / 2 + LANE_W * w * 1.5f, base); lineTo(w / 2 - LANE_W * w * 1.5f, base); close() }
onDrawBehind {
drawRect(Brush.verticalGradient(listOf(Color(0xFF040A1E), Color(0xFF0E1A48)), 0f, horizon))
drawRect(Color(0xFF060C24), Offset(0f, horizon), Size(w, h - horizon))
for (i in 0 until 120) drawCircle(Color.White.copy(alpha = .3f + stars[i * 3 + 2] / 5), stars[i * 3 + 2], Offset(stars[i * 3], stars[i * 3 + 1]))
drawPath(track, RColours.Track)
for (b in 0..3) { val off = b - 1.5f; drawLine(RColours.Edge, Offset(w / 2 + off * LANE_W * w * .2f, horizon), Offset(w / 2 + off * LANE_W * w, base), 2f) }
}
}
/** Where the horizon sits, and a lane's width at the front (a share of the screen's width). */
private const val HORIZON = .34f
private const val LANE_W = .2f
/** The perspective: a thing at distance [z] is drawn at scale s (1 at Blaze, .2 at the horizon) and at height y. */
private fun scaleAt(z: Float) = 1f / (1f + 4f * (z / FAR))
private fun DrawScope.yAt(s: Float) = size.height * HORIZON + (size.height * .9f - size.height * HORIZON) * (s - .2f) / .8f
private fun DrawScope.xAt(laneX: Float, s: Float) = size.width / 2 + (laneX - 1f) * LANE_W * size.width * s
private fun DrawScope.drawRush(art: OrbiteroidsArt, s: RushSim, calm: Boolean, steady: Boolean) {
val w = size.width; val h = size.height
// Dashes rushing past on the lane lines (still with Reduce motion).
val shift = if (calm) 0f else (s.distance % 10f) / 10f
for (b in 0..3) for (k in 0 until 8) {
val z = FAR * (1f - (k + shift) / 8f)
val sc = scaleAt(z); val off = b - 1.5f
drawCircle(RColours.Edge.copy(alpha = .4f + .6f * sc), 2f + 3f * sc, Offset(w / 2 + off * LANE_W * w * sc, yAt(sc)))
}
// Warnings: a lane lights in the colour of what's coming down it (steady with Reduce flashing).
for (i in 0 until RushSim.MAX) {
if (!s.on[i] || s.kind[i] > RKind.TALL || s.z[i] > WARN) continue
val a = if (steady) .35f else .25f + .15f * kotlin.math.sin(s.clock * 12f)
val sc = scaleAt(0f)
drawRect(RColours.warn(s.kind[i]).copy(alpha = a), Offset(xAt(s.laneOf[i].toFloat(), sc) - LANE_W * w * .5f, h * .9f), Size(LANE_W * w, h * .06f))
}
// Far things first, so near ones are drawn over them.
for (pass in 0 until 2) for (i in 0 until RushSim.MAX) {
if (!s.on[i]) continue
val z = s.z[i]
if ((pass == 0) != (z > FAR / 2)) continue
val sc = scaleAt(z); val x = xAt(s.laneOf[i].toFloat(), sc); val y = yAt(sc); val u = LANE_W * w * sc
when (s.kind[i]) {
// A rock: a big chunky boulder filling the lane.
RKind.ROCK -> { drawCircle(RColours.RockDark, u * .42f, Offset(x, y - u * .3f)); drawCircle(RColours.Rock, u * .36f, Offset(x - u * .04f, y - u * .34f)); drawCircle(RColours.RockDark, u * .08f, Offset(x + u * .1f, y - u * .42f)) }
// A low satellite: a wide flat bar along the track (rise over it).
RKind.LOW -> { drawRect(RColours.Low, Offset(x - u * .45f, y - u * .16f), Size(u * .9f, u * .14f)); drawRect(RColours.Panel, Offset(x - u * .42f, y - u * .14f), Size(u * .3f, u * .1f)); drawRect(RColours.Panel, Offset(x + u * .12f, y - u * .14f), Size(u * .3f, u * .1f)) }
// A tall signal gate: two posts and a bar overhead, a gap underneath (dive under it).
RKind.TALL -> { drawRect(RColours.Tall, Offset(x - u * .45f, y - u * .9f), Size(u * .08f, u * .9f)); drawRect(RColours.Tall, Offset(x + u * .37f, y - u * .9f), Size(u * .08f, u * .9f)); drawRect(RColours.Tall, Offset(x - u * .45f, y - u * .9f), Size(u * .9f, u * .3f)) }
RKind.STAR -> drawPath(starPath(Offset(x, y - u * .3f), u * .16f, u * .07f, 0f), RColours.Star)
RKind.SHIELD -> { drawCircle(RColours.Shield, u * .18f, Offset(x, y - u * .3f)); drawCircle(Color.White, u * .18f, Offset(x, y - u * .3f), style = Stroke(u * .03f)) }
}
}
// Blaze's rocket: low when diving, high when rising, tinted for a moment when hit.
val bx = xAt(s.laneX, 1f)
val by = h * .82f + when (s.height) { RHeight.RISE -> -h * .12f; RHeight.DIVE -> h * .06f; else -> 0f }
val k = h / 260f
if (s.shieldFor > 0f) drawCircle(RColours.Shield.copy(alpha = .3f), 34f * k, Offset(bx, by))
scale(k, k, Offset(bx, by)) { with(art) { ship(bx, by, 0f, s.hurtFor > 0f, if (calm) 1f else kotlin.math.sin(s.clock * 30f)) } }
// The static storm behind, closer as he's hit: a band of grey along the bottom (dots still with Reduce motion).
val band = h * (.06f + .14f * (1f - s.storm))
drawRect(Brush.verticalGradient(listOf(Color.Transparent, Color(0xFF8D95AE).copy(alpha = .55f)), h - band, h), Offset(0f, h - band), Size(w, band))
if (!calm) for (k2 in 0 until 40) { val sx = ((k2 * 97 + (s.clock * 400).toInt() * 13) % 1000) / 1000f * w; val sy = h - band * (((k2 * 37) % 100) / 100f); drawRect(Color.White.copy(alpha = .35f), Offset(sx, sy), Size(3f, 2f)) }
}
@@ -0,0 +1,135 @@
package tv.orbit.classic.arcade.rush
import tv.orbit.classic.arcade.Difficulty
/**
* Orbit Rush (prototype, 9 November 2026, from Paul's idea): Blaze flies forward on his own down three lanes through
* Asteroid Alley, a static storm close behind. ◀▶ change lane, ▲ rises over a low satellite, ▼ dives under a tall
* signal gate; rocks block a lane at every height, so only a lane change gets round one. Stars to collect, and one
* power-up (Orbit Shield) held until OK. Three hull bars.
*
* 2.5D: the sim works in lanes and distance ahead; the screen draws it in perspective. Fixed 60 Hz steps over pooled
* arrays: nothing is made while it runs (checked by RushSimTest).
*/
internal const val RSTEP = 1f / 60f
internal const val LANES = 3
/** How far ahead things appear, and where they're first shown with a warning on their lane. */
internal const val FAR = 100f
internal const val WARN = 55f
internal object RKind { const val ROCK = 0; const val LOW = 1; const val TALL = 2; const val STAR = 3; const val SHIELD = 4 }
/** Blaze's height: level, rising over a low thing, or diving under a tall one. */
internal object RHeight { const val LEVEL = 0; const val RISE = 1; const val DIVE = 2 }
internal object REvents { const val STAR = 1; const val HIT = 2; const val DODGE = 4; const val POWER = 8; const val SHIELD_ON = 16; const val OVER = 32 }
internal class RushSim(var difficulty: Difficulty = Difficulty.Normal, seed: Long = 1) {
private var rnd = java.util.Random(seed)
// ---------- Blaze ----------
/** The lane he's in or heading for (0 left, 1 middle, 2 right), and where he's drawn, sliding between lanes. */
var lane = 1; var laneX = 1f
var height = RHeight.LEVEL; var heightFor = 0f
var hull = HULL; var hurtFor = 0f
/** Orbit Shield: held until OK, then on for a while. */
var shieldHeld = false; var shieldFor = 0f
// ---------- the alley ----------
val kind = IntArray(MAX); val laneOf = IntArray(MAX); val z = FloatArray(MAX); val on = BooleanArray(MAX)
var distance = 0f; var speed = 0f; var stars = 0; var dodged = 0
var over = false; var clock = 0f
private var spawnIn = 0f
/** The static storm: how far behind (1 far, 0 on his tail); it closes in when he's hit and drifts back as he flies on. */
var storm = 1f
var events = 0
val score get() = distance.toInt() + stars * 10
private val pace get() = when (difficulty) { Difficulty.Gentle -> .78f; Difficulty.Normal -> 1f; Difficulty.Tricky -> 1.18f }
fun newRun(d: Difficulty, seed: Long) {
difficulty = d; rnd = java.util.Random(seed)
lane = 1; laneX = 1f; height = RHeight.LEVEL; heightFor = 0f; hull = HULL; hurtFor = 0f; shieldHeld = false; shieldFor = 0f
on.fill(false); distance = 0f; speed = START_SPEED * pace; stars = 0; dodged = 0; over = false; clock = 0f; spawnIn = 1.2f; storm = 1f; events = 0
}
// ---------- the remote ----------
fun left() { if (!over && lane > 0) lane-- }
fun right() { if (!over && lane < LANES - 1) lane++ }
fun rise() { if (!over) { height = RHeight.RISE; heightFor = MOVE_TIME } }
fun dive() { if (!over) { height = RHeight.DIVE; heightFor = MOVE_TIME } }
/** OK: the held power-up goes on. */
fun usePower(): Boolean { if (over || !shieldHeld) return false; shieldHeld = false; shieldFor = SHIELD_TIME; events = events or REvents.SHIELD_ON; return true }
fun step() {
events = 0
if (over) return
val dt = RSTEP
clock += dt
// Faster the further he goes, to a limit.
speed = minOf(MAX_SPEED, (START_SPEED + distance * .012f)) * pace
distance += speed * dt
// Lanes slide quickly; a rise or dive lasts a moment, then he levels out.
laneX += (lane - laneX) * minOf(1f, LANE_SNAP * dt)
if (kotlin.math.abs(lane - laneX) < .01f) laneX = lane.toFloat()
if (heightFor > 0f) { heightFor -= dt; if (heightFor <= 0f) height = RHeight.LEVEL }
if (hurtFor > 0f) hurtFor -= dt
if (shieldFor > 0f) shieldFor -= dt
storm = minOf(1f, storm + dt * .02f)
// Everything comes towards him; whatever reaches him is met.
for (i in 0 until MAX) {
if (!on[i]) continue
z[i] -= speed * dt
if (z[i] > 0f) continue
on[i] = false
if (laneOf[i] != lane) { if (kind[i] <= RKind.TALL) { dodged++; events = events or REvents.DODGE }; continue }
when (kind[i]) {
RKind.STAR -> { stars++; events = events or REvents.STAR }
RKind.SHIELD -> { shieldHeld = true; events = events or REvents.POWER }
RKind.ROCK -> meet()
RKind.LOW -> if (height == RHeight.RISE) { dodged++; events = events or REvents.DODGE } else meet()
RKind.TALL -> if (height == RHeight.DIVE) { dodged++; events = events or REvents.DODGE } else meet()
}
}
// A new row: always at least one way through.
spawnIn -= dt
if (spawnIn <= 0f) { spawnRow(); spawnIn = rowGap() }
}
/** Seconds between rows: shorter as the speed builds; Gentle leaves more room, Tricky less. */
private fun rowGap() = (when (difficulty) { Difficulty.Gentle -> 1.35f; Difficulty.Normal -> 1.05f; Difficulty.Tricky -> .85f } - distance * .00004f).coerceAtLeast(.6f)
private fun meet() {
if (hurtFor > 0f || shieldFor > 0f) { dodged++; return }
hull--; hurtFor = HURT_TIME; storm = maxOf(0f, storm - .34f)
events = events or REvents.HIT
if (hull <= 0) { hull = 0; over = true; events = events or REvents.OVER }
}
private fun spawn(k: Int, laneAt: Int) {
for (i in 0 until MAX) if (!on[i]) { on[i] = true; kind[i] = k; laneOf[i] = laneAt; z[i] = FAR; return }
}
/**
* A row of hazards: one or two (never all three blocked by rocks), so a lane is always free or a rise or dive gets
* through; stars in a free lane now and then, and a shield once in a while.
*/
private fun spawnRow() {
val hazards = if (difficulty == Difficulty.Gentle || rnd.nextInt(3) != 0) 1 else 2
val free = rnd.nextInt(LANES)
var placed = 0
for (l in 0 until LANES) {
if (l == free || placed >= hazards) continue
val k = when (rnd.nextInt(3)) { 0 -> RKind.ROCK; 1 -> RKind.LOW; else -> RKind.TALL }
spawn(k, l); placed++
}
if (rnd.nextInt(3) == 0) spawn(if (rnd.nextInt(14) == 0) RKind.SHIELD else RKind.STAR, free)
}
companion object {
const val MAX = 48; const val HULL = 3
const val START_SPEED = 46f; const val MAX_SPEED = 95f
const val LANE_SNAP = 22f; const val MOVE_TIME = .7f; const val HURT_TIME = 1f; const val SHIELD_TIME = 6f
}
}
@@ -16,7 +16,7 @@ class KidsArcadeTest {
@Test fun grownUpsSeeEveryGame() {
assertEquals(ArcadeGames.all.map { it.id }, ids(grown))
assertEquals(17, ids(grown).size)
assertEquals(18, ids(grown).size)
// A grown-up's Arcade for Kids setting means nothing.
assertEquals(ArcadeGames.all.map { it.id }, ids(grown.withKidsArcade(KidsArcade.Off)))
assertEquals(ArcadeGames.all.map { it.id }, ids(null))
@@ -70,16 +70,16 @@ class KidsArcadeTest {
@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: 15 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.KidsSuitable)))
assertEquals("Kids-suitable games: 16 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.KidsSuitable)))
assertEquals("Chosen games: 2 to play", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Chosen, setOf("Pairs", "Sky", "Retired"))))
assertEquals("Chosen games: none chosen yet, so no Arcade", arcadeForKidsLine(kids.withKidsArcade(KidsArcade.Chosen, emptySet())))
}
@Test fun everyGameIsDescribed() {
assertEquals(ArcadeGames.all.size, ArcadeGames.all.map { it.id }.toSet().size)
assertEquals(9, ArcadeGames.originals.size); assertEquals(8, ArcadeGames.classics.size)
assertEquals(10, ArcadeGames.originals.size); assertEquals(8, ArcadeGames.classics.size)
// All five Originals play now (Orbiteroids, the last, 9 November 2026); every Classic does.
assertEquals(listOf("OrbiRaiders", "ChannelChaos", "Hive", "NightShift", "Orbiteroids", "QuizNight", "TestCardTangle", "Codebreaker", "ArcadeDaily"), ArcadeGames.originals.filter { it.launchable }.map { it.id })
assertEquals(listOf("OrbiRaiders", "ChannelChaos", "Hive", "NightShift", "Orbiteroids", "QuizNight", "TestCardTangle", "Codebreaker", "ArcadeDaily", "OrbitRush"), 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())
@@ -0,0 +1,92 @@
package tv.orbit.classic.arcade.rush
import org.junit.Assert.*
import org.junit.Test
import tv.orbit.classic.arcade.Difficulty
class RushSimTest {
private fun fresh(d: Difficulty, seed: Long = 1) = RushSim(d).also { it.newRun(d, seed) }
/**
* A careful player with a reaction time: acts only once a hazard's lane warning is showing and [reaction] seconds have
* passed since it first could have; rocks get a lane change to a lane clear of the next thing coming, low things a
* rise, tall ones a dive, timed for the moment they arrive.
*/
private fun bot(s: RushSim, reaction: Float) {
var nearest = -1
for (i in 0 until RushSim.MAX) if (s.on[i] && s.laneOf[i] == s.lane && s.kind[i] <= RKind.TALL && (nearest < 0 || s.z[i] < s.z[nearest])) nearest = i
if (nearest < 0) return
val seen = (WARN - s.z[nearest]) / s.speed // seconds since its warning came on
if (seen < reaction) return
val t = s.z[nearest] / s.speed // seconds until it arrives
when (s.kind[nearest]) {
RKind.ROCK -> {
// The lane whose next hazard is furthest off.
var best = s.lane; var room = -1f
for (l in 0 until LANES) if (kotlin.math.abs(l - s.lane) == 1 || l == s.lane) {
var near = Float.MAX_VALUE
for (i in 0 until RushSim.MAX) if (s.on[i] && s.laneOf[i] == l && s.kind[i] <= RKind.TALL) near = minOf(near, s.z[i])
if (l != s.lane && near > room) { room = near; best = l }
}
if (best < s.lane) s.left() else if (best > s.lane) s.right()
}
RKind.LOW -> if (t < .45f && s.height != RHeight.RISE) s.rise()
RKind.TALL -> if (t < .45f && s.height != RHeight.DIVE) s.dive()
}
}
@Test fun everyHazardCanBeDodgedInTimeOnEveryDifficulty() {
// Three minutes each, at the fastest the run gets: a player reacting within a quarter of a second takes no hits.
for (d in Difficulty.entries) for (seed in 1L..6L) {
val s = fresh(d, seed); var hits = 0
repeat(180 * 60) { bot(s, .25f); s.step(); if (s.events and REvents.HIT != 0) hits++ }
assertEquals("$d seed $seed: hits", 0, hits); assertFalse(s.over)
assertTrue(s.dodged > 50)
}
}
@Test fun theWarningComesSoonEnoughEvenAtFullSpeed() {
// From the warning to arrival is at least half a second at the top speed on Tricky: time to see and press.
val top = RushSim.MAX_SPEED * 1.18f
assertTrue(WARN / top >= .45f)
// And rows never come so close that a lane change and a rise can't both be done between them.
assertTrue(.6f >= RushSim.MOVE_TIME * .8f)
}
@Test fun eachHazardWantsItsOwnMove() {
fun meet(kind: Int, act: (RushSim) -> Unit): Int {
val s = fresh(Difficulty.Normal); for (i in 0 until RushSim.MAX) s.on[i] = false
s.on[0] = true; s.kind[0] = kind; s.laneOf[0] = 1; s.z[0] = .1f
act(s); s.step(); return s.hull
}
assertEquals(RushSim.HULL - 1, meet(RKind.ROCK) { it.rise() }) // a rock: rising doesn't help
assertEquals(RushSim.HULL, meet(RKind.ROCK) { it.left() })
assertEquals(RushSim.HULL, meet(RKind.LOW) { it.rise() }); assertEquals(RushSim.HULL - 1, meet(RKind.LOW) { it.dive() })
assertEquals(RushSim.HULL, meet(RKind.TALL) { it.dive() }); assertEquals(RushSim.HULL - 1, meet(RKind.TALL) { it.rise() })
}
@Test fun theShieldIsHeldUntilOkAndThenTakesHits() {
val s = fresh(Difficulty.Normal); for (i in 0 until RushSim.MAX) s.on[i] = false
s.on[0] = true; s.kind[0] = RKind.SHIELD; s.laneOf[0] = 1; s.z[0] = .1f; s.step()
assertTrue(s.shieldHeld); assertTrue(s.usePower()); assertFalse(s.usePower())
s.on[1] = true; s.kind[1] = RKind.ROCK; s.laneOf[1] = 1; s.z[1] = .1f; s.step()
assertEquals(RushSim.HULL, s.hull)
}
@Test fun threeHitsEndTheRunAndTheStormClosesIn() {
val s = fresh(Difficulty.Normal); var t = 0
while (!s.over && t < 60 * 120) { s.step(); t++ } // nobody steering
assertTrue(s.over); assertEquals(0, s.hull); assertTrue(s.storm < 1f)
}
@Test fun nothingIsAllocatedWhileItRuns() {
val s = fresh(Difficulty.Normal, 3)
repeat(2_000) { bot(s, .25f); s.step() }
val mx = java.lang.management.ManagementFactory.getThreadMXBean() as com.sun.management.ThreadMXBean
val before = mx.getThreadAllocatedBytes(Thread.currentThread().id)
repeat(10_000) { bot(s, .25f); s.step(); if (s.over) s.newRun(Difficulty.Normal, 4) }
val bytes = mx.getThreadAllocatedBytes(Thread.currentThread().id) - before
println("Orbit Rush: 10,000 ticks allocated $bytes bytes")
assertTrue("allocated $bytes", bytes < 8 * 1024)
}
}
+52
View File
@@ -0,0 +1,52 @@
# Orbit Rush: prototype (0.119.0, versionCode 310, 9 November 2026)
From Paul's idea, built as the small prototype he agreed to: to try for feel on the TV before any artwork. On top of
0.118.0 (309, installed downstairs). Not installed; nothing seen running.
## What's in it
- **The run:** Blaze flies forward on his own down **three lanes** through **Asteroid Alley**, a static storm behind. He
gets a little quicker the further he goes.
- **The remote:** ◀▶ change lane, ▲ rises, ▼ dives, OK uses the power-up, Back pauses (nothing is held, so Back by context
is a plain pause). Every move acts on the press. Lanes repeat on a held key; rise and dive don't.
- **Three hazards**, plain shapes in their own colours (nothing like Orbiteroids' grey rocks and debris):
| Hazard | Shape | Way past it |
|---|---|---|
| Rock | an orange boulder | it blocks its lane at every height, so change lane |
| Low satellite | a wide blue bar along the track | rise over it |
| Tall signal gate | pink posts and a bar overhead | dive under it |
- **Lane warnings:** before each hazard its lane lights in a colour, red for change lane, yellow for rise, cyan for dive.
It's shown at least half a second before arrival even at the top speed on Tricky.
- **Never boxed in:** every row has a free lane or a way over or under.
- **The power-up:** Orbit Shield is picked up and held, and OK puts it on for 6 seconds, during which hits bounce off.
- **Stars:** collected for score (10 each).
- **The static storm:** three hull bars; each hit costs one and brings the storm closer (a grey band along the bottom).
The third ends the run.
- **Difficulty:** Gentle is slower with one hazard a row and more room between rows; Tricky is quicker with closer rows
and two hazards more often.
- **Reduce motion:** the dashes and the storm's static hold still. **Reduce flashing:** the warnings are steady.
- **2.5D:** a perspective track in Canvas.
- The sky and the lanes are drawn once in their own layer.
- Each frame draws the moving dashes, the hazards (scaled by distance, far ones first) and Blaze's rocket (Orbi-Raiders'
rocket with Blaze in the porthole).
- **Screens:** the shared title (with "AN ORBIT ARCADE ORIGINAL · PROTOTYPE"), pause and result.
- **Saves:** its own High Scores per profile (points: distance plus stars). Kids-suitable.
## Checks (`RushSimTest`)
- **A bot can dodge everything:** a careful player reacting a quarter of a second after each warning takes **no hits in
three minutes** on Gentle, Normal and Tricky, six runs each.
- **Each hazard wants its own move:** rising doesn't get past a rock, and diving doesn't get under a low satellite.
- The shield is held until OK, then takes a hit.
- Three hits end the run, and the storm closes in.
- **0 bytes allocated over 10,000 steps.**
- **Unit tests:** 1,081 run, 24 skipped, 0 failed.
- **Lint:** 0 errors, 87 warnings (none new).
- **Release APK:** 48,268,891 bytes (+16,376 on 0.118.0).
## For after Paul's try
Artwork, more regions (Broadcast Boulevard, The Static Zone, The Forbidden Frequency's 999 portal), a choice of pilot
with their own abilities, more power-ups, and sounds.