glowtide/
lib.rs

1//! Glowtide: a bioluminescent bullet-heaven roguelite for Ferravex.
2//!
3//! A tiny lantern spirit survives a ten-minute tide (or a five-minute quick
4//! tide) of glowing sea creatures. Weapons fire on their own; you steer, dash
5//! and choose upgrades. Rules live in [`sim`] and run on fixed ticks with a
6//! seeded RNG; the host here only samples input, renders and saves.
7//!
8//! ```
9//! use glowtide::sim::{Game, Input, Phase, RunConfig, bot};
10//! let mut game = Game::new(RunConfig { seed: 7, ..RunConfig::default() });
11//! for _ in 0..600 {
12//!     let input = bot::autoplay(&game);
13//!     game.update(input);
14//! }
15//! assert!(game.stats.kills > 0, "ten seconds in, the wisps have found someone");
16//! assert!(matches!(game.phase, Phase::Running | Phase::LevelUp | Phase::Chest));
17//! // A dash is an input edge consumed by a single tick.
18//! let mut game = Game::new(RunConfig::default());
19//! game.update(Input { dash: true, ..Input::default() });
20//! assert_eq!(game.stats.dashes, 1);
21//! ```
22#[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
23mod capture;
24mod chips;
25mod fx;
26mod gfx;
27mod hud;
28mod icons;
29mod layout;
30mod menus;
31pub mod meta;
32pub mod run;
33mod sfx;
34pub mod sim;
35mod text;
36mod world;
37
38use ferravex_play::tween::{
39    Motion, RollCounter, ScreenTransition, TransitionEvent, TransitionKind,
40};
41use ferravex_render::demo::Demo;
42use ferravex_render::effects::{
43    EffectBlend, EffectStyle, ParticleRenderer, ParticleShape, ParticleStyle,
44};
45use ferravex_render::input::{ActionKind, Binding, HintDevice, InputCode, PlayerInput, Preset};
46use ferravex_render::post::{self, PostFx};
47use ferravex_render::prelude::*;
48use ferravex_render::storage::{Records, Slot};
49use ferravex_render::ui::{Ui, kit};
50use fx::Fx;
51use gfx::Painter;
52use layout::Layout;
53use menus::{Buttons, CardView, Menu, Summary, id};
54use meta::Meta;
55use run::Run;
56use sfx::SoundKit;
57use sim::content::{CHARACTERS, WeaponId};
58use sim::{Card, Choice, Event, Game, Input, MAX_EVENTS, Phase, RunConfig};
59use text::Text;
60use world::{Scene, View};
61
62fn conf() -> Conf {
63    #[allow(unused_mut)]
64    let mut conf = ferravex_render::window_conf("Glowtide ยท Ferravex");
65    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
66    capture::window(&mut conf);
67    conf
68}
69
70#[derive(Clone, Copy, Debug, PartialEq, Eq)]
71enum Screen {
72    Title,
73    Select,
74    Shrine,
75    Play,
76}
77
78/// A screen change that waits for the iris transition to cover the screen.
79#[derive(Clone, Copy, Debug, PartialEq, Eq)]
80enum Swap {
81    To(Screen),
82    StartRun,
83    ToTitle,
84}
85
86#[derive(Clone, Copy, Debug, PartialEq, Eq)]
87enum Grade {
88    Menu,
89    Run,
90    LightsOut,
91}
92
93/// Bloom tuned for a dark sea: a low threshold so bioluminescence blooms,
94/// a wide radius for underwater haze, and a vignette that frames the lantern.
95fn grade(kind: Grade) -> PostFx {
96    let fx = PostFx::neon()
97        .bloom(1.7, 0.52, 1.35)
98        .bloom_knee(0.35)
99        .vignette(0.36, 0.6);
100    match kind {
101        Grade::Menu => fx.bloom(2.1, 0.5, 1.45),
102        Grade::Run => fx,
103        Grade::LightsOut => fx.vignette(0.55, 0.5).exposure(0.92),
104    }
105}
106
107fn add_actions(input: &mut PlayerInput) {
108    let key = |k: KeyCode| Binding::digital(InputCode::Key(k as u16));
109    for (name, label, k) in [
110        ("pick_1", "Pick card 1", KeyCode::Key1),
111        ("pick_2", "Pick card 2", KeyCode::Key2),
112        ("pick_3", "Pick card 3", KeyCode::Key3),
113        ("pick_4", "Pick card 4", KeyCode::Key4),
114    ] {
115        input
116            .global_action(name, label, ActionKind::Button, vec![key(k)])
117            .expect("authored action");
118    }
119    input
120        .global_action(
121            "reroll",
122            "Reroll cards",
123            ActionKind::Button,
124            vec![key(KeyCode::E), Binding::digital(InputCode::PadButton(3))],
125        )
126        .expect("authored action");
127    input
128        .global_action(
129            "banish",
130            "Banish a card",
131            ActionKind::Button,
132            vec![key(KeyCode::Q), Binding::digital(InputCode::PadButton(2))],
133        )
134        .expect("authored action");
135}
136
137/// A lively background run for the title screen.
138fn attract_game(seed: u64) -> Game {
139    let mut game = Game::new(RunConfig {
140        character: (seed % CHARACTERS.len() as u64) as u8,
141        seed,
142        ..RunConfig::default()
143    });
144    game.time = 140.;
145    for card in [
146        Card::Weapon(WeaponId::HaloOrbit),
147        Card::Weapon(WeaponId::ChainSpark),
148        Card::Weapon(WeaponId::LanternAura),
149        Card::Weapon(WeaponId::HaloOrbit),
150        Card::Weapon(WeaponId::HaloOrbit),
151        Card::Weapon(WeaponId::ChainSpark),
152    ] {
153        game.apply_card(card);
154    }
155    game
156}
157
158fn seed_now(salt: u64) -> u64 {
159    let t = (get_time() * 1_000_003.) as u64;
160    t ^ salt.wrapping_mul(0x9e37_79b9_7f4a_7c15) ^ 0x5eed
161}
162
163struct Host {
164    meta: Meta,
165    slot: Option<Slot<Meta>>,
166    records: Option<Records>,
167}
168
169impl Host {
170    fn save(&mut self) {
171        if let Some(slot) = &mut self.slot {
172            let _ = slot.commit(self.meta.clone());
173        }
174    }
175}
176
177ferravex_render::game!(conf, game);
178async fn game() {
179    let mut demo = Demo::new();
180    let mut sound = SoundKit::new();
181    let mut fx = Fx::new();
182    let mut painter = Painter::new();
183    let mut particles = ParticleRenderer::new(2200).expect("bounded particle scratch");
184    let slot = Slot::open(meta::OWNER, "meta", Meta::default()).ok();
185    let mut host = Host {
186        meta: slot.as_ref().map(|s| s.value().clone()).unwrap_or_default(),
187        slot,
188        records: Records::new(meta::OWNER).ok(),
189    };
190    let mut input = PlayerInput::preset("glowtide", Preset::TopDown);
191    add_actions(&mut input);
192    let mut ui_menu = Ui::new();
193    let mut tx = Text::new();
194    let mut buttons = Buttons::new();
195    let mut hud_state = hud::HudState::new();
196    let mut transition = ScreenTransition::new(TransitionKind::Iris, 0.42);
197    let mut swap: Option<Swap> = None;
198    let mut graded: Option<Grade> = None;
199    let mut pause_age = 0_f32;
200    let mut events: Vec<Event> = Vec::with_capacity(MAX_EVENTS);
201    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
202    let mut capture = capture::Capture::from_env();
203    let mut config = RunConfig {
204        character: host.meta.character,
205        quick: host.meta.quick,
206        seed: if demo.autoplay {
207            0x6c75_6d69
208        } else {
209            seed_now(1)
210        },
211        bonuses: host.meta.bonuses(),
212    };
213    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
214    {
215        if let Some(c) = capture.character {
216            config.character = c.min(3);
217        }
218        config.quick |= capture.quick;
219        if let Some(s) = capture.seed {
220            config.seed = s;
221        }
222        if let Some(g) = capture.glimmer {
223            host.meta.glimmer = g;
224        }
225    }
226    let mut run = Run::new(config, demo.autoplay);
227    // Native benchmark workload: a sustained late-game horde (release builds too).
228    #[cfg(not(target_arch = "wasm32"))]
229    if let Some(count) = std::env::var("GLOWTIDE_STRESS")
230        .ok()
231        .and_then(|v| v.parse::<usize>().ok())
232    {
233        run.game.time = 420.;
234        for card in [
235            Card::Weapon(WeaponId::HaloOrbit),
236            Card::Weapon(WeaponId::LanternAura),
237            Card::Weapon(WeaponId::ChainSpark),
238            Card::Weapon(WeaponId::StarSkipper),
239        ] {
240            run.game.apply_card(card);
241        }
242        run.game.stress(count);
243    }
244    let mut attract = attract_game(seed_now(2));
245    let mut attract_acc = 0.;
246    let mut screen = if demo.autoplay {
247        Screen::Play
248    } else {
249        Screen::Title
250    };
251    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
252    match capture.screen.as_deref() {
253        Some("title") => screen = Screen::Title,
254        Some("select") => screen = Screen::Select,
255        Some("shrine") => screen = Screen::Shrine,
256        _ => {}
257    }
258    let mut shrine_return = Screen::Title;
259    let mut selected = usize::from(host.meta.character);
260    let mut screen_age = 0_f32;
261    let mut pending = Choice::None;
262    let mut banish_mode = false;
263    let mut offer_serial = u32::MAX;
264    let mut offer_age = 0_f32;
265    let mut chest_serial = u32::MAX;
266    let mut chest_age = 0_f32;
267    let mut results_age = 0_f32;
268    let mut summary: Option<Summary> = None;
269    let mut was_over = false;
270    let mut pauses = 0_usize;
271    let mut was_paused = false;
272    // Missing Glimmer for a locked character, and how long to show it.
273    let mut notice: Option<(u64, f32)> = None;
274    let mut bought: Option<(usize, f32)> = None;
275    let mut attempts = 0_u64;
276    let mut visual_time = 0_f32;
277    loop {
278        let render_dt = demo.dt();
279        let pdt = if render_dt.is_finite() {
280            render_dt.clamp(0., 0.1)
281        } else {
282            0.
283        };
284        visual_time += pdt;
285        screen_age += pdt;
286        fx.sync();
287        sound.age(pdt);
288        let motion = Motion::from(fx.policy());
289        if transition.advance(pdt, motion) == Some(TransitionEvent::Covered) {
290            match swap.take() {
291                Some(Swap::To(next)) => {
292                    screen = next;
293                    screen_age = 0.;
294                    buttons.snap();
295                }
296                Some(Swap::ToTitle) => {
297                    screen = Screen::Title;
298                    screen_age = 0.;
299                    run.reset();
300                    buttons.snap();
301                }
302                Some(Swap::StartRun) => {
303                    host.meta.character = selected as u8;
304                    host.save();
305                    config = RunConfig {
306                        character: selected as u8,
307                        quick: host.meta.quick,
308                        seed: seed_now(attempts + 3),
309                        bonuses: host.meta.bonuses(),
310                    };
311                    run.begin(config);
312                    fx.reset();
313                    sound.reset();
314                    hud_state.reset();
315                    summary = None;
316                    was_over = false;
317                    pending = Choice::None;
318                    banish_mode = false;
319                    screen = Screen::Play;
320                    screen_age = 0.;
321                    buttons.snap();
322                    input.set_paused(true);
323                }
324                None => {}
325            }
326            transition.reveal();
327        }
328        let l = Layout::new([screen_width(), screen_height()]);
329        let in_run = screen == Screen::Play;
330        let playing = in_run && run.session.is_playing();
331        let steering = playing && run.game.phase == Phase::Running;
332        let controls = l.touch_controls();
333        input
334            .set_touch_layout(if steering {
335                &controls[..]
336            } else {
337                &controls[..0]
338            })
339            .expect("authored touch layout");
340        input.set_paused(!playing);
341        input.sample(playing);
342        let touch = input.current_device() == HintDevice::Touch;
343        let mut changed = false;
344        if !demo.autoplay && playing && !input.gameplay_active() {
345            changed = run.pause();
346        }
347        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
348        if capture.pause_now() && run.session.is_playing() {
349            changed |= run.pause();
350        }
351        let menu_back = !in_run && input.pressed("pause") && !input.controls_open();
352        if in_run && !run.game.is_over() && run.session.is_started() {
353            if input.pressed("restart") {
354                config.seed = seed_now(attempts);
355                config.bonuses = host.meta.bonuses();
356                run.begin(config);
357                fx.reset();
358                sound.reset();
359                summary = None;
360                was_over = false;
361                changed = true;
362            } else if input.pressed("pause") && !changed && !input.controls_open() {
363                changed |= if run.session.is_paused() {
364                    run.activate()
365                } else {
366                    run.pause()
367                };
368            }
369        }
370        if changed {
371            input.set_paused(true);
372        }
373        if run.session.is_paused() && !was_paused {
374            pauses += 1;
375        }
376        was_paused = run.session.is_paused();
377        if run.session.is_paused() || !in_run {
378            sound.pause();
379        } else {
380            sound.resume();
381        }
382        // Quick card keys (render-frame global actions), applied on the next tick.
383        let modal = playing && matches!(run.game.phase, Phase::LevelUp | Phase::Chest);
384        if modal && run.game.phase == Phase::LevelUp && pending == Choice::None {
385            for (k, name) in ["pick_1", "pick_2", "pick_3", "pick_4"]
386                .into_iter()
387                .enumerate()
388            {
389                if input.pressed(name) && k < usize::from(run.game.offer.count) {
390                    pending = if banish_mode {
391                        Choice::Banish(k as u8)
392                    } else {
393                        Choice::Pick(k as u8)
394                    };
395                    banish_mode = false;
396                }
397            }
398            if input.pressed("reroll") && run.game.rerolls > 0 {
399                pending = Choice::Reroll;
400            }
401            if input.pressed("banish") && run.game.banishes > 0 {
402                banish_mode = !banish_mode;
403            }
404        }
405        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
406        if in_run {
407            capture.prepare(&mut run);
408        }
409        // --- Simulation: edges are consumed only inside executed ticks.
410        let movement = input.movement();
411        let movement = vec2(movement.x, -movement.y);
412        let dt = if changed {
413            0.
414        } else if demo.autoplay {
415            render_dt
416        } else {
417            input.simulation_dt(render_dt)
418        };
419        if in_run {
420            let autoplay = demo.autoplay;
421            #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
422            let capture_ref = &capture;
423            run.advance(f64::from(dt), |game| {
424                if autoplay {
425                    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
426                    return capture_ref.input(game);
427                    #[allow(unreachable_code)]
428                    return sim::bot::autoplay(game);
429                }
430                let [dash] = input.take_tick(["boost"]);
431                let choice = std::mem::take(&mut pending);
432                Input {
433                    movement: if game.phase == Phase::Running {
434                        movement
435                    } else {
436                        Vec2::ZERO
437                    },
438                    dash: dash.pressed,
439                    choice,
440                }
441            });
442            run.drain(&mut events);
443        } else {
444            // Attract mode behind the title: a muted demo run at 60 Hz.
445            attract_acc += pdt;
446            let mut steps = 0;
447            while attract_acc >= sim::DT && steps < 4 {
448                attract_acc -= sim::DT;
449                steps += 1;
450                let input = sim::bot::autoplay(&attract);
451                attract.update(input);
452            }
453            attract.drain_events(&mut events);
454            if attract.is_over() || attract.time > 400. {
455                attract = attract_game(seed_now(attempts + 9));
456            }
457        }
458        let world_game = if in_run { &run.game } else { &attract };
459        let alpha = if in_run {
460            run.alpha
461        } else {
462            (attract_acc / sim::DT).clamp(0., 1.)
463        };
464        let running = world_game.phase == Phase::Running && (!in_run || run.session.is_playing());
465        fx.age(pdt, running);
466        fx.consume(&events, world_game, &mut sound, !in_run);
467        events.clear();
468        let player_pos = world_game.player.prev.lerp(world_game.player.pos, alpha);
469        if running || !in_run {
470            fx.follow(player_pos, world_game.player.vel, pdt);
471        }
472        sound.music(
473            pdt,
474            if in_run && playing {
475                (world_game.foes.len() as f32 / 300.).min(1.) * 0.8
476                    + if world_game.boss().is_some() { 0.2 } else { 0. }
477            } else {
478                0.15
479            },
480        );
481        // --- Run end bookkeeping.
482        let over = in_run && run.game.is_over();
483        if over && !was_over {
484            let won = run.game.phase == Phase::Won;
485            ferravex_render::performance::event(
486                if won {
487                    ferravex_play::performance::DiagnosticKind::Completed
488                } else {
489                    ferravex_play::performance::DiagnosticKind::Death
490                },
491                run.game.time,
492            );
493            let glimmer = meta::run_glimmer(&run.game);
494            host.meta.award(glimmer, won);
495            host.save();
496            let quick = run.game.config.quick;
497            let survive = (run.game.time * 10.) as u64;
498            let level = u64::from(run.game.level());
499            let kills = u64::from(run.game.stats.kills);
500            let mut best = [false; 3];
501            if let Some(records) = &mut host.records {
502                for (k, (metric, value)) in
503                    [("survive", survive), ("kills", kills), ("level", level)]
504                        .into_iter()
505                        .enumerate()
506                {
507                    let id = meta::record_id(quick, metric);
508                    let prev = records.get(id, meta::RECORD_RULES).map(|r| r.score);
509                    best[k] = prev.is_none_or(|p| value > p);
510                    let time = if won {
511                        ferravex_render::storage::run_micros(run.game.time)
512                    } else {
513                        None
514                    };
515                    let _ = records.attempt(id, meta::RECORD_RULES, value, time);
516                }
517            }
518            summary = Some(Summary {
519                title: meta::title(&run.game),
520                best_time: best[0],
521                best_kills: best[1],
522                best_level: best[2],
523                rolls: [
524                    run.game.time as i64,
525                    i64::from(run.game.level()),
526                    kills as i64,
527                    glimmer as i64,
528                ]
529                .map(|v| {
530                    let mut roll = RollCounter::new(0);
531                    roll.set_target(v);
532                    roll
533                }),
534            });
535            attempts += 1;
536            results_age = 0.;
537            input.set_paused(true);
538        }
539        was_over = over;
540        if over {
541            results_age += pdt;
542        }
543        if in_run {
544            hud_state.update(&run.game, pdt, motion);
545        }
546        if let Some(s) = &mut summary {
547            s.advance(pdt, motion, results_age);
548        }
549        if run.session.is_paused() {
550            pause_age += pdt;
551        } else {
552            pause_age = 0.;
553        }
554        let want = if !in_run {
555            Grade::Menu
556        } else if world_game
557            .boss()
558            .is_some_and(|b| b.kind == sim::content::FoeKind::Gulpjaw && b.hp / b.max_hp < 0.6)
559        {
560            Grade::LightsOut
561        } else {
562            Grade::Run
563        };
564        if graded != Some(want) {
565            graded = Some(want);
566            post::set_post_fx(grade(want));
567        }
568        // --- World pass.
569        let (deep, _, _) = world::palette(&fx);
570        clear_background(Color::new(deep[0], deep[1], deep[2], 1.));
571        let shake = fx.shake_offset();
572        let view = View::new(l.screen, fx.camera + shake, 1. + fx.zoom_punch);
573        set_camera(&view.camera());
574        ferravex_render::set_world_colors(true);
575        painter.begin_frame();
576        {
577            let scene = Scene {
578                game: world_game,
579                fx: &fx,
580                view,
581                alpha,
582                time: visual_time,
583                flashes: fx.flashes(),
584                motion: fx.motion(),
585            };
586            world::draw(&mut painter, &scene);
587        }
588        let _ = particles.draw_2d(
589            &fx.pixels,
590            ParticleStyle {
591                shape: ParticleShape::Square,
592                sort_back_to_front: false,
593                ..ParticleStyle::default()
594            },
595        );
596        let _ = particles.draw_2d(
597            &fx.sparks,
598            ParticleStyle {
599                draw: EffectStyle {
600                    blend: EffectBlend::Additive,
601                    depth_test: Some(false),
602                    depth_write: false,
603                },
604                shape: ParticleShape::Diamond,
605                stretch: 0.012,
606                max_stretch: 3.5,
607                sort_back_to_front: false,
608            },
609        );
610        // --- World/HUD boundary: everything below draws crisp, unbloomed.
611        post::post_fx_hud_begin();
612        ferravex_render::set_world_colors(false);
613        set_default_camera();
614        if in_run {
615            hud::numbers(&mut tx, &fx, &view);
616        }
617        ferravex_render::performance::context(Some(run.session.tick()), None);
618        let show_hud = in_run && run.session.is_started() && !over;
619        if show_hud {
620            hud::draw(
621                &mut painter,
622                &mut tx,
623                &hud_state,
624                &l,
625                &run.game,
626                &fx,
627                &view,
628                visual_time,
629                touch,
630            );
631            if touch
632                && steering
633                && let Some((origin, position)) = input.touch_stick(0, 1)
634            {
635                hud::stick(&mut painter, origin, position, run.game.character().color);
636            }
637        }
638        painter.flush();
639        tx.flush();
640        // --- Menus and modals.
641        ui_menu.begin(l.viewport);
642        let mut menu = Menu {
643            p: &mut painter,
644            tx: &mut tx,
645            ui: &mut ui_menu,
646            buttons: &mut buttons,
647            t: visual_time,
648            dt: pdt,
649            motion,
650            sway: fx.motion(),
651        };
652        if let Some((_, a)) = &mut notice {
653            *a -= pdt;
654        }
655        if notice.is_some_and(|(_, a)| a <= 0.) {
656            notice = None;
657        }
658        if let Some((_, a)) = &mut bought {
659            *a = (*a - pdt * 1.5).max(0.);
660        }
661        match screen {
662            Screen::Title => {
663                let best = host.records.as_ref().and_then(|r| {
664                    let t = r.get(
665                        meta::record_id(host.meta.quick, "survive"),
666                        meta::RECORD_RULES,
667                    )?;
668                    let k = r.get(
669                        meta::record_id(host.meta.quick, "kills"),
670                        meta::RECORD_RULES,
671                    )?;
672                    Some((t.score, k.score))
673                });
674                menus::title(&mut menu, &l, &host.meta, best, screen_age);
675            }
676            Screen::Select => {
677                menus::select(&mut menu, &l, &host.meta, selected, screen_age, notice)
678            }
679            Screen::Shrine => menus::shrine(&mut menu, &l, &host.meta, screen_age, bought),
680            Screen::Play => {
681                let game = &run.game;
682                if over {
683                    if let Some(s) = &summary {
684                        menus::results(&mut menu, &l, game, s, results_age);
685                    }
686                } else if run.session.is_paused() {
687                    menus::paused(
688                        &mut menu,
689                        &l,
690                        game,
691                        menus::PAUSE_QUIPS[pauses % menus::PAUSE_QUIPS.len()],
692                        pause_age,
693                    );
694                } else if game.phase == Phase::LevelUp {
695                    if game.offer.serial != offer_serial {
696                        offer_serial = game.offer.serial;
697                        offer_age = 0.;
698                    }
699                    offer_age += pdt;
700                    let keys = match input.current_device() {
701                        HintDevice::Gamepad => Some(["Y", "X"]),
702                        HintDevice::Touch => None,
703                        _ => Some(["E", "Q"]),
704                    };
705                    menus::level_up(
706                        &mut menu,
707                        &l,
708                        game,
709                        &CardView {
710                            banish_mode,
711                            age: offer_age,
712                        },
713                        keys,
714                    );
715                } else if game.phase == Phase::Chest {
716                    if game.chest.serial != chest_serial {
717                        chest_serial = game.chest.serial;
718                        chest_age = 0.;
719                    }
720                    chest_age += pdt;
721                    menus::chest(&mut menu, &l, game, chest_age);
722                } else if touch && run.session.is_playing() {
723                    menus::touch_pause(&mut menu, &l);
724                }
725            }
726        }
727        painter.flush();
728        tx.flush();
729        let idle = transition.phase() == ferravex_play::tween::TransitionPhase::Idle;
730        let menu_live = idle
731            && !changed
732            && (!in_run || !run.session.is_playing() || run.game.phase != Phase::Running || touch);
733        ui_menu.finish_player(&mut input, menu_live && !demo.autoplay);
734        ui_menu.paint();
735        // --- Menu actions.
736        let hit = |id: u64| ui_menu.activated(id);
737        let mut start_run = false;
738        match screen {
739            Screen::Title => {
740                if hit(id::DIVE) {
741                    swap = Some(Swap::To(Screen::Select));
742                    sound.play(sfx::Sfx::Select, 0.6, 1.);
743                } else if hit(id::SHRINE) {
744                    shrine_return = Screen::Title;
745                    swap = Some(Swap::To(Screen::Shrine));
746                    sound.play(sfx::Sfx::Select, 0.6, 1.);
747                }
748            }
749            Screen::Select => {
750                for (i, character) in CHARACTERS.iter().enumerate() {
751                    if hit(id::CHARACTER + i as u64) {
752                        if host.meta.is_unlocked(i) {
753                            selected = i;
754                            sound.play(sfx::Sfx::Click, 0.6, 1.2);
755                        } else if host.meta.unlock(i) == meta::Purchase::Bought {
756                            selected = i;
757                            host.save();
758                            sound.play(sfx::Sfx::Chest, 0.6, 1.);
759                        } else {
760                            let missing = character.cost.saturating_sub(host.meta.glimmer);
761                            notice = Some((missing, 2.5));
762                            sound.play(sfx::Sfx::Hurt, 0.4, 1.4);
763                        }
764                    }
765                }
766                if hit(id::TIDE) {
767                    host.meta.quick = !host.meta.quick;
768                    host.save();
769                    sound.play(sfx::Sfx::Click, 0.6, 1.);
770                }
771                if hit(id::GO) && host.meta.is_unlocked(selected) {
772                    start_run = true;
773                }
774                if hit(id::BACK) || menu_back {
775                    swap = Some(Swap::To(Screen::Title));
776                }
777            }
778            Screen::Shrine => {
779                for i in 0..sim::content::SHRINE_ITEMS {
780                    if hit(id::BUY + i as u64) && host.meta.buy(i) == meta::Purchase::Bought {
781                        host.save();
782                        bought = Some((i, 1.));
783                        sound.play(sfx::Sfx::Coin, 0.7, 1.);
784                    }
785                }
786                if hit(id::SHRINE_BACK) || menu_back {
787                    // Coming back from results shows the title, not a stale run.
788                    swap = Some(if shrine_return == Screen::Play {
789                        Swap::ToTitle
790                    } else {
791                        Swap::To(shrine_return)
792                    });
793                }
794            }
795            Screen::Play => {
796                if over {
797                    if hit(id::AGAIN) {
798                        start_run = true;
799                    } else if hit(id::RESULTS_SHRINE) {
800                        shrine_return = Screen::Play;
801                        swap = Some(Swap::To(Screen::Shrine));
802                    } else if hit(id::RESULTS_TITLE) {
803                        swap = Some(Swap::ToTitle);
804                    }
805                } else if run.session.is_paused() {
806                    if hit(id::RESUME) {
807                        run.activate();
808                        input.set_paused(true);
809                    } else if hit(id::RESTART) {
810                        start_run = true;
811                    } else if hit(id::GIVE_UP) {
812                        run.game.surrender();
813                        run.session.set_paused(false);
814                        run.session.finish(false);
815                    } else if hit(id::TITLE) {
816                        let glimmer = meta::run_glimmer(&run.game);
817                        host.meta.award(glimmer, false);
818                        host.save();
819                        swap = Some(Swap::ToTitle);
820                    }
821                } else if run.game.phase == Phase::LevelUp {
822                    for i in 0..4u8 {
823                        if hit(id::CARD + u64::from(i)) {
824                            pending = if banish_mode {
825                                Choice::Banish(i)
826                            } else {
827                                Choice::Pick(i)
828                            };
829                            banish_mode = false;
830                        }
831                    }
832                    if hit(id::REROLL) {
833                        pending = Choice::Reroll;
834                    }
835                    if hit(id::BANISH) {
836                        banish_mode = !banish_mode;
837                    }
838                } else if run.game.phase == Phase::Chest {
839                    if hit(id::CONTINUE) {
840                        pending = Choice::Pick(0);
841                    }
842                } else if hit(id::TOUCH_PAUSE) {
843                    run.pause();
844                    input.set_paused(true);
845                }
846            }
847        }
848        if start_run {
849            swap = Some(Swap::StartRun);
850            sound.play(sfx::Sfx::Select, 0.7, 0.9);
851        }
852        if swap.is_some() && transition.phase() == ferravex_play::tween::TransitionPhase::Idle {
853            transition.cover();
854        }
855        let focus = if in_run {
856            view.to_screen(player_pos)
857        } else {
858            l.screen * 0.5
859        };
860        kit::draw_screen_transition(
861            transition.kind(motion),
862            transition.coverage(),
863            Color::new(0.01, 0.02, 0.05, 1.),
864            focus,
865        );
866        set_default_camera();
867        input.draw_controls();
868        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
869        capture.end_frame();
870        if demo.finish_frame() {
871            break;
872        }
873        next_frame().await;
874    }
875}