-- Insert Coin:  a demo for Singe, to "Game Is On" by poorartistt.
--
-- Forty years of video games in four minutes, an era to a section of the song:  a phosphor bat and
-- ball, aliens in formation that step on the beat, a sixteen-bit runner over parallax hills and a
-- kart round a track seen in perspective, a tape loading, flat-shaded polygons with their wobble, modern glass
-- and chrome and physics, a countdown to continue, a boss in a storm of bullets, a bonus stage, the
-- high score table, and every era again, faster, at the end.
--
-- Everything moves on the music:  the aliens step on the beat, the ball meets the bats on the beat,
-- the runner jumps on the snare, the boss fires on the kick, the hats, and the snare.
dofile("Singe/Framework.singe")
local K = dofile(DIR .. "../kit.lua")

local FOV        = 60
local PHOSPHOR   = { 70, 255, 140 }
local NEON       = { { 255, 60, 90 }, { 255, 170, 40 }, { 255, 240, 70 }, { 70, 230, 120 }, { 60, 180, 255 }, { 190, 90, 255 } }
-- The high score table near the end:  edit it freely.  Rows show top to bottom in the order written
-- here, ranked 1ST, 2ND, and so on;  any number of rows fits, and a name too long for the column is
-- drawn smaller.  Scores show as six digits.
local HIGH_SCORES = {
	{ "SINGE",    999990 },
	{ "MAME",     874350 },
	{ "STELLA",   762100 },
	{ "VICE",     658400 },
	{ "DAPHNE",   541750 },
	{ "DOSBOX",   433200 },
	{ "FCEUX",    356900 },
	{ "SNES9X",   284150 },
	{ "MEDNAFEN", 197600 },
	{ "HYPSEUS",  121050 },
}

-- The big scroller that runs over the whole demo until the recap:  what this is, and what Singe does.
local FEATURE_TEXT = "YOU ARE WATCHING INSERT COIN, A DEMO OF THE SINGE GAME ENGINE  ...  EVERYTHING HERE RUNS LIVE, IN REAL TIME, TIMED TO THE MUSIC BEAT BY BEAT  ...  SINGE PLAYS LASERDISC GAMES AND MAKES NEW ONES  ...  GAMES ARE WRITTEN IN LUA  ...  SPRITES SCALE, TURN, TINT, AND GLOW  ...  VIDEO IN ALMOST ANY FORMAT, HARDWARE DECODED  ...  A 3D ENGINE WITH GLTF MODELS, LIGHTS, SHADOWS, BLOOM, AND FOG  ...  PHYSICS, CLOTH, ROPES, RAGDOLLS, AND VEHICLES  ...  PARTICLES IN 2D AND 3D  ...  GUIS, MIDI, AND THE MICROPHONE  ...  LIGHT GUNS AND EVERY KIND OF CONTROLLER  ...  ONLINE HIGH SCORES  ...  IT RECORDS ITS OWN VIDEO  ...  ONE FILE PER GAME  ...  WINDOWS, MACOS, LINUX, RASPBERRY PI, AND HANDHELDS  ...  SINGE  ...  "
local FEATURE_ALPHA = 190             -- How see-through its letters are:  0 to 255
local FEATURE_CELL  = 12              -- A block of its letters, in pixels, as a letter rests

local ART_DENSITY = 2.25               -- The boss's, its bullets', and the targets' pixels to a design unit (util/insertCoinArt.py DENSITY)
local FX_W        = 320                -- The live plasma's and tunnel's size, stretched to wherever they are shown
local FX_H        = 240
local TUNNEL_LAP  = 4                  -- The tunnel's travel counts a lap of its texture as this many passes
local PLASMA_STOPS = { { 0.00, { 0, 0, 20 } }, { 0.25, { 10, 40, 160 } }, { 0.50, { 20, 200, 120 } }, { 0.70, { 240, 240, 60 } }, { 0.85, { 255, 255, 255 } }, { 1.00, { 0, 0, 20 } } }
local TUNNEL_STOPS = { { 0.00, { 0, 0, 20 } }, { 0.30, { 10, 40, 160 } }, { 0.55, { 20, 200, 120 } }, { 0.80, { 240, 240, 60 } }, { 1.00, { 255, 255, 255 } } }
local ALIEN_COLS = 10
local ALIEN_ROWS = 5
local RING_EVERY = 14            -- World units between rings in the polygon era:  one passes each beat
-- The vector era:  a field of the camera's view at z = 0, and the asteroids' sizes.
local VEC_HALF_W   = 30
local VEC_HALF_H   = 23
local VEC_SIZES    = { 3.2, 1.9, 1.0 }    -- Radius of a large, a medium, and a small asteroid
local VEC_POOL     = { 6, 12, 24 }        -- How many of each the field can hold
local VEC_EDGE     = 0.14                 -- How thick a glowing line is
local VEC_SHOTS    = 24
local VEC_TURN     = 540                  -- Degrees a second the ship turns to aim
-- The light-gun era:  three rails of targets, each sliding across in RAIL_BEATS beats.
local RAILS        = { 150, 255, 360 }
local RAIL_BEATS   = 4
local RAIL_GAP     = 210                  -- Pixels from one target to the next on a rail
-- The versus era.
local FIGHTER_SCALE = 4
local FIGHTER_FRAME = 40
local FIGHT_DAMAGE  = 0.03
-- The rhythm era:  the highway's lanes, what they are fed from, and how far ahead notes show.
local RHYTHM_LANES  = { { list = "kicks", label = "KICK", rgb = { 255, 70, 90 } }, { list = "snares", label = "SNARE", rgb = { 80, 220, 255 } }, { list = "hats", label = "HAT", rgb = { 255, 220, 70 } } }
local RHYTHM_LOOK   = 1.6                 -- Seconds of notes on the highway
local RHYTHM_TOP    = 120                 -- Where the highway meets the horizon
local RHYTHM_HIT    = 400                 -- The hit line
local RHYTHM_SPAN   = 130                 -- Pixels between lanes at the hit line

local KART_HEIGHT = 3.2          -- The rival karts' height in the racer's world
local KART_SCALE  = 4            -- The player's kart:  screen pixels a pixel of its picture
local KART_W      = 48           -- The kart pictures' size
local KART_H      = 29
local GATE_RADIUS = 4.5          -- The gates' size:  tight enough that the ship has to thread them
local COIN_ALIVE  = 60           -- Coins in the bonus stage at once;  the oldest are swept away first
local COIN_BELT   = 11           -- World units a second the tunnel floor carries a coin, at its slowest
local COIN_RATE   = 4            -- Coins dropped a beat
local COIN_RADIUS = 1.0
local COIN_THICK  = 0.2
local BRICK_COLS = 9
local BRICK_ROWS = 6

local sync  = K.load(DIR)
local W     = K.W                    -- The screen in design units:  480 tall (kit.lua)
local H     = K.H
local beat  = sync.beats[3] - sync.beats[2]
local art   = {}
local world = {}
local lastT = 0


-- 1ST, 2ND, 3RD, 4TH ... 11TH, 12TH, 13TH ... 21ST.
local function ordinal(n)
	local last = n % 10
	local suffix = "TH"

	if (n % 100 < 11) or (n % 100 > 13) then
		suffix = ({ "ST", "ND", "RD" })[last] or "TH"
	end
	return n .. suffix
end


-- Pixel drawing ------------------------------------------------------------------------------------

-- Pixel art is drawn a whole number of the window's pixels to each of its own, the nearest to scale
-- design units, so every art pixel is the same size and crisp on any screen.
local function pixels(scale)
	return math.max(1, math.floor(scale * K.S + 0.5))
end


-- Frame frame of a sheet of frames frameW wide, at x, y, scale design units a pixel.
local function px(sprite, frameW, frame, x, y, scale)
	local h    = spriteGetHeight(sprite)
	local size = pixels(scale)
	local rx   = math.floor(x * K.S)
	local ry   = math.floor(y * K.S)

	spriteDrawGrid(sprite, rx, ry, frame * frameW, 0, frameW, h, rx + frameW * size - 1, ry + h * size - 1)
end


-- How wide text in the 8 by 8 font is at scale, in design units.
local function ptextWidth(text, scale)
	return #text * 8 * pixels(scale) / K.S
end


-- Text in the 8 by 8 font, scale design units a pixel.  align "center" centres it on x.
local function ptext(x, y, text, scale, r, g, b, align)
	local size = pixels(scale)
	local rx   = 0
	local ry   = math.floor(y * K.S)

	if align == "center" then
		x = x - ptextWidth(text, scale) / 2
	end
	rx = math.floor(x * K.S)
	spriteSetTint(art.font, r, g, b)
	for i = 1, #text do
		local c = text:byte(i) - 32

		if c > 0 and c < 96 then
			spriteDrawGrid(art.font, rx + (i - 1) * 8 * size, ry, (c % 16) * 8, (c // 16) * 8, 8, 8, rx + i * 8 * size - 1, ry + 8 * size - 1)
		end
	end
	spriteSetTint(art.font, 255, 255, 255)
end


-- The same, each letter its own colour round the wheel, cycling:  the high score table's rainbow.
local function rainbow(x, y, text, scale, t, align)
	local step = ptextWidth("X", scale)

	if align == "center" then
		x = x - ptextWidth(text, scale) / 2
	end
	for i = 1, #text do
		local r, g, b = K.hue(i * 0.06 - t * 0.8)

		ptext(x + (i - 1) * step, y, text:sub(i, i), scale, r, g, b)
	end
end


-- A CRT's scanlines over everything:  one screen row in three darkened.
local function scanlines(alpha)
	K.cover(art.scanlines, discGetHeight() / spriteGetHeight(art.scanlines), alpha)
end


-- Loading --------------------------------------------------------------------------------------------

local function loadArt()
	for _, name in ipairs({ "invaderA", "invaderB", "cannon", "runner", "coin", "ship", "kart", "font", "mountains", "hills", "ground", "scanlines", "fighterA", "fighterB" }) do
		art[name] = spriteLoad(DIR .. "art/" .. name .. ".png")
	end
	for _, name in ipairs({ "bossCore", "bossArm", "turret", "bullet", "target" }) do
		art[name] = K.sprite(DIR .. "art/" .. name .. ".png", ART_DENSITY)
	end
	spriteQuality(art.bossCore, RENDER_SMOOTH)
	spriteQuality(art.bossArm, RENDER_SMOOTH)
	-- The plasma and the tunnel, worked out live in Lua a frame at a time.
	art.plasma = K.plasmaNew(FX_W, FX_H, PLASMA_STOPS)
	art.tunnel = K.tunnelNew(FX_W, FX_H, TUNNEL_STOPS)

	-- Explosions on the overlay:  square sparks added over everything.
	art.boom = emitterNew()
	emitterSetBlend(art.boom, PARTICLE_ADD)
	emitterSetRate(art.boom, 0)
	emitterSetLife(art.boom, 0.3, 0.9)
	emitterSetSpeed(art.boom, 60 * K.S, 320 * K.S)
	emitterSetSpread(art.boom, 180)
	emitterSetDrag(art.boom, 2)
	emitterSetSize(art.boom, 9 * K.S, 2 * K.S)
	emitterSetMax(art.boom, 4000)
	emitterStart(art.boom)
end


local function boom(x, y, count, r, g, b)
	emitterSetPosition(art.boom, x * K.S, y * K.S)
	emitterSetColor(art.boom, 255, 255, 255, 255, r, g, b, 0)
	emitterBurst(art.boom, count)
end


-- The world --------------------------------------------------------------------------------------------

local function flatMesh(verts, faces)
	local positions = {}
	local normals   = {}
	local indices   = {}

	for _, f in ipairs(faces) do
		local a = verts[f[1]]
		local b = verts[f[2]]
		local c = verts[f[3]]
		local ux = b[1] - a[1]
		local uy = b[2] - a[2]
		local uz = b[3] - a[3]
		local vx = c[1] - a[1]
		local vy = c[2] - a[2]
		local vz = c[3] - a[3]
		local nx = uy * vz - uz * vy
		local ny = uz * vx - ux * vz
		local nz = ux * vy - uy * vx
		local l  = math.sqrt(nx * nx + ny * ny + nz * nz) + 1e-9

		for _, p in ipairs({ a, b, c }) do
			positions[#positions + 1] = p[1]
			positions[#positions + 1] = p[2]
			positions[#positions + 1] = p[3]
			normals[#normals + 1]     = nx / l
			normals[#normals + 1]     = ny / l
			normals[#normals + 1]     = nz / l
			indices[#indices + 1]     = #positions / 3
		end
	end
	return meshNew(positions, normals, nil, indices)
end


-- A low-poly ship:  a few triangles, flat shaded, nose toward -Z.
local function shipMesh()
	local v = {
		{ 0, 0, -2.2 }, { -0.5, 0.15, 0.4 }, { 0.5, 0.15, 0.4 }, { 0, 0.5, 0.2 }, { 0, -0.2, 0.6 },
		{ -1.8, -0.05, 0.9 }, { 1.8, -0.05, 0.9 }, { 0, 0.15, 1.0 },
	}
	local f = {
		{ 1, 4, 2 }, { 1, 3, 4 }, { 1, 2, 5 }, { 1, 5, 3 }, { 2, 4, 8 }, { 4, 3, 8 }, { 2, 8, 5 }, { 3, 5, 8 },
		{ 2, 6, 5 }, { 3, 5, 7 }, { 2, 5, 6 }, { 3, 7, 5 },
	}

	return flatMesh(v, f)
end


local function octahedron(r)
	local v = { { r, 0, 0 }, { -r, 0, 0 }, { 0, r, 0 }, { 0, -r, 0 }, { 0, 0, r }, { 0, 0, -r } }
	local f = { { 1, 3, 5 }, { 5, 3, 2 }, { 2, 3, 6 }, { 6, 3, 1 }, { 5, 4, 1 }, { 2, 4, 5 }, { 6, 4, 2 }, { 1, 4, 6 } }

	return flatMesh(v, f)
end


local function buildRacer()
	local ground = materialNew()

	materialSetTexture(ground, spriteLoad(DIR .. "art/track.png"))
	materialSetFilter(ground, FILTER_NEAREST)
	materialSetUnlit(ground, true)
	world.track = nodeNew()
	nodeSetMesh(world.track, meshPlane(400, 400), ground)
	local skyMaterial = materialNew()

	materialSetTexture(skyMaterial, spriteLoad(DIR .. "art/raceSky.png"))
	materialSetUnlit(skyMaterial, true)
	materialSetDoubleSided(skyMaterial, true)
	world.raceSky = nodeNew()
	nodeSetMesh(world.raceSky, meshSphere(320, 32), skyMaterial)
	world.rivals = {}
	for i = 1, 5 do
		local n = nodeNew()

		-- A crisp picture on a quad that the racer turns to face the camera:  the same nearest-pixel look as the
		-- player's kart, where a sprite node would be smoothed.
		local m    = materialNew()
		local quad = nodeNew(n)

		materialSetTexture(m, spriteLoad(DIR .. "art/kart" .. i .. ".png"))
		materialSetFilter(m, FILTER_NEAREST)
		materialSetUnlit(m, true)
		materialSetDoubleSided(m, true)
		materialSetCutoff(m, 0.5)
		nodeSetMesh(quad, meshPlane(KART_HEIGHT * KART_W / KART_H, KART_HEIGHT), m)
		nodeSetRotation(quad, 90, 0, 0)
		world.rivals[i] = { node = n, offset = 0.12 + i * 0.09 }
	end
end


local function buildPolygons()
	local hull = materialNew()

	materialSetColor(hull, 200, 210, 230)
	materialSetRoughness(hull, 0.6)
	-- The ship turns on a pivot that faces along the path, and banks on its own node under it.
	world.shipPivot = nodeNew()
	world.ship = nodeNew(world.shipPivot)
	nodeSetMesh(world.ship, shipMesh(), hull)
	world.rings = {}
	world.ringMaterials = {}
	for i = 1, 6 do
		local m = materialNew()
		local c = NEON[i]

		materialSetColor(m, c[1] // 2, c[2] // 2, c[3] // 2)
		materialSetRoughness(m, 0.7)
		world.ringMaterials[i] = m
	end
	local ringMesh = meshTorus(GATE_RADIUS, 0.45, 6)

	-- Each gate is a pivot that faces along the path, with the hexagon stood up under it so it can
	-- turn in its own plane.
	world.gates = {}
	for i = 1, 14 do
		local n    = nodeNew()
		local ring = nodeNew(n)

		nodeSetMesh(ring, ringMesh, world.ringMaterials[(i - 1) % 6 + 1])
		world.rings[i] = n
		world.gates[i] = ring
	end
	local floorMaterial = materialNew()

	materialSetTexture(floorMaterial, spriteLoad(DIR .. "art/ground.png"))
	materialSetFilter(floorMaterial, FILTER_NEAREST)
	materialSetTiling(floorMaterial, 30, 30)
	materialSetColor(floorMaterial, 70, 55, 120)
	world.polyFloor = nodeNew()
	nodeSetMesh(world.polyFloor, meshPlane(300, 300, 4), floorMaterial)
	world.enemies = {}
	local enemyMaterial = materialNew()

	materialSetColor(enemyMaterial, 255, 80, 60)
	materialSetEmissive(enemyMaterial, 120, 20, 10)
	local enemyMesh = octahedron(1.2)

	for i = 1, 6 do
		local n = nodeNew()

		nodeSetMesh(n, enemyMesh, enemyMaterial)
		world.enemies[i] = n
	end
	world.shardAnchor = nodeNew()
	world.shards = emitterNew(world.shardAnchor)
	emitterSetRate(world.shards, 0)
	emitterSetLife(world.shards, 0.4, 1.0)
	emitterSetSpeed(world.shards, 6, 16)
	emitterSetSpread(world.shards, 180)
	emitterSetGravity(world.shards, 0, -10, 0)
	emitterSetSize(world.shards, 0.5, 0.1)
	emitterSetColor(world.shards, 255, 200, 80, 255, 255, 60, 20, 0)
	emitterSetBlend(world.shards, PARTICLE_ADD)
	emitterStart(world.shards)
	world.light = lightNew(LIGHT_DIRECTIONAL)
	nodeSetPosition(world.light, 3, 8, 4)
	nodeLookAt(world.light, 0, 0, 0)
	lightSetIntensity(world.light, 0)
end


-- The modern era:  a wall of glossy bricks on a dark floor, and chrome balls to knock it down.
local function buildModern()
	local floorMaterial = materialNew()

	materialSetColor(floorMaterial, 30, 30, 40)
	materialSetMetallic(floorMaterial, 0.8)
	materialSetRoughness(floorMaterial, 0.15)
	world.modernFloor = nodeNew()
	nodeSetMesh(world.modernFloor, meshBox(60, 0.4, 60), floorMaterial)
	nodeSetPosition(world.modernFloor, 0, -0.2, 0)
	bodyNew(world.modernFloor, BODY_STATIC, SHAPE_BOX, 60, 0.4, 60)
	world.brickMaterials = {}
	for i, c in ipairs(NEON) do
		local m = materialNew()

		materialSetColor(m, c[1], c[2], c[3])
		materialSetMetallic(m, 0.3)
		materialSetRoughness(m, 0.12)
		world.brickMaterials[i] = m
	end
	world.brickMesh = meshBox(1.2, 0.6, 0.6)
	world.bricks = {}
	world.ballMesh = meshSphere(0.45, 24)
	world.ballMaterial = K.chrome(240, 240, 250, 0.04)
	world.balls = {}
	world.spark = nodeNew()
	world.sparks = emitterNew(world.spark)
	emitterSetBlend(world.sparks, PARTICLE_ADD)
	emitterSetRate(world.sparks, 0)
	emitterSetLife(world.sparks, 0.3, 0.8)
	emitterSetSpeed(world.sparks, 2, 7)
	emitterSetSpread(world.sparks, 180)
	emitterSetGravity(world.sparks, 0, -9, 0)
	emitterSetSize(world.sparks, 0.08, 0.02)
	emitterSetColor(world.sparks, 255, 240, 200, 255, 255, 120, 40, 0)
	emitterSetTrail(world.sparks, 5, 0.03)
	emitterStart(world.sparks)
	world.sun = lightNew(LIGHT_DIRECTIONAL)
	nodeSetPosition(world.sun, -6, 10, 8)
	nodeLookAt(world.sun, 0, 0, 0)
	lightSetIntensity(world.sun, 0)
	lightSetShadow(world.sun, true)
end


local function buildBonus()
	local tunnel = materialNew()

	world.tunnelMaterial = tunnel
	materialSetTexture(tunnel, art.tunnel.sprite)
	materialSetUnlit(tunnel, true)
	materialSetDoubleSided(tunnel, true)
	world.tunnel = K.screenQuad(world.camera, FOV, tunnel, 80, true)
	-- A coin is a gold rim and two struck faces:  the name on one side and the dragon on the other.
	world.coinMesh = meshCylinder(COIN_RADIUS, COIN_THICK, 24)
	world.coinMaterial = K.chrome(255, 200, 60, 0.25)
	materialSetEmissive(world.coinMaterial, 150, 100, 10)
	world.faceMesh = K.disc(COIN_RADIUS, 32)
	world.faceMaterials = {}
	for i, file in ipairs({ "coinSinge.png", "coinDragon.png" }) do
		local m     = materialNew()
		local image = spriteLoad(DIR .. "art/" .. file)

		materialSetTexture(m, image)
		materialSetEmissiveMap(m, image)
		materialSetEmissive(m, 150, 120, 60)
		materialSetMetallic(m, 0.8)
		materialSetRoughness(m, 0.3)
		world.faceMaterials[i] = m
	end
	world.coins = {}
	-- The tunnel's floor, which nobody sees:  a long slab the coins land on, running from far down
	-- the tunnel to behind the camera.  It waits out of the way until the bonus stage.
	world.coinFloor = nodeNew()
	nodeSetPosition(world.coinFloor, 0, -200, 0)
	bodyNew(world.coinFloor, BODY_KINEMATIC, SHAPE_BOX, 24, 0.4, 140)
end


-- The vector era:  every line a thin glowing box, so bloom makes it glow as a vector monitor's beam
-- did.  Asteroids are outlines of ten jagged points, a pool of each size;  the ship is a triangle.
local function edge(parent, x1, y1, x2, y2)
	local n  = nodeNew(parent)
	local dx = x2 - x1
	local dy = y2 - y1

	nodeSetMesh(n, world.vecEdge, world.vecGlow)
	nodeSetPosition(n, (x1 + x2) / 2, (y1 + y2) / 2, 0)
	nodeSetRotation(n, 0, 0, math.deg(math.atan(dy, dx)))
	nodeSetScale(n, math.sqrt(dx * dx + dy * dy) + VEC_EDGE, VEC_EDGE, VEC_EDGE)
	return n
end


local function buildVector()
	world.vecEdge = meshBox(1, 1, 1)
	world.vecGlow = materialNew()
	materialSetColor(world.vecGlow, 0, 0, 0)
	materialSetEmissive(world.vecGlow, 210, 235, 255)
	world.vecField = nodeNew()
	world.asteroids = {}
	for size, count in ipairs(VEC_POOL) do
		for i = 1, count do
			local n      = nodeNew(world.vecField)
			local points = {}

			for p = 0, 9 do
				local a = p / 10 * 2 * math.pi
				local r = VEC_SIZES[size] * (0.55 + 0.45 * ((p * 7 + i * 13 + size * 5) % 11) / 10)

				points[#points + 1] = { math.cos(a) * r, math.sin(a) * r }
			end
			for p = 1, #points do
				local q = points[p % #points + 1]

				edge(n, points[p][1], points[p][2], q[1], q[2])
			end
			nodeSetVisible(n, false)
			world.asteroids[#world.asteroids + 1] = { node = n, size = size, alive = false }
		end
	end
	world.vecShip = nodeNew(world.vecField)
	edge(world.vecShip, 1.6, 0, -1.1, 0.95)
	edge(world.vecShip, 1.6, 0, -1.1, -0.95)
	edge(world.vecShip, -0.7, 0.75, -0.7, -0.75)
	world.vecFlame = nodeNew(world.vecShip)
	edge(world.vecFlame, -0.7, 0.4, -1.7, 0)
	edge(world.vecFlame, -0.7, -0.4, -1.7, 0)
	world.vecShots = {}
	for i = 1, VEC_SHOTS do
		local n = nodeNew(world.vecField)

		nodeSetMesh(n, world.vecEdge, world.vecGlow)
		nodeSetScale(n, 0.35, 0.35, 0.35)
		world.vecShots[i] = { node = n, alive = false }
	end
	world.vecBurstAt = nodeNew()
	world.vecBurst = emitterNew(world.vecBurstAt)
	emitterSetBlend(world.vecBurst, PARTICLE_ADD)
	emitterSetRate(world.vecBurst, 0)
	emitterSetLife(world.vecBurst, 0.4, 0.9)
	emitterSetSpeed(world.vecBurst, 6, 22)
	emitterSetSpread(world.vecBurst, 180)
	emitterSetSize(world.vecBurst, 0.3, 0.05)
	emitterSetColor(world.vecBurst, 255, 255, 255, 255, 160, 210, 255, 0)
	emitterStart(world.vecBurst)
	nodeSetVisible(world.vecField, false)
end


local function buildWorld()
	sceneEnable(true)
	sceneSetSky(DIR .. "art/duskSky.png")
	sceneSetBloom(0.8, 0.5)
	sceneSetAmbient(40, 40, 50)
	world.camera = nodeNew()
	cameraSet(world.camera)
	cameraSetPerspective(FOV, 0.1, 800)
	K.screen(world.camera, FOV, 800)
	art.blocks = K.blockFont(dofile(DIR .. "art/font.lua"), world.camera, FOV, FEATURE_CELL, FEATURE_ALPHA)
	buildRacer()
	buildPolygons()
	buildModern()
	buildBonus()
	buildVector()
end


local function hideAll()
	for _, n in ipairs({ world.track, world.raceSky, world.shipPivot, world.polyFloor, world.modernFloor, world.tunnel }) do
		nodeSetVisible(n, false)
	end
	for _, r in ipairs(world.rivals) do
		nodeSetVisible(r.node, false)
	end
	for _, n in ipairs(world.rings) do
		nodeSetVisible(n, false)
	end
	for _, n in ipairs(world.enemies) do
		nodeSetVisible(n, false)
	end
	nodeSetVisible(world.vecField, false)
	lightSetIntensity(world.light, 0)
	lightSetIntensity(world.sun, 0)
	sceneSetFog()
	sceneSetSkyIntensity(1)
	-- Behind a 2D era the 3D layer is plain black.
	nodeSetPosition(world.camera, 0, -500, 0)
	nodeLookAt(world.camera, 0, -500, -1)
end


-- The eras ----------------------------------------------------------------------------------------------
-- Each is a scene table without its bars, so the finale can run them again:  enter, draw(t, bar,
-- k), and leave.  An era's own time is the music's, so whatever it plays lands on the beat wherever
-- it is placed, as long as it is placed on a whole bar.

local ERA = {}

-- Switching on:  the tube warms up from a line, INSERT COIN blinks on the beat, and a coin spins
-- down into the slot on the downbeat of bar 5.
ERA.boot = {
	enter = function(t)
		hideAll()
	end,
	draw = function(t, bar, k)
		K.fill(0, 0, 0)
		local warm = K.smooth(1, 1.6, bar)

		if warm < 1 then
			local h = math.max(2, H * warm * warm)

			K.box(0, H / 2 - h / 2, W - 1, H / 2 + h / 2, 255, 255, 255, math.floor(255 * (1 - warm * 0.85)))
			return
		end
		if (K.beat(t) % 1) < 0.5 then
			ptext(W / 2, 200, "INSERT COIN", 5, 255, 255, 255, "center")
		end
		local land = K.barTime(5)
		local fall = K.clamp((t - (land - beat * 4)) / (beat * 4), 0, 1)
		local cy   = K.lerp(-60, 320, fall * fall)
		local spin = math.floor(t * 12) % 4

		if fall < 1 then
			px(art.coin, 8, spin, W / 2 - 32, cy, 8)
		end
		K.box(W / 2 - 40, 392, W / 2 + 40, 402, 90, 90, 100, 255)
		ptext(W / 2, 430, (fall >= 1) and "CREDIT 1" or "CREDIT 0", 3, 255, 220, 80, "center")
		scanlines(160)
	end,
}

-- Analog:  two bats and a ball in green phosphor.  The ball crosses the court once a beat, so it meets
-- a bat on every beat, and its afterglow trails behind it.
ERA.pong = {
	enter = function(t)
		hideAll()
		world.pongScore = { 0, 0 }
	end,
	draw = function(t, bar, k)
		K.fill(0, 6, 2)
		local b     = K.beat(t)
		local left  = 60
		local right = W - 60

		for y = 20, H - 20, 24 do
			K.box(W / 2 - 3, y, W / 2 + 3, y + 12, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], 160)
		end
		local function ballAt(beatPos)
			local whole = math.floor(beatPos)
			local p     = beatPos - whole
			local x     = (whole % 2 == 0) and K.lerp(left + 12, right - 12, p) or K.lerp(right - 12, left + 12, p)
			local tri   = (beatPos * 0.37) % 2

			tri = (tri < 1) and tri or (2 - tri)
			return x, K.lerp(40, H - 40, tri)
		end
		for g = 6, 1, -1 do
			local gx, gy = ballAt(b - g * 0.02)

			K.box(gx - 7, gy - 7, gx + 7, gy + 7, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], 30 + (6 - g) * 20)
		end
		local x, y = ballAt(b)

		K.box(x - 8, y - 8, x + 8, y + 8, 220, 255, 230, 255)
		local _, ly = ballAt(math.floor(b) + ((math.floor(b) % 2 == 0) and 0 or 1))
		local _, ry = ballAt(math.floor(b) + ((math.floor(b) % 2 == 0) and 1 or 0))

		K.box(left - 10, ly - 40, left, ly + 40, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], 255)
		K.box(right, ry - 40, right + 10, ry + 40, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], 255)
		local points = math.floor(b / 4)

		ptext(W / 2 - 80, 30, string.format("%02d", points % 100), 6, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], "center")
		ptext(W / 2 + 80, 30, string.format("%02d", (points * 3) % 100), 6, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], "center")
		K.strobe(t, "kicks", 20, PHOSPHOR[1], PHOSPHOR[2], PHOSPHOR[3], 30)
		scanlines(200)
	end,
}

-- 8-bit:  a formation of aliens that steps on every beat, the cannon below firing on every snare and
-- taking out the lowest alien above it.
local function alienPositions(step)
	local cycle = step % 40
	local dx    = (cycle < 20) and cycle or (40 - cycle)

	return 48 + dx * 8, 60 + math.floor(step / 20) * 16
end


ERA.invaders = {
	enter = function(t)
		hideAll()
		world.alive = {}
		for i = 1, ALIEN_COLS * ALIEN_ROWS do
			world.alive[i] = true
		end
		world.shots     = {}
		world.alienBase = K.beat(t)
	end,
	draw = function(t, bar, k)
		K.fill(0, 0, 8)
		local step   = math.floor(K.beat(t) - world.alienBase)
		local ox, oy = alienPositions(step)
		local frame  = step % 2
		local cannonX = W / 2 + math.sin(t * 1.4) * 220

		-- On a snare, a shot from the cannon at the lowest alien in the column above it.
		if K.hitCount("snares", lastT, t) > 0 then
			local col = math.floor((cannonX - ox) / 52 + 0.5)

			if col >= 0 and col < ALIEN_COLS then
				for row = ALIEN_ROWS - 1, 0, -1 do
					local i = row * ALIEN_COLS + col + 1

					if world.alive[i] then
						world.shots[#world.shots + 1] = { x = cannonX, start = t, target = i }
						break
					end
				end
			end
		end
		for row = 0, ALIEN_ROWS - 1 do
			local c = NEON[row % #NEON + 1]
			local sprite = (row < 2) and art.invaderA or art.invaderB

			spriteSetTint(sprite, c[1], c[2], c[3])
			for col = 0, ALIEN_COLS - 1 do
				if world.alive[row * ALIEN_COLS + col + 1] then
					px(sprite, (row < 2) and 12 or 12, frame, ox + col * 52, oy + row * 40, 4)
				end
			end
			spriteSetTint(sprite, 255, 255, 255)
		end
		for i = #world.shots, 1, -1 do
			local s   = world.shots[i]
			local row = (s.target - 1) // ALIEN_COLS
			local col = (s.target - 1) % ALIEN_COLS
			local tx  = ox + col * 52 + 24
			local ty  = oy + row * 40 + 16
			local p   = (t - s.start) / (beat * 0.35)

			if p >= 1 then
				if world.alive[s.target] then
					world.alive[s.target] = false
					local c = NEON[row % #NEON + 1]

					boom(tx, ty, 60, c[1], c[2], c[3])
				end
				table.remove(world.shots, i)
			else
				local sx = K.lerp(s.x, tx, p)
				local sy = K.lerp(H - 70, ty, p)

				K.box(sx - 2, sy - 10, sx + 2, sy + 10, 255, 255, 255, 255)
			end
		end
		spriteSetTint(art.cannon, 80, 255, 120)
		px(art.cannon, 13, 0, cannonX - 26, H - 64, 4)
		spriteSetTint(art.cannon, 255, 255, 255)
		K.box(0, H - 28, W - 1, H - 26, 80, 255, 120, 255)
		ptext(20, 14, string.format("SCORE %05d", (ALIEN_COLS * ALIEN_ROWS - (function() local n = 0 for _, a in ipairs(world.alive) do if a then n = n + 1 end end return n end)()) * 50), 2, 255, 255, 255)
		emitterDraw(art.boom)
		scanlines(180)
	end,
}

-- 16-bit:  a runner over parallax hills.  The ground runs at a steady speed, the runner jumps on every
-- snare, as high as the note being played says, and the coins are placed where the jumps will take
-- him.
local RUN_SPEED = 260
local RUNNER_X  = 170

ERA.runner = {
	enter = function(t)
		hideAll()
		world.collected = {}
		world.runScore  = 0
	end,
	draw = function(t, bar, k)
		for i = 0, 11 do
			local r = 40 + i * 12
			local g = 90 + i * 12
			local b = 210 + i * 4

			K.box(0, i * 30, W - 1, i * 30 + 29, r, g, math.min(255, b), 255)
		end
		local function layer(sprite, speed, y, scale)
			local w      = K.width(sprite) * scale
			local offset = (t * speed) % w

			for x = -offset, W, w do
				K.draw(sprite, x, y, x + w, y + K.height(sprite) * scale)
			end
		end
		layer(art.mountains, RUN_SPEED * 0.15, 170, 2)
		layer(art.hills, RUN_SPEED * 0.4, 260, 2)
		layer(art.ground, RUN_SPEED, H - 96, 2)
		local groundY = H - 96 - 64
		local b       = K.beat(t)
		local jumpY   = 0

		-- Jumps on the backbeat:  beats 2 and 4 of each bar, a beat long.
		local whole = math.floor(b)
		local p     = b - whole

		if (whole - (sync.barStart - 1)) % 2 == 1 then
			local note = K.note(K.beatTime(whole))

			jumpY = 4 * p * (1 - p) * (90 + note * 8)
		end
		-- Coins at the top of every jump, a beat's worth of ground apart.
		for j = math.floor(b) - 2, math.floor(b) + 4 do
			if (j - (sync.barStart - 1)) % 2 == 1 then
				local apex = K.beatTime(j + 0.5)
				local cx   = RUNNER_X + 24 + (apex - t) * RUN_SPEED
				local note = K.note(K.beatTime(j))
				local cy   = groundY - (90 + note * 8) + 8

				if t < apex then
					px(art.coin, 8, math.floor(t * 10) % 4, cx, cy, 4)
				elseif not world.collected[j] then
					world.collected[j] = true
					world.runScore = world.runScore + 100
					boom(RUNNER_X + 32, cy + 16, 30, 255, 230, 80)
				end
			end
		end
		local frame = (jumpY > 0) and 4 or (math.floor(b * 4) % 4)

		px(art.runner, 16, frame, RUNNER_X, groundY - jumpY, 4)
		ptext(20, 14, string.format("COINS %03d", world.runScore // 100), 2, 255, 255, 255)
		ptext(W - 20 - 9 * 16, 14, string.format("WORLD 1-%d", math.floor(bar - 16) // 2 + 1), 2, 255, 255, 255)
		emitterDraw(art.boom)
	end,
}

-- 16-bit, the other trick:  a kart on a flat track seen in perspective, the sky turning with it.  It
-- laps once every four bars.
local function trackPoint(a)
	return math.cos(a) * 144, math.sin(a) * 104
end


ERA.racer = {
	enter = function(t)
		hideAll()
		nodeSetVisible(world.track, true)
		nodeSetVisible(world.raceSky, true)
		for _, r in ipairs(world.rivals) do
			nodeSetVisible(r.node, true)
		end
		world.raceBase = t
	end,
	draw = function(t, bar, k)
		local lap = (bar - 1) / 4
		local a   = lap * 2 * math.pi
		local x, z = trackPoint(a)
		local ax, az = trackPoint(a + 0.08)

		nodeSetPosition(world.camera, x, 4.5, z)
		nodeLookAt(world.camera, ax, 3.2, az)
		nodeSetPosition(world.raceSky, x, 0, z)
		for i, r in ipairs(world.rivals) do
			local ra = a + r.offset + 0.02 * math.sin(t * 2 + i)
			local rx, rz = trackPoint(ra)

			local px2 = rx + math.sin(i * 2.1) * 6
			local pz2 = rz + math.cos(i * 1.7) * 6

			-- Turned square to the camera, level, so the picture is never seen edge on.
			nodeSetPosition(r.node, px2, 1.4, pz2)
			nodeLookAt(r.node, px2 + (px2 - x), 1.4, pz2 + (pz2 - z))
		end
		local lean = math.sin(a * 2) * 8

		-- The player's kart, crisp, frame 1 of the sheet, sliding with the lean rather than turning.
		px(art.kart, KART_W, 0, W / 2 - KART_W / 2 * KART_SCALE + lean * 2, H - 30 - KART_H * KART_SCALE, KART_SCALE)
		ptext(20, 14, string.format("LAP %d/3", math.floor(lap) % 3 + 1), 3, 255, 255, 255)
		ptext(W - 20 - 6 * 24, 14, string.format("POS %d", 6 - math.floor(lap * 1.5) % 5), 3, 255, 240, 80)
		local laps = (t - world.raceBase)

		ptext(W - 20 - 8 * 16, 48, string.format("%02d\"%02d", math.floor(laps) % 60, math.floor(laps * 100) % 100), 2, 255, 255, 255)
	end,
	leave = function(t)
	end,
}

-- Loading:  a tape loading, the border awash with stripes, a bar filling to the riser.
ERA.loading = {
	enter = function(t)
		hideAll()
	end,
	draw = function(t, bar, k)
		local border = { { 20, 20, 120 }, { 255, 255, 80 }, { 60, 200, 200 }, { 200, 60, 200 }, { 255, 140, 60 }, { 255, 255, 255 }, { 40, 40, 40 } }
		local seed   = math.floor(t * 50)
		local band   = 3 + math.floor(6 * (1 - k))

		for y = 0, H - 1, band do
			local c = border[((seed * 31 + y * 7) // band) % #border + 1]

			K.box(0, y, W - 1, y + band - 1, c[1], c[2], c[3], 255)
		end
		K.box(64, 56, W - 65, H - 57, 60, 60, 200, 255)
		ptext(96, 90, "PRESS PLAY ON TAPE", 2, 160, 160, 255)
		ptext(96, 130, "OK", 2, 160, 160, 255)
		ptext(96, 170, "SEARCHING", 2, 160, 160, 255)
		ptext(96, 210, "FOUND GAME", 2, 160, 160, 255)
		ptext(96, 250, "LOADING", 2, 160, 160, 255)
		if (t * 3) % 1 < 0.5 then
			K.box(96 + 8 * 16, 250, 96 + 8 * 16 + 14, 265, 160, 160, 255, 255)
		end
		local fill = K.clamp(k, 0, 1)

		K.box(96, 320, W - 97, 350, 20, 20, 90, 255)
		K.box(98, 322, 98 + (W - 196 - 4) * fill, 348, 160, 160, 255, 255)
		ptext(W / 2, 370, string.format("%3d%%", math.floor(fill * 100)), 2, 255, 255, 255, "center")
		scanlines(120)
		if bar > 40.6 then
			K.flash(255, 255, 255, math.floor(255 * K.smooth(40.6, 41, bar)))
		end
	end,
}

-- 32-bit:  a flat-shaded ship flying a winding path through hexagonal gates, one gate a beat.  Each
-- gate stands on the path, facing along it and turning in its own plane, so the ship weaves through
-- them, banking into every turn;  every position is snapped to a coarse grid as the machines of the
-- time snapped theirs.  Enemy crystals wait along the path and burst on the snare.
local function snap(v)
	return math.floor(v * 12 + 0.5) / 12
end


-- The path, s world units along it:  across and up, and the depth, which is -s.
local function gatePath(s)
	return 7 * math.sin(s * 0.045) + 3 * math.sin(s * 0.11 + 1), 3 + 2.5 * math.sin(s * 0.033 + 2), -s
end


-- Puts a pivot on the path at s, facing along it.
local function onPath(node, s)
	local x, y, z    = gatePath(s)
	local ax, ay, az = gatePath(s + 2)

	nodeSetPosition(node, snap(x), snap(y), snap(z))
	nodeLookAt(node, ax, ay, az)
end


ERA.polygons = {
	enter = function(t)
		hideAll()
		nodeSetVisible(world.shipPivot, true)
		nodeSetVisible(world.polyFloor, true)
		for _, n in ipairs(world.rings) do
			nodeSetVisible(n, true)
		end
		lightSetIntensity(world.light, 3)
		sceneSetFog(30, 10, 50, 10, 120)
		sceneSetSkyIntensity(0)
		world.enemyBase = K.beat(t)
	end,
	draw = function(t, bar, k)
		local b     = K.beat(t)
		local s     = b * RING_EVERY
		local x0    = gatePath(s - 4)
		local x1    = gatePath(s)
		local x2    = gatePath(s + 4)
		local bank  = K.clamp((x0 - 2 * x1 + x2) * -60, -60, 60)
		local cx, cy, cz = gatePath(s - 7)
		local lx, ly, lz = gatePath(s + 12)

		-- The ship on the path, banked into the turn;  the camera on the path behind it.
		onPath(world.shipPivot, s)
		nodeSetRotation(world.ship, 0, 0, snap(bank))
		nodeSetPosition(world.camera, snap(cx), snap(cy + 1.8), snap(cz))
		nodeLookAt(world.camera, lx, ly + 0.6, lz)
		nodeSetPosition(world.polyFloor, 0, -6, -s - (-s % 20))
		local first = math.floor(b)

		for i, n in ipairs(world.rings) do
			local rb = first + i - 1

			onPath(n, rb * RING_EVERY)
			nodeSetRotation(world.gates[i], 90, rb * 15 + t * 40 * ((rb % 2 == 0) and 1 or -1), 0)
		end
		for i, m in ipairs(world.ringMaterials) do
			local v = K.decay("kicks", t, 6)
			local c = NEON[i]

			materialSetEmissive(m, math.floor(c[1] * v), math.floor(c[2] * v), math.floor(c[3] * v))
		end
		if bar >= 49 then
			for i, n in ipairs(world.enemies) do
				local eb    = math.floor(b) + i * 2
				local ex, ey, ez = gatePath(eb * RING_EVERY + RING_EVERY / 2)
				local alive = (eb + 0.5 - b) > 0.35

				nodeSetVisible(n, alive)
				nodeSetPosition(n, snap(ex + math.sin(eb * 1.7) * 2), snap(ey + math.cos(eb * 2.3) * 1.2), snap(ez))
				nodeSetRotation(n, t * 90, t * 130, 0)
			end
			if K.hitCount("snares", lastT, t) > 0 then
				local ax, ay, az = gatePath(s + 20)

				nodeSetPosition(world.shardAnchor, ax, ay, az)
				emitterBurst(world.shards, 80)
			end
		end
	end,
}

-- Now:  glass, chrome, and physics.  A wall of glossy bricks under a dusk sky, and on every kick a
-- chrome ball thrown into it;  the wall is built again at bar 69 and comes down harder.
local function buildWall()
	for _, b in ipairs(world.bricks) do
		bodyDelete(b)
		nodeDelete(b)
	end
	for _, b in ipairs(world.balls) do
		bodyDelete(b)
		nodeDelete(b)
	end
	world.bricks = {}
	world.balls  = {}
	for row = 0, BRICK_ROWS - 1 do
		for col = 0, BRICK_COLS - 1 do
			local n = nodeNew()

			nodeSetMesh(n, world.brickMesh, world.brickMaterials[(row + col) % #world.brickMaterials + 1])
			nodeSetPosition(n, (col - (BRICK_COLS - 1) / 2) * 1.25 + ((row % 2) * 0.62 - 0.31), 0.3 + row * 0.62, 0)
			bodyNew(n, BODY_DYNAMIC, SHAPE_BOX, 1.2, 0.6, 0.6)
			bodySetMass(n, 1)
			bodySetFriction(n, 0.8)
			world.bricks[#world.bricks + 1] = n
		end
	end
end


ERA.modern = {
	enter = function(t)
		hideAll()
		nodeSetVisible(world.modernFloor, true)
		lightSetIntensity(world.sun, 4)
		sceneSetSkyIntensity(1.2)
		buildWall()
		world.wallBuilt = K.bar(t)
	end,
	draw = function(t, bar, k)
		if bar >= 69 and world.wallBuilt < 69 then
			buildWall()
			world.wallBuilt = bar
		end
		local a = t * 0.12

		nodeSetPosition(world.camera, math.sin(a) * 7, 2.4 + math.sin(t * 0.3) * 0.6, 7.5 + math.cos(a) * 2)
		nodeLookAt(world.camera, 0, 1.6, 0)
		if K.hitCount("kicks", lastT, t) > 0 and #world.balls < 40 then
			local n = nodeNew()
			local tx = (math.random() - 0.5) * 8
			local ty = 0.5 + math.random() * 3

			nodeSetMesh(n, world.ballMesh, world.ballMaterial)
			nodeSetPosition(n, tx * 0.3, ty + 1.5, 14)
			bodyNew(n, BODY_DYNAMIC, SHAPE_SPHERE, 0.45)
			bodySetMass(n, (bar >= 69) and 8 or 4)
			bodySetVelocity(n, tx * 0.9, 1.2, -32)
			world.balls[#world.balls + 1] = n
		end
	end,
	leave = function(t)
		for _, b in ipairs(world.bricks) do
			bodyDelete(b)
			nodeDelete(b)
		end
		for _, b in ipairs(world.balls) do
			bodyDelete(b)
			nodeDelete(b)
		end
		world.bricks = {}
		world.balls  = {}
	end,
}

-- Game over, and a countdown to continue, a number a bar, glitching, until the coin goes in.
ERA.continue = {
	enter = function(t)
		hideAll()
	end,
	draw = function(t, bar, k)
		K.fill(0, 0, 0)
		local n = 8 - math.floor(bar - 73)

		if bar < 74 then
			ptext(W / 2, 200, "GAME OVER", 6, 255, 60, 60, "center")
		else
			ptext(W / 2, 80, "CONTINUE?", 4, 255, 255, 255, "center")
			local pulse = 1 + 0.15 * K.decay("snares", t, 6)
			local s     = math.floor(18 * pulse)
			local glitch = (math.random() < 0.15) and math.random(-20, 20) or 0

			ptext(W / 2 + glitch, 170, tostring(math.max(1, n)), s, 255, 220, 60, "center")
			for i = 1, 3 do
				local y = math.random(0, H)

				K.box(0, y, W - 1, y + math.random(1, 4), 255, 255, 255, math.random(20, 90))
			end
		end
		if bar > 80.25 then
			local p = K.smooth(80.25, 80.95, bar)

			px(art.coin, 8, math.floor(t * 12) % 4, W / 2 - 32, K.lerp(-60, 380, p * p), 8)
		end
		ptext(W / 2, 430, "CREDIT 0", 3, 255, 220, 80, "center")
		scanlines(160)
	end,
}

-- The boss:  a core and four turning arms with turrets, firing rings on the kick, spirals on the
-- hats, and aimed shots on the snare, while the ship below weaves and fires back.  Its health runs
-- out over eight bars, and it goes up on the last.
ERA.boss = {
	enter = function(t)
		hideAll()
		world.bullets = {}
		world.bossHit = 0
	end,
	draw = function(t, bar, k)
		K.plasmaUpdate(art.plasma, t)
		K.under(art.plasma.sprite, 0, 0, W, H, nil, nil, nil, nil, true)
		K.under(nil, 0, 0, W, H, 0, 0, 10, 200)
		local dt     = t - lastT
		local cx     = W / 2 + math.sin(t * 0.5) * 60
		local cy     = 150 + math.sin(t * 0.8) * 20
		local spin   = t * 40
		local shipX  = W / 2 + math.sin(t * 1.1) * 210 + math.sin(t * 2.7) * 40
		local shipY  = H - 70
		local dying  = bar >= 96

		-- Stars streaming past.
		for i = 1, 60 do
			local sy = (i * 97 + t * (60 + (i % 5) * 50)) % H
			local sx = (i * 173) % W

			K.box(sx, sy, sx + 1, sy + 1 + (i % 3), 255, 255, 255, 120 + (i % 4) * 30)
		end
		if not dying then
			if K.hitCount("kicks", lastT, t) > 0 then
				for i = 1, 20 do
					local a = i / 20 * 2 * math.pi + t

					world.bullets[#world.bullets + 1] = { x = cx, y = cy, vx = math.cos(a) * 150, vy = math.sin(a) * 150, c = 1 }
				end
			end
			if K.hitCount("hats", lastT, t) > 0 then
				for arm = 0, 3 do
					local a = math.rad(spin) + arm * math.pi / 2

					world.bullets[#world.bullets + 1] = { x = cx + math.cos(a) * 110, y = cy + math.sin(a) * 110, vx = math.cos(a + 1.2) * 180, vy = math.sin(a + 1.2) * 180, c = 2 }
				end
			end
			if K.hitCount("snares", lastT, t) > 0 then
				for i = -1, 1 do
					local a = math.atan(shipY - cy, shipX - cx) + i * 0.18

					world.bullets[#world.bullets + 1] = { x = cx, y = cy, vx = math.cos(a) * 240, vy = math.sin(a) * 240, c = 3 }
				end
			end
		end
		-- The arms and turrets, then the core over them, flashing white while it is being hit.
		local hitFlash = (math.floor(t * 30) % 2 == 0) and not dying

		for arm = 0, 3 do
			local a  = spin + arm * 90
			local ax = cx + math.cos(math.rad(a)) * 60
			local ay = cy + math.sin(math.rad(a)) * 60

			K.turn(art.bossArm, ax, ay, a)
			K.turn(art.turret, cx + math.cos(math.rad(a)) * 110, cy + math.sin(math.rad(a)) * 110, 0)
		end
		K.turn(art.bossCore, cx, cy, -spin * 0.5, 1.4 + 0.1 * K.decay("kicks", t, 8), 255, hitFlash and 200 or 255, hitFlash and 200 or 255)
		-- Bullets.
		local tints = { { 255, 80, 220 }, { 80, 230, 255 }, { 255, 230, 80 } }

		for i = #world.bullets, 1, -1 do
			local bl = world.bullets[i]

			bl.x = bl.x + bl.vx * dt
			bl.y = bl.y + bl.vy * dt
			if bl.x < -20 or bl.x > W + 20 or bl.y < -20 or bl.y > H + 20 then
				table.remove(world.bullets, i)
			else
				local c = tints[bl.c]

				spriteSetTint(art.bullet, c[1], c[2], c[3])
				K.draw(art.bullet, bl.x, bl.y, true)
			end
		end
		spriteSetTint(art.bullet, 255, 255, 255)
		-- The ship and its fire.
		for i = 0, 6 do
			local fy = shipY - ((t * 900 + i * 70) % 420)

			K.box(shipX - 2, fy, shipX + 2, fy + 12, 255, 255, 150, 255)
		end
		px(art.ship, 16, 0, shipX - 32, shipY - 32, 4)
		-- Health.
		local health = 1 - K.clamp((bar - 89) / 7, 0, 1)

		K.box(120, 18, W - 121, 30, 60, 0, 0, 255)
		K.box(122, 20, 122 + (W - 244 - 4) * health, 28, 255, 60, 60, 255)
		ptext(W / 2, 36, "BOSS", 2, 255, 255, 255, "center")
		if dying and K.hitCount("hats", lastT, t) > 0 then
			boom(cx + math.random(-90, 90), cy + math.random(-90, 90), 90, NEON[math.random(1, 6)][1], NEON[math.random(1, 6)][2], 60)
		end
		emitterDraw(art.boom)
		if bar > 96.85 then
			K.flash(255, 255, 255, math.floor(255 * K.smooth(96.85, 97, bar)))
		end
	end,
}

-- The bonus stage:  coins pour down further along the tunnel, COIN_RATE a beat, land on its floor, and the
-- tunnel's own motion carries them toward the camera and off the bottom of the screen;  every coin
-- that rides past counts.
ERA.bonus = {
	enter = function(t)
		hideAll()
		nodeSetVisible(world.tunnel, true)
		nodeSetPosition(world.coinFloor, 0, -3.2, -50)
		world.phase     = 0
		world.phaseT    = t
		world.bonusBase = t
		world.dropped   = 0
		world.collected = 0
		sceneSetSkyIntensity(1.4)
		lightSetIntensity(world.sun, 3)
	end,
	draw = function(t, bar, k)
		local push = 0.6 + 1.5 * K.decay("kicks", t, 5)

		nodeSetPosition(world.camera, 0, 0.5, 14)
		nodeLookAt(world.camera, 0, 0.5, -100)
		world.phase  = world.phase + (t - world.phaseT) * push
		world.phaseT = t
		K.tunnelUpdate(art.tunnel, (world.phase / TUNNEL_LAP) % 1, 0)
		materialSetTexture(world.tunnelMaterial, art.tunnel.sprite)
		nodeSetRotation(world.tunnel, 0, 0, t * 30)
		local due = math.floor((K.beat(t) - K.beat(world.bonusBase)) * COIN_RATE)

		while world.dropped < due do
			local n = nodeNew()

			world.dropped = world.dropped + 1
			nodeSetMesh(n, world.coinMesh, world.coinMaterial)
			for side = 1, 2 do
				local face = nodeNew(n)

				nodeSetMesh(face, world.faceMesh, world.faceMaterials[side])
				nodeSetPosition(face, 0, (side == 1) and (COIN_THICK / 2 + 0.005) or -(COIN_THICK / 2 + 0.005), 0)
				nodeSetRotation(face, 0, 0, (side == 1) and 0 or 180)
			end
			nodeSetPosition(n, (math.random() - 0.5) * 9, 7 + math.random() * 4, -30 - math.random() * 30)
			nodeSetRotation(n, math.random(0, 360), math.random(0, 360), 0)
			bodyNew(n, BODY_DYNAMIC, SHAPE_CYLINDER, COIN_RADIUS, COIN_THICK)
			bodySetMass(n, 0.3)
			bodySetBounce(n, 0.4)
			bodySetAngularVelocity(n, (math.random() - 0.5) * 12, (math.random() - 0.5) * 12, 0)
			world.coins[#world.coins + 1] = n
		end
		-- Coins on the floor ride the tunnel toward the camera at its speed;  past the camera they go.
		for i = #world.coins, 1, -1 do
			local n          = world.coins[i]
			local x, y, z    = nodeGetPosition(n)
			local vx, vy, vz = bodyGetVelocity(n)

			if z > 16 or #world.coins - i >= COIN_ALIVE then
				bodyDelete(n)
				nodeDelete(n)
				table.remove(world.coins, i)
				world.collected = world.collected + 1
			elseif y < -1.8 then
				bodySetVelocity(n, vx * 0.95, vy, COIN_BELT * push)
			end
		end
		ptext(W / 2, 30, "BONUS STAGE", 4, 255, 230, 80, "center")
		ptext(W / 2, 80, string.format("%07d", world.collected * 500), 4, 255, 255, 255, "center")
	end,
	leave = function(t)
		for _, n in ipairs(world.coins) do
			bodyDelete(n)
			nodeDelete(n)
		end
		world.coins = {}
		nodeSetPosition(world.coinFloor, 0, -200, 0)
	end,
}

-- The high score table, which is also the credits.
ERA.scores = {
	enter = function(t)
		hideAll()
	end,
	draw = function(t, bar, k)
		K.plasmaUpdate(art.plasma, t)
		K.under(art.plasma.sprite, 0, 0, W, H, nil, nil, nil, nil, true)
		K.under(nil, 0, 0, W, H, 0, 0, 20, 190)
		rainbow(W / 2, 40, "HIGH SCORES", 4, t, "center")
		-- Rows share the space under the title, centred in it, and appear one after another over the
		-- first half of the scene, however many there are.  The table is centred across the screen by
		-- its widest row;  a name too long for the screen is drawn a size smaller.
		local count   = #HIGH_SCORES
		local top     = 110
		local room    = H - 40 - top
		local spacing = math.min(52, room / math.max(count, 1))
		local scale   = (spacing >= 34) and 3 or 2
		local scoreAt = 100
		local nameAt  = 290
		local fit     = math.floor((W - 80 - nameAt) / ptextWidth("X", scale))
		local sizes   = {}
		local widest  = 0

		for i, row in ipairs(HIGH_SCORES) do
			local name = tostring(row[1])

			sizes[i] = (#name > fit) and math.max(1, scale - 1) or scale
			widest   = math.max(widest, ptextWidth(name, sizes[i]))
		end
		local left = (W - nameAt - widest) / 2

		top = top + (room - spacing * count) / 2
		for i, row in ipairs(HIGH_SCORES) do
			if bar >= 113 + (i - 1) * 4 / count then
				local y = top + (i - 1) * spacing

				ptext(left, y, ordinal(i), scale, 255, 255, 255)
				ptext(left + scoreAt, y, string.format("%06d", math.floor(row[2] or 0) % 1000000), scale, 255, 230, 80)
				rainbow(left + nameAt, y, tostring(row[1]):upper(), sizes[i], t + i * 0.3)
			end
		end
		scanlines(120)
	end,
	leave = function(t)
	end,
}

-- The end:  game over, thanks, and the set switched off on the last hit.
ERA.outro = {
	enter = function(t)
		hideAll()
	end,
	draw = function(t, bar, k)
		K.fill(0, 0, 0)
		local p    = t - K.barTime(137)
		local last = K.duration - 0.9

		if t < last then
			ptext(W / 2, 140, "GAME OVER", 7, 255, 60, 60, "center")
			if p > 2 then
				rainbow(W / 2, 260, "THANKS FOR PLAYING", 3, t, "center")
			end
			if p > 4 and (t * 2) % 1 < 0.5 then
				ptext(W / 2, 340, "PRESS START", 3, 255, 255, 255, "center")
			end
			scanlines(160)
		else
			local q = (t - last) / 0.35

			if q < 1 then
				local h = math.max(2, H * (1 - q) ^ 3)
				local w = (q < 0.6) and W or W * (1 - (q - 0.6) / 0.4)

				K.box(W / 2 - w / 2, H / 2 - h / 2, W / 2 + w / 2, H / 2 + h / 2, 255, 255, 255, 255)
			end
		end
	end,
}

-- Vector:  wireframe asteroids drifting in the dark, glowing as a vector monitor's beam glowed.  On
-- every snare the ship turns to the biggest rock, fires, and the rock splits in two as the shot
-- reaches it, down to the smallest, which bursts;  on every hat it sprays a shot the way it faces.
-- The ship turns to face its mark before it fires, rather than snapping round.
local function vecSpawn(size, x, y)
	for _, a in ipairs(world.asteroids) do
		if a.size == size and not a.alive then
			local angle = math.random() * 2 * math.pi
			local pace  = (4 + size * 1.5) * (0.6 + math.random() * 0.8)

			a.alive = true
			a.x     = x
			a.y     = y
			a.vx    = math.cos(angle) * pace / size
			a.vy    = math.sin(angle) * pace / size
			a.spin  = (math.random() - 0.5) * 120
			a.angle = math.random() * 360
			nodeSetVisible(a.node, true)
			return a
		end
	end
end


local function vecRefill()
	local left = 0

	for _, a in ipairs(world.asteroids) do
		if a.alive then
			left = left + 1
		end
	end
	if left < 3 then
		for i = 1, 4 do
			local side = (i % 2 == 0) and 1 or -1

			vecSpawn(1, side * VEC_HALF_W, (math.random() - 0.5) * VEC_HALF_H * 2)
		end
	end
end


local function vecFire(x, y, angle, speed, target)
	for _, s in ipairs(world.vecShots) do
		if not s.alive then
			s.alive  = true
			s.x      = x
			s.y      = y
			s.vx     = math.cos(math.rad(angle)) * speed
			s.vy     = math.sin(math.rad(angle)) * speed
			s.life   = 0.9
			s.target = target
			nodeSetVisible(s.node, true)
			return
		end
	end
end


ERA.vector = {
	enter = function(t)
		hideAll()
		nodeSetVisible(world.vecField, true)
		for _, a in ipairs(world.asteroids) do
			a.alive = false
			nodeSetVisible(a.node, false)
		end
		for _, s in ipairs(world.vecShots) do
			s.alive = false
			nodeSetVisible(s.node, false)
		end
		vecRefill()
		world.vecAngle   = 90
		world.vecPending = nil
		world.vecScore   = 0
		sceneSetSkyIntensity(0)
		sceneSetBloom(0.4, 0.9)
	end,
	draw = function(t, bar, k)
		local dt = math.max(0, t - lastT)

		nodeSetPosition(world.camera, 0, 0, 40)
		nodeLookAt(world.camera, 0, 0, 0)
		for _, a in ipairs(world.asteroids) do
			if a.alive then
				a.x     = (a.x + a.vx * dt + VEC_HALF_W) % (VEC_HALF_W * 2) - VEC_HALF_W
				a.y     = (a.y + a.vy * dt + VEC_HALF_H) % (VEC_HALF_H * 2) - VEC_HALF_H
				a.angle = a.angle + a.spin * dt
				nodeSetPosition(a.node, a.x, a.y, 0)
				nodeSetRotation(a.node, 0, 0, a.angle)
			end
		end
		-- On a snare, the ship picks the biggest rock and turns toward it;  it fires once it faces it.
		if K.hitCount("snares", lastT, t) > 0 then
			local best = nil

			for _, a in ipairs(world.asteroids) do
				if a.alive and (best == nil or a.size < best.size) then
					best = a
				end
			end
			world.vecPending = best
		end
		if world.vecPending and not world.vecPending.alive then
			world.vecPending = nil
		end
		if world.vecPending then
			local want = math.deg(math.atan(world.vecPending.y, world.vecPending.x))
			local diff = (want - world.vecAngle + 540) % 360 - 180
			local step = VEC_TURN * dt

			world.vecAngle = world.vecAngle + K.clamp(diff, -step, step)
			if math.abs(diff) <= step then
				vecFire(0, 0, world.vecAngle, 80, world.vecPending)
				world.vecPending = nil
			end
		end
		if K.hitCount("hats", lastT, t) > 0 then
			vecFire(0, 0, world.vecAngle + (math.random() - 0.5) * 30, 60, nil)
		end
		for _, s in ipairs(world.vecShots) do
			if s.alive then
				s.life = s.life - dt
				if s.target then
					-- The aimed shot homes on its rock and splits it on arrival.
					local dx = s.target.x - s.x
					local dy = s.target.y - s.y
					local d  = math.sqrt(dx * dx + dy * dy)

					if d < VEC_SIZES[s.target.size] or not s.target.alive then
						if s.target.alive then
							s.target.alive = false
							nodeSetVisible(s.target.node, false)
							nodeSetPosition(world.vecBurstAt, s.target.x, s.target.y, 0)
							emitterBurst(world.vecBurst, 40 * (4 - s.target.size))
							world.vecScore = world.vecScore + ({ 20, 50, 100 })[s.target.size]
							if s.target.size < 3 then
								vecSpawn(s.target.size + 1, s.target.x, s.target.y)
								vecSpawn(s.target.size + 1, s.target.x, s.target.y)
							end
						end
						s.alive = false
					else
						s.vx = dx / d * 80
						s.vy = dy / d * 80
					end
				end
				s.x = s.x + s.vx * dt
				s.y = s.y + s.vy * dt
				if s.life <= 0 or math.abs(s.x) > VEC_HALF_W or math.abs(s.y) > VEC_HALF_H then
					s.alive = false
				end
				nodeSetVisible(s.node, s.alive)
				nodeSetPosition(s.node, s.x, s.y, 0)
			end
		end
		vecRefill()
		nodeSetRotation(world.vecShip, 0, 0, world.vecAngle)
		nodeSetVisible(world.vecFlame, K.decay("kicks", t, 10) > 0.3)
		ptext(30, 20, string.format("%05d", world.vecScore), 3, 210, 235, 255)
	end,
	leave = function(t)
		sceneSetBloom(0.8, 0.5)
	end,
}

-- Light gun:  a shooting gallery, the cabinets Singe has always played.  Bullseyes slide along three
-- rails;  the crosshair glides to the nearest and, on every snare, the screen flashes white the way a
-- light gun's cabinet flashes to find where the gun points, and the target spins away, hit.
ERA.gallery = {
	enter = function(t)
		hideAll()
		world.gallery = { cx = W / 2, cy = H / 2, aim = nil, falling = {}, hits = 0, flash = -10, shot = {} }
	end,
	draw = function(t, bar, k)
		local g    = world.gallery
		local dt   = math.max(0, t - lastT)
		local b    = K.beat(t)
		local live = {}

		-- The backboard:  planks, a banner, and the rails.
		for x = 0, W, 48 do
			local shade = (x // 48) % 2 == 0 and 0 or 12

			K.box(x, 0, x + 47, H - 1, 120 + shade, 70 + shade, 40 + shade // 2, 255)
			K.box(x + 46, 0, x + 47, H - 1, 70, 40, 20, 255)
		end
		K.box(0, 0, W - 1, 56, 120, 20, 30, 255)
		ptext(W / 2, 16, "SHOOTING GALLERY", 3, 255, 230, 120, "center")
		-- The targets on each rail, sliding across a RAIL_GAP apart and round again;  a hit one is gone
		-- from its rail until it comes round the next time.
		for rail, y in ipairs(RAILS) do
			local dir    = (rail % 2 == 1) and 1 or -1
			local travel = (b / RAIL_BEATS) * (W + RAIL_GAP)

			K.box(0, y + 70, W - 1, y + 78, 60, 35, 20, 255)
			local period = (math.ceil(W / RAIL_GAP) + 2) * RAIL_GAP

			for slot = 0, math.ceil(W / RAIL_GAP) + 1 do
				local along = travel + slot * RAIL_GAP
				local x     = along % period - RAIL_GAP
				local id    = rail .. ":" .. slot .. ":" .. math.floor(along / period)

				if dir < 0 then
					x = W - x
				end
				if not g.shot[id] and x > -40 and x < W + 40 then
					K.draw(art.target, x - 32, y - 20)
					live[#live + 1] = { id = id, x = x, y = y + 12 }
				end
			end
		end
		-- The crosshair glides toward the target nearest it that is well on screen.
		local best = nil
		local bestD = math.huge

		for _, tg in ipairs(live) do
			if tg.x > 60 and tg.x < W - 60 then
				local d = (tg.x - g.cx) ^ 2 + (tg.y - g.cy) ^ 2

				if d < bestD then
					best  = tg
					bestD = d
				end
			end
		end
		if best then
			local ease = math.min(1, dt * 10)

			g.cx = g.cx + (best.x - g.cx) * ease
			g.cy = g.cy + (best.y - g.cy) * ease
		end
		-- A snare fires:  the light gun's white flash, and whatever is under the crosshair is hit.
		if K.hitCount("snares", lastT, t) > 0 then
			g.flash = t
			if best and math.abs(best.x - g.cx) < 40 and math.abs(best.y - g.cy) < 40 then
				g.shot[best.id] = true
				g.hits = g.hits + 1
				g.falling[#g.falling + 1] = { x = best.x, y = best.y - 12, vx = (math.random() - 0.5) * 120, vy = -220, spin = 0, t = t }
				boom(best.x, best.y, 30, 255, 220, 120)
			end
		end
		-- Hit targets spin and fall:  one picture, turned.
		for i = #g.falling, 1, -1 do
			local f = g.falling[i]

			f.vy   = f.vy + 900 * dt
			f.x    = f.x + f.vx * dt
			f.y    = f.y + f.vy * dt
			f.spin = f.spin + 900 * dt
			if f.y > H + 80 then
				table.remove(g.falling, i)
			else
				spriteRotate(art.target, math.floor(f.spin) % 360)
				K.draw(art.target, f.x, f.y, true)
			end
		end
		spriteRotate(art.target, 0)
		emitterDraw(art.boom)
		-- The crosshair.
		local cx = math.floor(g.cx)
		local cy = math.floor(g.cy)

		-- The ring, drawn a screen pixel at a time as thick as one design unit.
		colorForeground(255, 40, 40, 255)
		for r = math.floor(26 * K.S), math.floor(28 * K.S) - 1 do
			overlayCircle(math.floor(cx * K.S), math.floor(cy * K.S), r)
		end
		K.box(cx - 40, cy - 1, cx - 12, cy + 1, 255, 40, 40, 255)
		K.box(cx + 12, cy - 1, cx + 40, cy + 1, 255, 40, 40, 255)
		K.box(cx - 1, cy - 40, cx + 1, cy - 12, 255, 40, 40, 255)
		K.box(cx - 1, cy + 12, cx + 1, cy + 40, 255, 40, 40, 255)
		ptext(20, H - 40, string.format("HITS %03d", g.hits), 3, 255, 255, 255)
		if t - g.flash < 0.05 then
			K.flash(255, 255, 255, 255)
		end
		scanlines(90)
	end,
}

-- Versus:  two fighters face off.  ROUND 1 and FIGHT! land on the first bar's downbeats;  then the
-- red fighter strikes on every kick drum and the blue on every snare, each hit knocking the other's
-- health down, with sparks and a shake, until the last beat puts blue down for good.
local function fighterDraw(sprite, frame, x, y)
	px(sprite, FIGHTER_FRAME, frame, x, y, FIGHTER_SCALE)
end


ERA.fighter = {
	enter = function(t)
		hideAll()
		world.fight = { red = 1, blue = 1, redPose = 0, bluePose = 0, redUntil = 0, blueUntil = 0, shake = 0, start = K.bar(t) }
	end,
	draw = function(t, bar, k)
		local f     = world.fight
		local into  = bar - f.start
		local ox    = 0
		local oy    = 0
		local floor = H - 50
		local ko    = into >= 7.5

		-- The stage:  a dusk sky in bands, far hills, and a floor.
		for i = 0, 9 do
			K.box(0, i * 33, W - 1, i * 33 + 32, 60 + i * 14, 30 + i * 8, 90 + i * 6, 255)
		end
		K.draw(art.hills, 0, floor - 150, W, floor - 30)
		K.box(0, floor - 30, W - 1, H - 1, 90, 60, 50, 255)
		for x = 0, W, 64 do
			K.box(x, floor - 30, x + 2, H - 1, 70, 45, 38, 255)
		end
		if into >= 1 and not ko then
			if K.hitCount("kicks", lastT, t) > 0 then
				f.redPose   = (math.random() < 0.5) and 1 or 2
				f.redUntil  = t + 0.18
				f.bluePose  = 3
				f.blueUntil = t + 0.25
				f.blue      = math.max(0.06, f.blue - FIGHT_DAMAGE)
				f.shake     = t
				boom(W / 2 + 10, floor - 120, 40, 255, 230, 80)
			end
			if K.hitCount("snares", lastT, t) > 0 then
				f.bluePose  = (math.random() < 0.5) and 1 or 2
				f.blueUntil = t + 0.18
				f.redPose   = 3
				f.redUntil  = t + 0.25
				f.red       = math.max(0.06, f.red - FIGHT_DAMAGE * 0.8)
				f.shake     = t
				boom(W / 2 - 10, floor - 120, 40, 120, 200, 255)
			end
		end
		if ko then
			f.blue      = 0
			f.bluePose  = 3
			f.blueUntil = t + 1
		end
		if t - f.shake < 0.12 then
			ox = math.random(-6, 6)
			oy = math.random(-4, 4)
		end
		local bob = math.floor(2 * math.sin(K.beat(t) * math.pi * 2))

		fighterDraw(art.fighterA, (t < f.redUntil) and f.redPose or 0, W / 2 - 150 + ox, floor - 48 * FIGHTER_SCALE + oy + ((t < f.redUntil) and 0 or bob))
		fighterDraw(art.fighterB, (t < f.blueUntil) and f.bluePose or 0, W / 2 - 10 + ox, floor - 48 * FIGHTER_SCALE + oy + ((t < f.blueUntil) and 0 or bob))
		emitterDraw(art.boom)
		-- Health, names, and the clock.
		K.box(20, 20, 270, 38, 60, 0, 0, 255)
		K.box(22, 22, 22 + 246 * f.red, 36, 255, 220, 40, 255)
		K.box(W - 271, 20, W - 21, 38, 60, 0, 0, 255)
		K.box(W - 23 - 246 * f.blue, 22, W - 23, 36, 255, 220, 40, 255)
		ptext(20, 44, "P1", 2, 255, 120, 120)
		ptext(W - 20 - 3 * 16, 44, "CPU", 2, 140, 180, 255)
		ptext(W / 2, 18, string.format("%02d", math.max(0, 99 - math.floor(K.beat(t) - K.beat(K.barTime(f.start))))), 3, 255, 255, 255, "center")
		if into < 0.5 then
			ptext(W / 2, 160, "ROUND 1", 7, 255, 230, 80, "center")
		elseif into < 1 then
			ptext(W / 2, 150, "FIGHT!", 9, 255, 80, 60, "center")
		elseif ko then
			ptext(W / 2, 150, "K.O.", 10, 255, 60, 60, "center")
		end
		scanlines(110)
	end,
}

-- Rhythm:  a note highway whose notes are the song's own drums, read out of the music:  kicks,
-- snares, and hats each in their lane, scrolling down to the hit line and landing on it exactly as
-- the drum sounds.  Every hit is PERFECT, of course:  the music is playing itself.
local function rhythmY(ahead)
	local s = 1 / (1 + 3 * ahead / RHYTHM_LOOK)

	return RHYTHM_TOP + (RHYTHM_HIT - RHYTHM_TOP) * s, s
end


ERA.rhythm = {
	enter = function(t)
		hideAll()
		world.rhythm = { score = 0, combo = 0, flash = { -10, -10, -10 }, words = {} }
	end,
	draw = function(t, bar, k)
		local r = world.rhythm

		K.plasmaUpdate(art.plasma, t)
		K.under(art.plasma.sprite, 0, 0, W, H, nil, nil, nil, nil, true)
		K.under(nil, 0, 0, W, H, 0, 0, 20, 200)
		-- The highway, a row at a time, narrowing to the horizon, and the beat lines rushing down it.
		for y = RHYTHM_TOP, H - 1, 2 do
			local s    = (y - RHYTHM_TOP) / (RHYTHM_HIT - RHYTHM_TOP)
			local half = RHYTHM_SPAN * 1.7 * s

			K.box(W / 2 - half, y, W / 2 + half, y + 1, 20, 14, 40, 230)
		end
		local b = K.beat(t)

		for i = math.ceil(b), math.floor(b) + 5 do
			local ahead = K.beatTime(i) - t

			if ahead >= 0 and ahead <= RHYTHM_LOOK then
				local y, s = rhythmY(ahead)

				K.box(W / 2 - RHYTHM_SPAN * 1.7 * s, y, W / 2 + RHYTHM_SPAN * 1.7 * s, y + math.max(1, 3 * s), 90, 70, 140, 255)
			end
		end
		-- The notes:  each lane's drum hits in the next RHYTHM_LOOK seconds.
		for lane, info in ipairs(RHYTHM_LANES) do
			local offset = (lane - 2) * RHYTHM_SPAN
			local c      = info.rgb

			for _, hit in ipairs(sync[info.list]) do
				local ahead = hit - t

				if ahead > RHYTHM_LOOK then
					break
				end
				if ahead >= 0 then
					local y, s = rhythmY(ahead)
					local x    = W / 2 + offset * s
					local w    = 46 * s
					local h    = 14 * s

					K.box(x - w, y - h, x + w, y + h, c[1], c[2], c[3], 255)
					K.box(x - w, y - h, x + w, y - h * 0.4, 255, 255, 255, 160)
				end
			end
			-- A hit since last frame:  the target flashes, sparks fly, and a word pops up.
			if K.hitCount(info.list, lastT, t) > 0 then
				r.flash[lane] = t
				r.combo       = r.combo + 1
				r.score       = r.score + 100 + 10 * math.min(r.combo, 50)
				r.words[lane] = t
				boom(W / 2 + offset, RHYTHM_HIT, 25, c[1], c[2], c[3])
			end
			local glow = math.exp(-(t - r.flash[lane]) * 12)
			local x    = W / 2 + offset

			K.box(x - 50, RHYTHM_HIT - 18, x + 50, RHYTHM_HIT + 18, c[1], c[2], c[3], math.floor(60 + 195 * glow))
			K.box(x - 44, RHYTHM_HIT - 12, x + 44, RHYTHM_HIT + 12, 10, 10, 20, math.floor(200 * (1 - glow)))
			ptext(x, H - 40, info.label, 2, c[1], c[2], c[3], "center")
		end
		K.box(W / 2 - RHYTHM_SPAN * 1.7, RHYTHM_HIT - 1, W / 2 + RHYTHM_SPAN * 1.7, RHYTHM_HIT + 1, 255, 255, 255, 200)
		emitterDraw(art.boom)
		-- The latest hit's word in each lane, rising and gone in under half a second.
		for lane, when in pairs(r.words) do
			local age = t - when

			if age < 0.4 then
				local c = RHYTHM_LANES[lane].rgb

				ptext(W / 2 + (lane - 2) * RHYTHM_SPAN, RHYTHM_HIT - 60 - age * 80, "PERFECT", 2, c[1], c[2], c[3], "center")
			end
		end
		ptext(20, 20, string.format("SCORE %07d", r.score), 2, 255, 255, 255)
		ptext(W - 20 - 10 * 16, 20, string.format("COMBO %4d", r.combo), 2, 255, 230, 80)
		scanlines(90)
	end,
}

-- The finale runs the eras again, a bar each, every one on its own beat;  its time is moved by whole
-- bars, so the beat lands where it did.  The last two bars are GAME ON.
local MONTAGE = {
	{ era = "pong", bar = 6, label = "ANALOG" },        { era = "invaders", bar = 12, label = "8-BIT" },
	{ era = "runner", bar = 19, label = "16-BIT" },     { era = "racer", bar = 27, label = "16-BIT" },
	{ era = "loading", bar = 37, label = "TAPE" },      { era = "vector", bar = 44, label = "VECTOR" },
	{ era = "polygons", bar = 52, label = "32-BIT" },   { era = "gallery", bar = 59, label = "LIGHT GUN" },
	{ era = "modern", bar = 67, label = "NOW" },        { era = "continue", bar = 76, label = "CONTINUE" },
	{ era = "fighter", bar = 84, label = "VERSUS" },    { era = "boss", bar = 92, label = "BOSS" },
	{ era = "bonus", bar = 100, label = "BONUS" },      { era = "rhythm", bar = 108, label = "RHYTHM" },
}

ERA.montage = {
	enter = function(t)
		world.montageCut = 0
	end,
	draw = function(t, bar, k)
		local cut   = math.floor(bar - 121) + 1
		local final = cut > #MONTAGE
		local m     = MONTAGE[math.min(cut, #MONTAGE)]

		if final then
			-- The last two bars:  the name, slammed in on the downbeat, over everything flashing.
			if world.montageCut ~= cut then
				if world.montageEra and ERA[world.montageEra].leave then
					ERA[world.montageEra].leave(t)
				end
				world.montageEra = nil
				world.montageCut = cut
				hideAll()
			end
			local r, g, b = K.hue(t * 0.7)

			K.fill(r // 3, g // 3, b // 3)
			local s = 10 + 4 * math.exp(-(bar - 135) * 6)

			rainbow(W / 2, 170, "GAME ON", math.floor(s), t, "center")
			K.strobe(t, "kicks", 12, 255, 255, 255, 120)
			scanlines(160)
			return
		end
		local shift = K.barTime(m.bar) - K.barTime(121 + cut - 1)
		local et    = t + shift

		if world.montageCut ~= cut then
			if world.montageEra and ERA[world.montageEra].leave then
				ERA[world.montageEra].leave(t)
			end
			world.montageEra = m.era
			world.montageCut = cut
			ERA[m.era].enter(et)
		end
		local saved = lastT

		lastT = saved + shift
		ERA[m.era].draw(et, K.bar(et), 0)
		lastT = saved
		ptext(W - 20 - #m.label * 24, H - 40, m.label, 3, 255, 255, 255)
		K.flash(255, 255, 255, math.floor(220 * math.exp(-((bar - 121) % 1) * 1.7778 * 10)))
	end,
	leave = function(t)
		if world.montageEra and ERA[world.montageEra].leave then
			ERA[world.montageEra].leave(t)
		end
	end,
}


local function place(era, from, to)
	return { from = from, to = to, enter = ERA[era].enter, draw = ERA[era].draw, leave = ERA[era].leave }
end


local SCENES = {
	place("boot", 0, 5),
	place("pong", 5, 9),
	place("invaders", 9, 17),
	place("runner", 17, 25),
	place("racer", 25, 33),
	place("loading", 33, 41),
	place("vector", 41, 49),
	place("polygons", 49, 57),
	place("gallery", 57, 65),
	place("modern", 65, 73),
	place("continue", 73, 81),
	place("fighter", 81, 89),
	place("boss", 89, 97),
	place("bonus", 97, 105),
	place("rhythm", 105, 113),
	place("scores", 113, 121),
	-- Over every era until the recap, in the front layer so it stands over 2D and 3D alike.
	{
		from = 1, to = 121,
		draw = function(t, bar, k)
			K.scroller3D(t, art.blocks, FEATURE_TEXT, H * 0.5, K.barTime(1), K.barTime(121))
		end,
		leave = function(t)
			K.scroller3DStop(art.blocks)
		end,
	},
	place("montage", 121, 137),
	place("outro", 137, 200),
	-- The time at the end of each frame, for "what happened since last frame".
	{
		from = -10, to = 1000,
		draw = function(t, bar, k)
			lastT = t
		end,
	},
}

-- A ball meeting a brick throws sparks where they met.
function onCollision(a, b, x, y, z, speed)
	if speed > 4 then
		nodeSetPosition(world.spark, x, y, z)
		emitterBurst(world.sparks, math.min(60, math.floor(speed * 3)))
	end
end

loadArt()
buildWorld()
hideAll()
K.run(SCENES)