Files
horizon-airdef/crates/horizon-client/src/toasts.rs
T
2026-10-27 06:29:44 +01:00

164 lines
6.0 KiB
Rust

//! `ToastManager`'s slide, shared by the game's toasts and the title
//! screens' system toasts.
use crate::hud::{HudAtlas, HudBatch};
use std::time::Instant;
/// `ToastManager.ToastInstance`: slides a toast in and out over 600 ms,
/// eased by the square, and counts how long it has been fully shown.
#[derive(Default)]
pub struct Slide {
/// When it first updated; the times below are milliseconds since.
pub origin: Option<Instant>,
begun: bool,
/// `animationStartTime`.
start: i64,
/// `becameFullyVisibleAt`.
fully_at: i64,
show: bool,
/// `visiblePortion`: 0 off screen, 1 fully in.
pub portion: f32,
/// `fullyVisibleFor`.
pub fully_for: i64,
}
impl Slide {
pub const MS: i64 = 600;
/// `ToastInstance.update` at `now`; `wants_show` is the toast's own
/// update. The visibility it switched to (the sound to play), and whether
/// it has finished sliding out.
pub fn update(
&mut self,
now: i64,
wants_show: impl FnOnce(i64) -> bool,
) -> (Option<bool>, bool) {
let was = self.show;
if !self.begun {
self.begun = true;
self.start = now;
self.show = true;
}
if self.show && now - self.start <= Self::MS {
self.fully_at = now;
}
self.fully_for = now - self.fully_at;
let progress = ((now - self.start) as f32 / Self::MS as f32).clamp(0.0, 1.0);
let progress = progress * progress;
self.portion = if self.show { progress } else { 1.0 - progress };
let wanted = wants_show(self.fully_for);
if wanted != self.show {
self.start = now - ((1.0 - self.portion) * Self::MS as f32) as i64;
self.show = wanted;
}
let finished = !self.show && now - self.start > Self::MS;
((self.show != was).then_some(self.show), finished)
}
/// `update` at the time since the first one.
pub fn update_now(&mut self, wants_show: impl FnOnce(i64) -> bool) -> (Option<bool>, bool) {
let origin = *self.origin.get_or_insert_with(Instant::now);
self.update(origin.elapsed().as_millis() as i64, wants_show)
}
}
/// `SystemToast`: a yellow title over a white message (or the title alone,
/// lower down) on the system background. It stays until its display time
/// has passed since its last change, or until it is hidden.
pub struct SystemToast {
pub slide: Slide,
/// `ToastInstance.firstSlotIndex`: its 32-pixel slot once shown.
pub slot: Option<usize>,
title: String,
message: Option<String>,
/// `changed`: the next update takes its time as `lastChanged`.
changed: bool,
last_changed: i64,
force_hide: bool,
}
impl SystemToast {
/// `SystemToastId.displayTime`'s default, in milliseconds.
const DISPLAY_TIME: f64 = 5000.0;
pub fn new(title: String, message: Option<String>) -> Self {
Self {
slide: Slide::default(),
slot: None,
title,
message,
changed: false,
last_changed: 0,
force_hide: false,
}
}
/// `reset`: new text, and the display time starts again.
pub fn reset(&mut self, title: String, message: Option<String>) {
self.title = title;
self.message = message;
self.changed = true;
}
pub fn force_hide(&mut self) {
self.force_hide = true;
}
/// `ToastInstance.update` with `SystemToast.update`, the display time
/// scaled by the Notification Time option: the visibility it switched
/// to (the sound to play), and whether it has slid out.
pub fn update(&mut self, multiplier: f64) -> (Option<bool>, bool) {
self.slide.update_now(|fully| {
if std::mem::take(&mut self.changed) {
self.last_changed = fully;
}
!self.force_hide
&& ((fully - self.last_changed) as f64) < Self::DISPLAY_TIME * multiplier
})
}
/// `extractRenderState` at `y`, in from the right edge by the visible
/// portion (`Toast.xPos`).
pub fn draw(&self, atlas: &HudAtlas, batch: &mut HudBatch, y: f32) {
let width = std::iter::once(&self.title)
.chain(&self.message)
.map(|line| HudBatch::text_width(atlas, line))
.fold(0.0, f32::max)
.ceil()
.max(160.0)
+ 30.0;
let x = batch.width - width * self.slide.portion;
background(atlas, batch, x, y, width);
let yellow = crate::hud::rgba(255, 255, 0, 255);
match &self.message {
Some(message) => {
batch.text(atlas, &self.title, x + 18.0, y + 7.0, yellow, false);
batch.text(atlas, message, x + 18.0, y + 19.0, u32::MAX, false);
}
None => {
batch.text(atlas, &self.title, x + 18.0, y + 12.0, yellow, false);
}
}
}
}
/// SystemToast's 32-pixel background keeps the notice icon and borders intact.
pub fn background(atlas: &HudAtlas, batch: &mut HudBatch, x: f32, y: f32, width: f32) {
let Some(rect) = atlas.sprites.get("gui/sprites/toast/system").copied() else {
return;
};
let source_x = [0.0, 17.0, rect.w as f32 - 4.0, rect.w as f32];
let target_x = [x, x + 17.0, x + width - 4.0, x + width];
for col in 0..3 {
for (sy, sh, y, h) in [
(0.0, 28.0, y, 28.0),
(rect.h as f32 - 4.0, 4.0, y + 28.0, 4.0),
] {
let mut piece = rect;
let du = (rect.u1 - rect.u0) / rect.w as f32;
let dv = (rect.v1 - rect.v0) / rect.h as f32;
piece.u0 = rect.u0 + source_x[col] * du;
piece.u1 = rect.u0 + source_x[col + 1] * du;
piece.v0 = rect.v0 + sy * dv;
piece.v1 = rect.v0 + (sy + sh) * dv;
batch.rect_uv(
target_x[col],
y,
target_x[col + 1] - target_x[col],
h,
piece,
u32::MAX,
);
}
}
}