1#[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
90fn 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 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 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
224struct 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 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 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_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 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 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 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 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 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 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 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 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 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 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}