picnic_panic/
lib.rs

1//! Picnic Panic: a small, very determined raccoon versus the village picnic.
2//!
3//! Work through a hand-written to-do list of pranks in a sunny low-poly park
4//! while picnickers go about their routines, notice you, chase you and carry
5//! you back to your burrow. Rules live in [`sim`] and run on fixed 60 Hz ticks
6//! with a seeded RNG; this host samples input, renders, plays audio and saves.
7//!
8//! ```
9//! use picnic_panic::sim::{Game, Input, RunConfig, bot::Bot, pranks::Prank};
10//! let mut game = Game::new(RunConfig { seed: 7, completed: 0 });
11//! let mut bot = Bot::new(&game);
12//! // The demo raccoon heads straight for the village bell by the gate.
13//! for _ in 0..60 * 12 {
14//!     let input = bot.input(&game);
15//!     game.update(input);
16//! }
17//! assert!(game.todo.done(Prank::Bell), "DONG. Everyone checks their watch.");
18//! // A chitter is an input edge consumed by exactly one tick.
19//! let mut game = Game::new(RunConfig::default());
20//! game.update(Input { chitter: true, ..Input::default() });
21//! assert_eq!(game.stats.chitters, 1);
22//! ```
23#[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
24mod capture;
25pub mod fx;
26pub mod hud;
27pub mod layout;
28pub mod menus;
29pub mod meta;
30pub mod models;
31pub mod rig;
32pub mod run;
33pub mod scene;
34pub mod sfx;
35pub mod sim;
36pub mod text;
37
38use ferravex_physics::d3::QueryOptions;
39use ferravex_play::camera::{
40    CameraError, Input3, Mode3, ObstructionSettings, Rig3, Settings3, Sweep, Target3,
41};
42use ferravex_play::replay::ghost::GhostTrack;
43use ferravex_play::tween::{
44    Motion, ScreenTransition, TransitionEvent, TransitionKind, TransitionPhase,
45};
46use ferravex_render::demo::Demo;
47use ferravex_render::effects::{
48    BillboardView, EffectBlend, EffectStyle, ParticleRenderer, ParticleShape, ParticleStyle,
49    draw_ribbon,
50};
51use ferravex_render::input::{ActionKind, Binding, HintDevice, InputCode, PlayerInput, Preset};
52use ferravex_render::post::{self, PostFx};
53use ferravex_render::prelude::*;
54use ferravex_render::storage::{Records, Slot};
55use ferravex_render::ui::{Ui, kit};
56use fx::{Fx, Toast};
57use hud::HudState;
58use layout::Layout;
59use menus::{Buttons, Menu, Summary, id};
60use meta::{DaySave, Ghost, Meta};
61use run::Run;
62use scene::{Actors, Frame, Scene};
63use sfx::{Sfx, SoundKit};
64use sim::bot::Bot;
65use sim::{Event, Game, Input, MAX_EVENTS, RunConfig, flat, heading, yaw_of};
66use text::Text;
67
68fn conf() -> Conf {
69    #[allow(unused_mut)]
70    let mut conf = ferravex_render::window_conf("Picnic Panic ยท Ferravex");
71    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
72    capture::window(&mut conf);
73    conf
74}
75
76#[derive(Clone, Copy, Debug, PartialEq, Eq)]
77enum Screen {
78    Title,
79    Wardrobe,
80    Play,
81}
82
83#[derive(Clone, Copy, Debug, PartialEq, Eq)]
84enum Swap {
85    To(Screen),
86    Start(u8),
87    ToTitle,
88}
89
90/// Warm film: lifted golden shadows, a soft vignette and a high bloom
91/// threshold so only lanterns, the sun, water glints and sparkles glow.
92fn grade(menu: bool) -> PostFx {
93    let fx = PostFx::warm_film()
94        .bloom(0.85, 0.93, 1.2)
95        .bloom_knee(0.12)
96        .exposure(1.05)
97        .saturation(1.04)
98        .lift_gamma_gain([0.035, 0.018, 0.], [1., 1., 1.02], [1.09, 1.01, 0.86])
99        .vignette(0.32, 0.7);
100    if menu {
101        fx.vignette(0.45, 0.6).exposure(0.98)
102    } else {
103        fx
104    }
105}
106
107fn add_actions(input: &mut PlayerInput) {
108    let key = |k: KeyCode| Binding::digital(InputCode::Key(k as u16));
109    let b = Binding::digital;
110    for (name, label, bindings) in [
111        (
112            "jump",
113            "Jump",
114            vec![
115                key(KeyCode::Space),
116                b(InputCode::PadButton(0)),
117                b(InputCode::Touch(layout::TOUCH_JUMP)),
118            ],
119        ),
120        (
121            "throw",
122            "Throw",
123            vec![
124                key(KeyCode::F),
125                b(InputCode::Mouse(3)),
126                b(InputCode::PadButton(1)),
127                b(InputCode::Touch(layout::TOUCH_THROW)),
128            ],
129        ),
130        (
131            "chitter",
132            "Chitter (distract)",
133            vec![
134                key(KeyCode::C),
135                b(InputCode::PadButton(3)),
136                b(InputCode::Touch(layout::TOUCH_CHITTER)),
137            ],
138        ),
139        (
140            "slide",
141            "Belly-slide / flop",
142            vec![
143                key(KeyCode::LeftShift),
144                key(KeyCode::RightShift),
145                b(InputCode::PadButton(5)),
146                b(InputCode::Touch(layout::TOUCH_SLIDE)),
147            ],
148        ),
149    ] {
150        input
151            .action(name, label, ActionKind::Button, bindings)
152            .expect("authored action");
153    }
154    input
155        .global_action(
156            "notes",
157            "To-do list",
158            ActionKind::Button,
159            vec![key(KeyCode::N), b(InputCode::PadButton(4))],
160        )
161        .expect("authored action");
162    input
163        .action(
164            "zoom",
165            "Camera zoom",
166            ActionKind::Delta,
167            vec![b(InputCode::Wheel(1))],
168        )
169        .expect("authored action");
170    for (code, scale) in [(KeyCode::Z, -0.9), (KeyCode::X, 0.9)] {
171        let _ = input.add_default_binding(
172            "look_rate_x",
173            Binding {
174                code: InputCode::Key(code as u16),
175                scale,
176                deadzone: 0.,
177            },
178        );
179    }
180    // The interact action (E / X / touch) is our grab, drop and use button.
181    let _ = input.set_mouse_look_button(Some(1));
182}
183
184fn hint<'a>(input: &PlayerInput, action: &str, buf: &'a mut [u8], fallback: &'a str) -> &'a str {
185    match input.format_hint(action, buf) {
186        Ok(s) if !s.is_empty() => {
187            // Show only the first binding; Controls lists the rest.
188            let s: &str = s;
189            s.split(['/', ',']).next().map_or(fallback, str::trim)
190        }
191        _ => fallback,
192    }
193}
194
195fn seed_now(salt: u64) -> u64 {
196    let t = (get_time() * 1_000_003.) as u64;
197    t ^ salt.wrapping_mul(0x9e37_79b9_7f4a_7c15) ^ 0x7069_636e
198}
199
200struct Saves {
201    meta: Meta,
202    slot: Option<Slot<Meta>>,
203    day: Option<Slot<DaySave>>,
204    ghost: Option<Slot<Ghost>>,
205    records: Option<Records>,
206}
207
208impl Saves {
209    fn commit(&mut self) {
210        if let Some(slot) = &mut self.slot {
211            let _ = slot.commit(self.meta.clone());
212        }
213    }
214    fn saved_day(&self) -> Option<u8> {
215        if self.meta.day_ms == 0 {
216            return None;
217        }
218        self.day
219            .as_ref()
220            .and_then(|d| meta::restore_mask(d.value()))
221    }
222}
223
224/// Camera presentation state (never touches the rules).
225struct CameraState {
226    rig: Rig3,
227    yaw: f32,
228    pitch: f32,
229    zoom: f32,
230    idle: f32,
231}
232
233impl CameraState {
234    fn new(yaw: f32) -> Self {
235        Self {
236            rig: Rig3::new(Settings3 {
237                position_half_life: 0.1,
238                target_half_life: 0.05,
239                fov_half_life: 0.2,
240                teleport_distance: Some(9.),
241                obstruction: Some(ObstructionSettings {
242                    radius: 0.22,
243                    padding: 0.08,
244                    release_half_life: 0.35,
245                    sweep_motion: true,
246                }),
247                shake_strength: 1.,
248            })
249            .expect("authored camera"),
250            yaw,
251            pitch: 0.36,
252            zoom: 6.2,
253            idle: 10.,
254        }
255    }
256}
257
258ferravex_render::game!(conf, game);
259async fn game() {
260    let mut demo = Demo::new();
261    ferravex_render::set_quality(ferravex_render::lighting::Quality::High);
262    let _ = ferravex_render::set_visibility(ferravex_render::visibility::VisibilitySettings {
263        frustum_culling: true,
264        max_distance: Some(150.),
265    });
266    let mut sound = SoundKit::new();
267    let mut fx = Fx::new();
268    let slot = Slot::open(meta::OWNER, "meta", Meta::default()).ok();
269    let mut saves = Saves {
270        meta: slot.as_ref().map(|s| s.value().clone()).unwrap_or_default(),
271        slot,
272        day: Slot::open(meta::OWNER, "day", sim::pranks::Todo::new().snapshot()).ok(),
273        ghost: Slot::open(meta::OWNER, "ghost", Ghost::default()).ok(),
274        records: Records::new(meta::OWNER).ok(),
275    };
276    let mut ghost_track: Option<GhostTrack> = saves
277        .ghost
278        .as_ref()
279        .filter(|g| !g.value().is_empty())
280        .and_then(|g| g.value().track());
281    let mut input = PlayerInput::preset("picnic-panic", Preset::Explore);
282    add_actions(&mut input);
283    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
284    let mut capture = capture::Capture::from_env();
285    let mut config = RunConfig {
286        seed: if demo.autoplay {
287            0x7069_636e
288        } else {
289            seed_now(1)
290        },
291        completed: 0,
292    };
293    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
294    {
295        if let Some(done) = capture.done {
296            config.completed = done & 0x7f;
297        }
298        if let Some(h) = capture.hat {
299            saves.meta.hat = h.min(models::Hat::ALL.len() as u8 - 1);
300            saves.meta.hats = 0xff;
301        }
302    }
303    let mut run = Run::new(config, demo.autoplay);
304    let mut bot = Bot::new(&run.game);
305    let mut attract = Game::new(RunConfig {
306        seed: 3,
307        completed: 0,
308    });
309    let mut attract_bot = Bot::new(&attract);
310    let mut attract_acc = 0_f32;
311    let mut scene = Scene::new(&run.game);
312    let mut actors = Actors::new();
313    let mut soft_renderer = ParticleRenderer::new(900).expect("bounded particle scratch");
314    let mut glow_renderer = ParticleRenderer::new(400).expect("bounded particle scratch");
315    let mut ui = Ui::new();
316    let mut tx = Text::new();
317    let mut buttons = Buttons::new();
318    let mut hud = HudState::new();
319    hud.reset(Layout::new([screen_width(), screen_height()]).compact);
320    let mut transition = ScreenTransition::new(TransitionKind::Iris, 0.45);
321    let mut swap: Option<Swap> = None;
322    let mut graded: Option<bool> = None;
323    let mut events: Vec<Event> = Vec::with_capacity(MAX_EVENTS * 4);
324    let mut cam = CameraState::new(-run.game.coon.yaw);
325    let mut screen = if demo.autoplay {
326        Screen::Play
327    } else {
328        Screen::Title
329    };
330    #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
331    match capture.screen.as_deref() {
332        Some("title") => screen = Screen::Title,
333        Some("wardrobe") => screen = Screen::Wardrobe,
334        _ => {}
335    }
336    if screen == Screen::Play {
337        run.activate();
338    }
339    let mut screen_age = 0_f32;
340    let mut pause_age = 0_f32;
341    let mut pauses = 0_usize;
342    let mut was_paused = false;
343    let mut summary: Option<Summary> = None;
344    let mut results_age = 0_f32;
345    let mut was_over = false;
346    let mut visual_time = 0_f32;
347    let mut saved_pranks = run.game.completed();
348    let mut hint_buf = [[0_u8; 32]; 3];
349    loop {
350        let render_dt = demo.dt();
351        let pdt = if render_dt.is_finite() {
352            render_dt.clamp(0., 0.1)
353        } else {
354            0.
355        };
356        visual_time += pdt;
357        screen_age += pdt;
358        fx.sync();
359        sound.age(pdt);
360        let motion = Motion::from(fx.policy());
361        if transition.advance(pdt, motion) == Some(TransitionEvent::Covered) {
362            match swap.take() {
363                Some(Swap::To(next)) => {
364                    screen = next;
365                    screen_age = 0.;
366                    buttons.snap();
367                }
368                Some(Swap::ToTitle) => {
369                    screen = Screen::Title;
370                    screen_age = 0.;
371                    run.reset();
372                    buttons.snap();
373                    attract = Game::new(RunConfig {
374                        seed: seed_now(5),
375                        completed: 0,
376                    });
377                    attract_bot = Bot::new(&attract);
378                }
379                Some(Swap::Start(completed)) => {
380                    config = RunConfig {
381                        seed: seed_now(saves.meta.runs as u64 + 3),
382                        completed,
383                    };
384                    run.begin(config);
385                    bot = Bot::new(&run.game);
386                    saved_pranks = run.game.completed();
387                    saves.meta.runs = saves.meta.runs.saturating_add(1);
388                    if completed == 0 {
389                        saves.meta.day_ms = 0;
390                    }
391                    saves.commit();
392                    fx.reset();
393                    sound.reset();
394                    actors.reset();
395                    hud.reset(Layout::new([screen_width(), screen_height()]).compact);
396                    cam = CameraState::new(-run.game.coon.yaw);
397                    summary = None;
398                    was_over = false;
399                    screen = Screen::Play;
400                    screen_age = 0.;
401                    buttons.snap();
402                    input.set_paused(true);
403                }
404                None => {}
405            }
406            transition.reveal();
407        }
408        let l = Layout::new([screen_width(), screen_height()]);
409        let in_run = screen == Screen::Play;
410        let playing = in_run && run.session.is_playing();
411        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
412        let force_touch = capture.touch;
413        #[cfg(not(all(debug_assertions, not(target_arch = "wasm32"))))]
414        let force_touch = false;
415        let controls = l.touch_controls();
416        input
417            .set_touch_layout(if playing {
418                &controls[..]
419            } else {
420                &controls[..0]
421            })
422            .expect("authored touch layout");
423        input.set_paused(!playing);
424        input.sample(playing);
425        let touch = force_touch || input.current_device() == HintDevice::Touch;
426        let mut changed = false;
427        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
428        let keep_focus = capture.focus;
429        #[cfg(not(all(debug_assertions, not(target_arch = "wasm32"))))]
430        let keep_focus = false;
431        if !demo.autoplay && !keep_focus && playing && !input.gameplay_active() {
432            changed = run.pause();
433        }
434        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
435        {
436            if capture.pause_now() && run.session.is_playing() {
437                changed |= run.pause();
438            }
439            if capture.end_now() && in_run && !run.game.is_over() {
440                let at = run.game.coon.pos();
441                for p in sim::pranks::Prank::ALL {
442                    sim::pranks::complete(&mut run.game, p, at);
443                }
444            }
445            if in_run {
446                capture.prepare(&mut run, &mut bot);
447            }
448        }
449        let menu_back = !in_run && input.pressed("pause") && !input.controls_open();
450        if in_run
451            && !run.game.is_over()
452            && run.session.is_started()
453            && input.pressed("pause")
454            && !changed
455            && !input.controls_open()
456        {
457            changed |= if run.session.is_paused() {
458                run.activate()
459            } else {
460                run.pause()
461            };
462        }
463        if in_run && input.pressed("notes") {
464            hud.notes_open = !hud.notes_open;
465            sound.play(Sfx::Page, 0.6, 1.);
466        }
467        if changed {
468            input.set_paused(true);
469        }
470        if run.session.is_paused() && !was_paused {
471            pauses += 1;
472        }
473        was_paused = run.session.is_paused();
474        if run.session.is_paused() || !in_run {
475            sound.pause();
476        } else {
477            sound.resume();
478        }
479        // --- Camera input (presentation): look orbits, wheel zooms.
480        let look = input.look(pdt);
481        if playing {
482            cam.yaw -= look.x * 1.15;
483            cam.pitch = (cam.pitch + look.y * 0.9).clamp(0.12, 1.05);
484            let wheel = input.value("zoom");
485            cam.zoom = (cam.zoom - wheel * 0.6).clamp(3.5, 11.);
486            if look.length() > 1e-4 {
487                cam.idle = 0.;
488            }
489        }
490        cam.idle += pdt;
491        // --- Simulation: edges are consumed only inside executed ticks.
492        let movement = input.movement();
493        let held_jump = input.held("jump");
494        let held_grab = input.held("interact");
495        let dt = if changed {
496            0.
497        } else if demo.autoplay {
498            render_dt
499        } else {
500            input.simulation_dt(render_dt)
501        };
502        if in_run {
503            let autoplay = demo.autoplay;
504            let cam_yaw = -cam.yaw;
505            run.advance(f64::from(dt), |game| {
506                if autoplay {
507                    return bot.input(game);
508                }
509                let [jump, grab, throw, chitter, slide] =
510                    input.take_tick(["jump", "interact", "throw", "chitter", "slide"]);
511                Input {
512                    movement,
513                    cam_yaw,
514                    jump: jump.pressed,
515                    jump_held: held_jump,
516                    grab: grab.pressed,
517                    grab_held: held_grab,
518                    throw: throw.pressed,
519                    chitter: chitter.pressed,
520                    slide: slide.pressed,
521                }
522            });
523            run.drain(&mut events);
524        } else {
525            // Attract mode behind the title: the demo raccoon plays on.
526            attract_acc += pdt;
527            let mut steps = 0;
528            while attract_acc >= sim::DT && steps < 4 {
529                attract_acc -= sim::DT;
530                steps += 1;
531                let input = attract_bot.input(&attract);
532                attract.update(input);
533            }
534            attract.drain_events(&mut events);
535            if attract.time > 240. {
536                attract = Game::new(RunConfig {
537                    seed: seed_now(9),
538                    completed: 0,
539                });
540                attract_bot = Bot::new(&attract);
541            }
542        }
543        let world: &Game = if in_run { &run.game } else { &attract };
544        let alpha = if in_run {
545            run.alpha
546        } else {
547            (attract_acc / sim::DT).clamp(0., 1.)
548        };
549        let running = !in_run || run.session.is_playing();
550        let (coon_pos, coon_yaw) = world.coon_pose(alpha);
551        fx.consume(&events, world, &mut sound, !in_run);
552        // Unlocks and saves follow accepted progress.
553        if in_run {
554            for e in &events {
555                match e {
556                    Event::Prank { .. } | Event::Bonus { .. } => {
557                        let all_caps = run.game.shinies_found() as usize == run.game.shinies.len();
558                        if let Some(hat) = saves.meta.note_progress(
559                            run.game.completed(),
560                            run.game.todo.bonus,
561                            all_caps,
562                        ) && !demo.autoplay
563                        {
564                            fx.toasts
565                                .insert(
566                                    ferravex_play::ui::notices::Notice {
567                                        key: Some(5),
568                                        priority:
569                                            ferravex_play::ui::notices::NoticePriority::Normal,
570                                        message: Toast::Hat(hat),
571                                        lifetime_seconds: 3.5,
572                                    },
573                                    ferravex_play::ui::notices::NoticeDuplicate::Replace,
574                                )
575                                .ok();
576                        }
577                    }
578                    Event::Shiny { count, .. } if *count as usize == run.game.shinies.len() => {
579                        if let Some(hat) = saves.meta.note_progress(0, 0, true) {
580                            let _ = hat;
581                        }
582                    }
583                    _ => {}
584                }
585            }
586            if run.game.completed() != saved_pranks && !run.game.is_over() {
587                saved_pranks = run.game.completed();
588                saves.meta.day_ms = (run.game.time * 1000.) as u64 + 1;
589                saves.meta.scruffs = saves.meta.scruffs.max(run.game.stats.scruffs);
590                if let Some(day) = &mut saves.day {
591                    let _ = day.commit(run.game.todo.snapshot());
592                }
593                saves.commit();
594            }
595        }
596        events.clear();
597        fx.advance(pdt, world, coon_pos, running);
598        let chase = world.folk.iter().filter(|f| f.chasing()).count() as f32;
599        let trees: [Vec3; 6] =
600            std::array::from_fn(|i| world.park.trees.get(i * 3).map_or(Vec3::ZERO, |t| t.at));
601        sound.ambience(
602            pdt,
603            if running { (chase / 2.).min(1.) } else { 0. },
604            world.band_offkey,
605            cam.rig.pose().map_or(coon_pos, |p| p.position),
606            &trees,
607        );
608        // Footsteps: pitter-patter from accepted grounded travel.
609        sound.steps.walk(
610            coon_pos,
611            world.coon.motor.grounded && world.coon.scruffed.is_none(),
612            running && world.coon.speed > 0.4,
613            sfx::walk_surface(),
614            0.45,
615        );
616        // --- Run end bookkeeping.
617        let over = in_run && run.game.is_over();
618        if over && !was_over {
619            ferravex_render::performance::event(
620                ferravex_play::performance::DiagnosticKind::Completed,
621                run.game.time,
622            );
623            let ms = (run.game.time * 1000.) as u64;
624            let all_caps = run.game.shinies_found() as usize == run.game.shinies.len();
625            let (best, hat) = saves.meta.record_clear(
626                ms,
627                run.game.stats.scruffs,
628                run.game.todo.bonus.count_ones(),
629                run.game.todo.bonus,
630                all_caps,
631            );
632            if !demo.autoplay {
633                saves.commit();
634                if let Some(records) = &mut saves.records {
635                    let _ = records.attempt(
636                        meta::RECORD,
637                        meta::RECORD_RULES,
638                        u64::from(run.game.todo.bonus.count_ones()),
639                        ferravex_render::storage::run_micros(run.game.time),
640                    );
641                }
642                if best && let Some(slot) = &mut saves.ghost {
643                    let _ = slot.commit(run.ghost.clone());
644                    ghost_track = run.ghost.track();
645                }
646                if let Some(day) = &mut saves.day {
647                    let _ = day.commit(sim::pranks::Todo::new().snapshot());
648                }
649            }
650            summary = Some(Summary::new(
651                run.game.time,
652                run.game.stats.scruffs,
653                run.game.todo.bonus,
654                run.game.shinies_found(),
655                run.game.shinies.len(),
656                best,
657                hat,
658            ));
659            results_age = 0.;
660            input.set_paused(true);
661        }
662        was_over = over;
663        if over {
664            results_age += pdt;
665        }
666        if let Some(s) = &mut summary {
667            s.advance(pdt, motion, results_age);
668        }
669        if run.session.is_paused() {
670            pause_age += pdt;
671        } else {
672            pause_age = 0.;
673        }
674        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
675        if let Some(open) = capture.notes {
676            hud.notes_open = open;
677        }
678        if in_run {
679            hud.update(&run.game, pdt, motion);
680        }
681        let want_menu = !in_run;
682        if graded != Some(want_menu) {
683            graded = Some(want_menu);
684            post::set_post_fx(grade(want_menu));
685        }
686        // --- Camera: orbit rig with obstruction sweeps, set-piece framing.
687        let fov = 52_f32.to_radians();
688        let auto = in_run && cam.idle > 1.6 && world.coon.speed > 1.5 && fx.motion() > 0.;
689        if auto {
690            let behind = -coon_yaw;
691            cam.yaw = sim::lerp_angle(cam.yaw, behind, (pdt * 1.4).min(1.));
692        }
693        let mut orbit_yaw = cam.yaw;
694        let mut pitch = cam.pitch;
695        let mut zoom = cam.zoom;
696        if !in_run {
697            orbit_yaw = visual_time * 0.05 * fx.motion() + 0.6;
698            pitch = 0.42;
699            zoom = 9.5;
700        }
701        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
702        if let Some([y, p, d]) = capture.cam {
703            orbit_yaw = y;
704            pitch = p;
705            zoom = d;
706        }
707        if world.coon.cape && in_run {
708            zoom = zoom.max(7.5);
709        }
710        let occluders = |s: Sweep| -> Result<Option<f32>, CameraError> {
711            let d = s.end - s.start;
712            let len = d.length();
713            if len < 1e-4 {
714                return Ok(None);
715            }
716            Ok(world
717                .world
718                .spherecast_with_options(
719                    s.start.to_array(),
720                    (d / len).to_array(),
721                    s.radius,
722                    QueryOptions::new(len).layers(sim::L_OCCLUDE),
723                )
724                .map(|hit| (hit.distance / len).clamp(0., 1.)))
725        };
726        let focus = if in_run {
727            coon_pos
728        } else {
729            coon_pos * 0.4 + vec3(0., 0., 4.) * 0.6
730        };
731        let mut pose = cam
732            .rig
733            .update(
734                pdt,
735                Input3 {
736                    target: Target3 {
737                        position: focus,
738                        rotation: Quat::IDENTITY,
739                        velocity: world.coon.motor.velocity,
740                    },
741                    mode: Mode3::Orbit {
742                        yaw: orbit_yaw,
743                        pitch,
744                        distance: zoom,
745                        pivot: vec3(0., 0.6, 0.),
746                    },
747                    fov_y: fov,
748                },
749                &occluders,
750            )
751            .map(|f| f.pose)
752            .unwrap_or_default();
753        let mut showcase_weight = 0.;
754        if let Some(sc) = fx.showcase {
755            let w = sc.weight();
756            showcase_weight = w;
757            let subject = sc
758                .prop
759                .map_or(sc.at, |i| world.prop_pose(i, alpha).0)
760                .lerp(sc.at, 0.25);
761            let side = heading(-orbit_yaw + 1.2);
762            let eye = subject - side * 6.5 + Vec3::Y * 3.2;
763            pose.position = pose.position.lerp(eye, w);
764            pose.target = pose.target.lerp(subject + Vec3::Y * 0.6, w);
765        }
766        let shake = fx.camera_shake();
767        let camera = Camera3D {
768            position: pose.position + shake,
769            target: pose.target + shake * 0.5,
770            up: Vec3::Y,
771            fovy: pose.fov_y.max(0.3),
772            z_near: 0.08,
773            z_far: 260.,
774            aspect: None,
775        };
776        let right = (camera.target - camera.position)
777            .cross(Vec3::Y)
778            .normalize_or_zero();
779        ferravex_render::audio::listener(camera.position, right);
780        // --- Animation (presentation, from accepted state).
781        let ghost_sample = if in_run && saves.meta.ghost {
782            ghost_track
783                .as_ref()
784                .and_then(|g| g.sample(run.game.tick, alpha))
785                .map(|s| {
786                    let yaw = yaw_of(s.rotation * Vec3::NEG_Z);
787                    (s.position, yaw)
788                })
789        } else {
790            None
791        };
792        let ghost_speed = ghost_sample.map(|_| 3.);
793        let (steps, _) = actors.update(world, if running { pdt } else { 0. }, ghost_speed);
794        if steps > 0 && running && world.coon.motor.grounded {
795            sound.at(Sfx::Pat, coon_pos, 0.18, 1.3);
796        }
797        // --- World pass.
798        let sky = models::rgb(scene::HAZE);
799        clear_background(sky);
800        ferravex_render::set_world_colors(true);
801        {
802            let r = Rect::new(0., 0., l.screen.x, l.screen.y);
803            ferravex_render::shapes::fill_rounded_rect(
804                r,
805                0.,
806                ferravex_render::shapes::Fill::vertical(r, models::rgb(scene::SKY_TOP), sky),
807            );
808        }
809        set_camera(&camera);
810        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
811        let hat = capture.hat.map_or(saves.meta.selected_hat(), |h| {
812            models::Hat::ALL[usize::from(h).min(models::Hat::ALL.len() - 1)]
813        });
814        #[cfg(not(all(debug_assertions, not(target_arch = "wasm32"))))]
815        let hat = saves.meta.selected_hat();
816        scene.draw(
817            &actors,
818            &Frame {
819                game: world,
820                alpha,
821                time: visual_time,
822                camera,
823                motion: fx.motion(),
824                flash: fx.reduced_flash(),
825                hat,
826                ghost: ghost_sample,
827                cones: saves.meta.cones && in_run,
828                jelly: fx.jelly,
829                showcase: showcase_weight > 0.,
830            },
831        );
832        // Trails and particles after opaque geometry.
833        let ground = EffectStyle {
834            blend: EffectBlend::Alpha,
835            depth_test: Some(true),
836            depth_write: false,
837        };
838        let up = ferravex_play::particles::RibbonFacing::Plane {
839            normal: [0., 1., 0.],
840        };
841        let _ = draw_ribbon(&fx.slide_trail, up, 2., ground);
842        let _ = draw_ribbon(&fx.sled_trail, up, 2., ground);
843        if let Ok(view) = BillboardView::from_camera(&camera) {
844            let _ = soft_renderer.draw_3d(
845                &fx.soft,
846                view,
847                ParticleStyle {
848                    shape: ParticleShape::Square,
849                    ..ParticleStyle::default()
850                },
851            );
852            let _ = glow_renderer.draw_3d(
853                &fx.glow,
854                view,
855                ParticleStyle {
856                    draw: EffectStyle {
857                        blend: EffectBlend::Additive,
858                        depth_test: Some(true),
859                        depth_write: false,
860                    },
861                    shape: ParticleShape::Diamond,
862                    sort_back_to_front: false,
863                    ..ParticleStyle::default()
864                },
865            );
866        }
867        // --- World/HUD boundary: everything below is crisp and un-bloomed.
868        post::post_fx_hud_begin();
869        ferravex_render::set_world_colors(false);
870        set_default_camera();
871        ferravex_render::performance::context(Some(run.session.tick()), None);
872        tx.scale = 1.;
873        let show_hud = in_run && run.session.is_started() && !over;
874        if show_hud {
875            hud::letterbox(&l, showcase_weight);
876            hud::flash(&l, fx.flash);
877            hud::target(
878                &hud,
879                &l,
880                &run.game,
881                &camera,
882                alpha,
883                visual_time,
884                fx.motion(),
885            );
886            hud::bubbles(
887                &mut tx,
888                &l,
889                &run.game,
890                &fx,
891                &camera,
892                alpha,
893                visual_time,
894                fx.motion(),
895            );
896            if !touch && !l.compact && !run.session.is_paused() {
897                hud::minimap(&mut hud, &l, &run.game, -orbit_yaw, alpha, visual_time);
898            }
899            let [grab_buf, jump_buf, notes_buf] = &mut hint_buf;
900            let notes_key = (!touch).then(|| hint(&input, "notes", notes_buf, "N"));
901            hud::notepad(&mut tx, &hud, &l, &run.game, &fx, notes_key);
902            let grab = hint(&input, "interact", grab_buf, "E");
903            let jump = hint(&input, "jump", jump_buf, "Space");
904            hud::status(&mut tx, &l, &run.game, touch);
905            hud::prompt(&mut tx, &hud, &l, &run.game, grab, jump, touch);
906            if touch && run.session.is_playing() {
907                hud::touch(&mut tx, &l, &input, &run.game);
908                if let Some((origin, position)) = input.touch_stick(0, 1) {
909                    hud::stick(origin, position);
910                }
911            }
912            tx.flush();
913            hud::effects(&mut hud, &l, &run.game, &camera, alpha);
914            hud::toasts(&mut tx, &l, &fx, motion);
915        }
916        tx.flush();
917        // --- Menus and modals.
918        ui.begin(l.viewport);
919        let mut menu = Menu {
920            tx: &mut tx,
921            ui: &mut ui,
922            buttons: &mut buttons,
923            t: visual_time,
924            dt: pdt,
925            motion,
926            sway: fx.motion(),
927        };
928        let saved_day = saves.saved_day();
929        match screen {
930            Screen::Title => menus::title(&mut menu, &l, &saves.meta, saved_day, screen_age),
931            Screen::Wardrobe => menus::wardrobe(&mut menu, &l, &saves.meta, screen_age),
932            Screen::Play => {
933                if over {
934                    if let Some(s) = &summary {
935                        menus::results(&mut menu, &l, s, results_age);
936                    }
937                } else if run.session.is_paused() {
938                    menus::paused(
939                        &mut menu,
940                        &l,
941                        &saves.meta,
942                        menus::PAUSE_QUIPS[pauses % menus::PAUSE_QUIPS.len()],
943                        pause_age,
944                        run.game.completed(),
945                    );
946                } else if touch && run.session.is_playing() {
947                    menus::touch_pause(&mut menu, &l);
948                    menus::notes_toggle(&mut menu, &l);
949                } else if run.session.is_playing() {
950                    menus::notes_toggle(&mut menu, &l);
951                }
952            }
953        }
954        tx.flush();
955        let idle = transition.phase() == TransitionPhase::Idle;
956        let menu_live = idle && !changed && (!in_run || !run.session.is_playing() || touch);
957        ui.finish_player(&mut input, menu_live && !demo.autoplay);
958        ui.paint();
959        // --- Menu actions.
960        let hit = |i: u64| ui.activated(i);
961        match screen {
962            Screen::Title => {
963                if hit(id::NEW_DAY) {
964                    swap = Some(Swap::Start(0));
965                    sound.play(Sfx::Select, 0.7, 1.);
966                } else if hit(id::CONTINUE) {
967                    swap = Some(Swap::Start(saved_day.unwrap_or(0)));
968                    sound.play(Sfx::Select, 0.7, 1.);
969                } else if hit(id::WARDROBE) {
970                    swap = Some(Swap::To(Screen::Wardrobe));
971                    sound.play(Sfx::Page, 0.7, 1.);
972                }
973            }
974            Screen::Wardrobe => {
975                for (k, h) in models::Hat::ALL.iter().enumerate() {
976                    if hit(id::HAT + k as u64) && saves.meta.has_hat(*h) {
977                        saves.meta.hat = k as u8;
978                        saves.commit();
979                        sound.play(Sfx::Ding, 0.6, 1. + k as f32 * 0.05);
980                    }
981                }
982                if hit(id::BACK) || menu_back {
983                    swap = Some(Swap::To(Screen::Title));
984                }
985            }
986            Screen::Play => {
987                if over {
988                    if hit(id::AGAIN) {
989                        swap = Some(Swap::Start(0));
990                    } else if hit(id::RESULTS_TITLE) {
991                        swap = Some(Swap::ToTitle);
992                    }
993                } else if run.session.is_paused() {
994                    if hit(id::RESUME) {
995                        run.activate();
996                        input.set_paused(true);
997                    } else if hit(id::RESTART) || input.pressed("restart") {
998                        swap = Some(Swap::Start(0));
999                    } else if hit(id::GHOST) {
1000                        saves.meta.ghost = !saves.meta.ghost;
1001                        saves.commit();
1002                        sound.play(Sfx::Click, 0.6, 1.);
1003                    } else if hit(id::CONES) {
1004                        saves.meta.cones = !saves.meta.cones;
1005                        saves.commit();
1006                        sound.play(Sfx::Click, 0.6, 1.);
1007                    } else if hit(id::TITLE) {
1008                        saves.meta.day_ms = if run.game.completed() != 0 {
1009                            (run.game.time * 1000.) as u64 + 1
1010                        } else {
1011                            0
1012                        };
1013                        saves.commit();
1014                        swap = Some(Swap::ToTitle);
1015                    }
1016                } else if hit(id::TOUCH_PAUSE) {
1017                    run.pause();
1018                    input.set_paused(true);
1019                } else if hit(id::NOTES) {
1020                    hud.notes_open = !hud.notes_open;
1021                    sound.play(Sfx::Page, 0.6, 1.);
1022                }
1023            }
1024        }
1025        if swap.is_some() && transition.phase() == TransitionPhase::Idle {
1026            transition.cover();
1027        }
1028        let focus =
1029            hud::project(&camera, l.screen, coon_pos + Vec3::Y * 0.4).unwrap_or(l.screen * 0.5);
1030        kit::draw_screen_transition(
1031            transition.kind(motion),
1032            transition.coverage(),
1033            Color::new(0.16, 0.09, 0.04, 1.),
1034            focus,
1035        );
1036        set_default_camera();
1037        input.draw_controls();
1038        let _ = flat;
1039        #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
1040        capture.end_frame();
1041        if demo.finish_frame() {
1042            break;
1043        }
1044        next_frame().await;
1045    }
1046}