1#[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#[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
93fn 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
137fn 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 #[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 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 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 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_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 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 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 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 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 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 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}