pinch-points 0.9.0

//! The unlock toasts and the achievements browser screen.

use super::{ACHIEVEMENTS, Stats, Unlocked};
use crate::app::i18n::fill;
use crate::app::menu_ui;
use crate::app::palette;
use crate::app::settings::GameSettings;
use bevy::prelude::*;

// --- toasts ----------------------------------------------------------------

/// An unlock's toast: how long it has been up, and whether its chime
/// has rung yet, which it does as the toast first shows.
#[derive(Component)]
pub struct Toast {
    age: f32,
    rung: bool,
}

const TOAST_LIFE: f32 = 4.0;

/// Where the first toast sits, and the air between one and the next.
const TOAST_TOP: f32 = 52.0;
const TOAST_GAP: f32 = 6.0;

/// What a toast is assumed to be tall on the frame it appears, before the
/// layout has measured it. Only ever used for one frame, and only to keep
/// the toast under it from starting in the same place.
const TOAST_GUESS: f32 = 64.0;

pub(super) fn spawn_toast(commands: &mut Commands, name: &str, desc: &str) {
    commands
        .spawn((
            Toast {
                age: 0.0,
                rung: false,
            },
            GlobalZIndex(menu_ui::layer::TOAST),
            Node {
                position_type: PositionType::Absolute,
                top: Val::Px(TOAST_TOP),
                right: Val::Px(12.0),
                flex_direction: FlexDirection::Column,
                row_gap: Val::Px(2.0),
                padding: UiRect::axes(Val::Px(14.0), Val::Px(10.0)),
                ..default()
            },
            BackgroundColor(palette::TOAST_FILL),
        ))
        .with_children(|toast| {
            toast.spawn((
                Text::new(format!("* {name}")),
                TextFont {
                    font_size: FontSize::Px(menu_ui::type_scale::ROW),
                    ..default()
                },
                TextColor(palette::GOLD),
            ));
            toast.spawn((
                Text::new(desc.to_string()),
                TextFont {
                    font_size: FontSize::Px(menu_ui::type_scale::BODY),
                    ..default()
                },
                TextColor(palette::PARCHMENT.with_alpha(0.9)),
            ));
        });
}

/// What a toast's chime is rung with.
#[derive(bevy::ecs::system::SystemParam)]
pub struct Chime<'w> {
    settings: Res<'w, GameSettings>,
    sounds: Option<Res<'w, crate::app::audio::Sounds>>,
    muted: Res<'w, crate::app::audio::Muted>,
}

/// Stack visible toasts under the header and expire them, each ringing
/// its chime as it first shows.
///
/// Each one is placed under the measured height of the one before it, not
/// under a constant: a toast is as tall as its two lines make it, and a
/// constant that cleared the real thing by one pixel would overlap on a
/// longer name or a language with taller metrics.
///
/// Held, unseen and not ageing, while a host's map page is up: the page
/// fills the window, and a toast sat over its corner and its scroll bar.
/// They show, and ring, once it is down.
pub fn update_toasts(
    time: Res<Time>,
    mut commands: Commands,
    menu: Res<crate::app::match_setup::MatchMenu>,
    chime: Chime,
    mut toasts: Query<(Entity, &mut Toast, &mut Node, &ComputedNode)>,
) {
    let held = crate::app::next_map::page_up(&menu);
    let display = match held {
        true => Display::None,
        false => Display::Flex,
    };
    let mut top = TOAST_TOP;
    for (entity, mut toast, mut node, computed) in &mut toasts {
        if node.display != display {
            node.display = display;
        }
        if held {
            continue;
        }
        if !std::mem::replace(&mut toast.rung, true)
            && let Some(sounds) = &chime.sounds
        {
            let gain = crate::app::audio::sfx_gain(&chime.settings, &chime.muted);
            crate::app::audio::play_chime(&mut commands, sounds, gain);
        }
        toast.age += time.delta_secs();
        if toast.age >= TOAST_LIFE {
            commands.entity(entity).despawn();
            continue;
        }
        let target = Val::Px(top);
        if node.top != target {
            node.top = target;
        }
        // Physical pixels out of the layout, logical pixels into `Val::Px`.
        let height = computed.size().y * computed.inverse_scale_factor();
        top += if height > 0.0 { height } else { TOAST_GUESS } + TOAST_GAP;
    }
}

// --- the browser screen ----------------------------------------------------

#[derive(Component)]
pub struct AchievementsUi;

/// The unlock mark: a filled gold disc when earned, an empty ring when not.
///
/// A disc rather than the star sprite, whose arms come out thinner than a
/// pixel at the 22 the list row allows, and it needs no asset.
///
/// The medal's ink, by what the trophy is for: banking gold, versus red,
/// puzzles green, the daily sky-blue, the editor violet, the gulls white.
/// Fifty gold rows read as one blur; the inks group them the way the
/// difficulty inks group the stage grid.
fn category_ink(id: &str) -> Color {
    match id {
        // Versus: the beach fought over, and who you fought there.
        _ if id.starts_with("win_") || id.starts_with("series_") => palette::INK_RAID,
        _ if id.starts_with("online_") || id.starts_with("rounds_") => palette::INK_RAID,
        _ if id.starts_with("crowd_") || id.starts_with("hosted_") => palette::INK_RAID,
        "dry_castle" | "raids_25" | "all_seats" => palette::INK_RAID,
        // The campaign, and how it was walked rather than that it was.
        _ if id.starts_with("puzzle_") => palette::INK_SURGE,
        "campaign_done" => palette::INK_SURGE,
        _ if id.starts_with("under_par") || id.starts_with("clean_") => palette::INK_SURGE,
        _ if id.starts_with("deep_") => palette::INK_SURGE,
        _ if id.starts_with("daily_") => palette::INK_TIDE,
        // The editor, and both ends of a level passed around as a code.
        _ if id.starts_with("built_") => palette::INK_LURE,
        "shared_1" | "taken_1" => palette::INK_LURE,
        "fed_25" => palette::PARCHMENT,
        _ => palette::GOLD,
    }
}

fn unlock_mark(done: bool, id: &str) -> (Node, BackgroundColor, BorderColor) {
    let ink = category_ink(id);
    (
        Node {
            width: Val::Px(14.0),
            height: Val::Px(14.0),
            flex_shrink: 0.0,
            border: UiRect::all(Val::Px(2.0)),
            border_radius: BorderRadius::all(Val::Px(7.0)),
            ..default()
        },
        BackgroundColor(if done { ink } else { Color::NONE }),
        BorderColor::all(if done { ink } else { ink.with_alpha(0.35) }),
    )
}

/// Columns the shelf is dealt into. One: at the type sizes the rest of the
/// game reads at, a trophy's name and what it asks for do not fit two to a
/// line, and at the old two columns of 580px some thirty names and fifty
/// descriptions across the eight languages lost their tails. The shelf
/// scrolls, so every trophy is still a keypress away.
const COLS: usize = 1;

/// A trophy row's width, the width two 580px columns and their gap took,
/// and the name column inside it. Shared with the tests that measure every
/// name and description against them, which used to copy the numbers.
pub(super) const ROW_PX: f32 = 1176.0;
pub(super) const NAME_PX: f32 = 300.0;

/// A trophy tile's own height, and the `row_gap` the column puts under it.
/// Named rather than inlined because the viewport height below is derived
/// from them, and a row that changed shape without them would cut the
/// bottom row in half. Set on the tile as well, rather than left to what
/// its text measures: it was 32 when the name was 15px, the name grew to
/// 17, the tile to 35, and the shelf went on scrolling by 34 and showing
/// the last row sliced through the middle.
const TILE_HEIGHT: f32 = 35.0;
const TILE_GAP: f32 = 2.0;

/// A trophy row and the gap under it. One press of a scroll key moves
/// exactly this, so the shelf comes to rest on row boundaries instead of
/// drifting half a row out of step with itself.
const ROW_PITCH: f32 = TILE_HEIGHT + TILE_GAP;

/// Rows the viewport shows at once. Thirteen is what fits between the
/// header and the prompt with the count above and the lifetime line below,
/// at the 35px a tile takes. It is
/// no longer a cap on how many trophies there may be, only on how many are
/// in front of you at once.
const SHELF_ROWS: f32 = 13.0;

/// The viewport height: whole rows, so the shelf never cuts one in half.
/// The last row has no gap under it, hence the one gap taken back off.
const SHELF_HEIGHT: f32 = SHELF_ROWS * ROW_PITCH - TILE_GAP;

/// The scrolling viewport, so the input system can find it.
#[derive(Component)]
pub struct Shelf;

/// The shelf's scroll bar, kept on the shelf's viewport by
/// [`update_shelf_scrollbar`].
#[derive(Component)]
pub struct ShelfBar;

/// One trophy's row: the mark, its name, what it asks for, how far along,
/// and a bar saying the same thing at a glance. "292/1000" is a fact you
/// have to read; a bar a third full is one you can see.
fn spawn_trophy(
    column: &mut ChildSpawnerCommands,
    tr: &crate::app::i18n::Tr,
    index: usize,
    done: bool,
    now: u32,
    goal: u32,
) {
    // A locked trophy is a rumour, not a deed: it drops back further than
    // the earned rows so the shelf reads at a glance.
    let ink = if done {
        palette::SELECTED_ROW
    } else {
        palette::IDLE_ROW.with_alpha(0.55)
    };
    column
        .spawn((
            Node {
                width: Val::Px(ROW_PX),
                height: Val::Px(TILE_HEIGHT),
                flex_direction: FlexDirection::Column,
                row_gap: Val::Px(3.0),
                padding: UiRect::axes(Val::Px(8.0), Val::Px(4.0)),
                border_radius: BorderRadius::all(Val::Px(6.0)),
                ..default()
            },
            // Earned rows carry a wash of gold behind them, so the screen
            // reads as a shelf with gaps rather than a list with markers.
            BackgroundColor(if done {
                palette::GOLD.with_alpha(0.10)
            } else {
                Color::NONE
            }),
        ))
        .with_children(|tile| {
            tile.spawn(Node {
                column_gap: Val::Px(8.0),
                align_items: AlignItems::Center,
                width: Val::Percent(100.0),
                ..default()
            })
            .with_children(|line| {
                line.spawn(unlock_mark(done, ACHIEVEMENTS[index].id));
                // A fixed name column, so every description starts at the
                // same x and the eye can run down the list of what to do.
                // Wide enough for the longest name in any language, which
                // `every_trophy_name_fits_its_column` measures in pixels.
                line.spawn((
                    Node {
                        width: Val::Px(NAME_PX),
                        flex_shrink: 0.0,
                        overflow: Overflow::clip_x(),
                        ..default()
                    },
                    children![(
                        Text::new(tr.ach_names[index].to_string()),
                        TextFont {
                            font_size: FontSize::Px(menu_ui::type_scale::BODY),
                            ..default()
                        },
                        TextLayout::no_wrap(),
                        TextColor(ink),
                    )],
                ));
                // `min_width: 0` on purpose: a flex item will not shrink
                // below its content by default, so the longest description
                // would push the count off the end of the row instead of
                // being clipped itself.
                line.spawn((
                    Node {
                        flex_grow: 1.0,
                        flex_basis: Val::Px(0.0),
                        min_width: Val::Px(0.0),
                        overflow: Overflow::clip_x(),
                        ..default()
                    },
                    children![(
                        Text::new(tr.ach_descs[index].to_string()),
                        TextFont {
                            font_size: FontSize::Px(menu_ui::type_scale::FINE),
                            ..default()
                        },
                        TextLayout::no_wrap(),
                        TextColor(palette::PARCHMENT.with_alpha(if done { 0.7 } else { 0.45 })),
                    )],
                ));
                line.spawn((
                    Node {
                        flex_shrink: 0.0,
                        ..default()
                    },
                    children![(
                        Text::new(format!("{now}/{goal}")),
                        TextFont {
                            font_size: FontSize::Px(menu_ui::type_scale::FINE),
                            ..default()
                        },
                        TextLayout::no_wrap(),
                        TextColor(palette::PARCHMENT.with_alpha(if done { 0.7 } else { 0.4 })),
                    )],
                ));
            });
            // The track, and the part of it filled in. `goal` is never zero
            // (a threshold of nothing is not an achievement), but the sim
            // does not enforce that, so the division guards itself.
            let filled = if goal == 0 {
                100.0
            } else {
                (now.min(goal) as f32 / goal as f32) * 100.0
            };
            tile.spawn((
                Node {
                    width: Val::Percent(100.0),
                    height: Val::Px(3.0),
                    border_radius: BorderRadius::all(Val::Px(2.0)),
                    ..default()
                },
                BackgroundColor(palette::BAR_TRACK),
                children![(
                    Node {
                        width: Val::Percent(filled),
                        height: Val::Percent(100.0),
                        border_radius: BorderRadius::all(Val::Px(2.0)),
                        ..default()
                    },
                    BackgroundColor(if done {
                        palette::GOLD
                    } else {
                        palette::GOLD.with_alpha(0.45)
                    }),
                )],
            ));
        });
}

pub fn enter_achievements(
    mut commands: Commands,
    settings: Res<GameSettings>,
    stats: Res<Stats>,
    unlocked: Res<Unlocked>,
) {
    let tr = settings.tr();
    let per_column = ACHIEVEMENTS.len().div_ceil(COLS);
    commands
        .spawn((
            AchievementsUi,
            // Between the bars and centred in what is left, the same
            // frame the stage list sits in - which it now literally is.
            // It said so while sitting two pixels inside it.
            menu_ui::between_bars(),
        ))
        .with_children(|wrap| {
            // The shared card, with room between the count, the shelf and
            // the key. `bg` and not `fill`: this file's `fill` is the one
            // that puts words into a translated string, and it is used all
            // through the card below.
            let (mark, mut node, bg, edge, shadow) = menu_ui::screen_card();
            node.row_gap = Val::Px(8.0);
            wrap.spawn((mark, node, bg, edge, shadow))
                .with_children(|card| {
                    let earned = ACHIEVEMENTS
                        .iter()
                        .filter(|a| unlocked.0.contains(a.id))
                        .count();
                    card.spawn((
                        Text::new(fill(
                            tr.ach_progress,
                            &[
                                ("a", &earned.to_string()),
                                ("b", &ACHIEVEMENTS.len().to_string()),
                            ],
                        )),
                        TextFont {
                            font_size: FontSize::Px(menu_ui::type_scale::ROW),
                            ..default()
                        },
                        TextColor(palette::PARCHMENT.with_alpha(0.75)),
                    ));
                    // The shelf and its scrollbar ride together: a list that
                    // stops at a clean row boundary looks finished, and the
                    // prompt in the corner is not where anyone is looking.
                    card.spawn(Node {
                        column_gap: Val::Px(menu_ui::scroll_bar::BAR_GAP),
                        ..default()
                    })
                    .with_children(|band| {
                        band.spawn((
                            Shelf,
                            Node {
                                // The viewport. Its child is as tall as the
                                // trophies make it and slides behind this.
                                max_height: Val::Px(SHELF_HEIGHT),
                                overflow: Overflow::scroll_y(),
                                ..default()
                            },
                            ScrollPosition::default(),
                        ))
                        .with_children(|shelf| {
                            shelf
                                .spawn(Node {
                                    column_gap: Val::Px(16.0),
                                    ..default()
                                })
                                .with_children(|grid| {
                                    for chunk in 0..COLS {
                                        grid.spawn(Node {
                                            flex_direction: FlexDirection::Column,
                                            row_gap: Val::Px(2.0),
                                            ..default()
                                        })
                                        .with_children(
                                            |column| {
                                                let first = chunk * per_column;
                                                let last =
                                                    (first + per_column).min(ACHIEVEMENTS.len());
                                                for (index, achievement) in ACHIEVEMENTS
                                                    .iter()
                                                    .enumerate()
                                                    .take(last)
                                                    .skip(first)
                                                {
                                                    let done = unlocked.0.contains(achievement.id);
                                                    let (now, goal) = achievement.progress(&stats);
                                                    spawn_trophy(
                                                        column, tr, index, done, now, goal,
                                                    );
                                                }
                                            },
                                        );
                                    }
                                });
                        });
                        // The bar that says how far down the shelf you
                        // are, as tall as the viewport beside it. Placed by
                        // `update_shelf_scrollbar`, which is the only thing
                        // that knows how tall the rows turned out to be.
                        menu_ui::scroll_bar::spawn(band, ShelfBar);
                    });
                    let footer = fill(
                        tr.stats_footer,
                        &[
                            ("banked", &stats.banked.to_string()),
                            ("golden", &stats.golden.to_string()),
                            ("wins", &stats.wins.to_string()),
                            ("rounds", &stats.rounds.to_string()),
                            ("puzzles", &stats.puzzles.to_string()),
                        ],
                    );
                    card.spawn((
                        Text::new(footer),
                        TextFont {
                            font_size: FontSize::Px(menu_ui::type_scale::BODY),
                            ..default()
                        },
                        TextColor(palette::PARCHMENT.with_alpha(0.6)),
                    ));
                });
        });
}

pub fn achievements_input(
    keys: Res<ButtonInput<KeyCode>>,
    mut next_screen: ResMut<NextState<crate::app::Screen>>,
    mut shelf: Query<(&mut ScrollPosition, &ComputedNode), With<Shelf>>,
) {
    if keys.just_pressed(KeyCode::Escape) || menu_ui::enter(&keys) {
        next_screen.set(crate::app::Screen::Menu);
        return;
    }
    let pressed = |a, b| keys.just_pressed(a) || keys.just_pressed(b);
    let mut step = 0.0;
    if pressed(KeyCode::KeyS, KeyCode::ArrowDown) {
        step += ROW_PITCH;
    }
    if pressed(KeyCode::KeyW, KeyCode::ArrowUp) {
        step -= ROW_PITCH;
    }
    if step == 0.0 {
        return;
    }
    for (mut position, computed) in &mut shelf {
        let scale = computed.inverse_scale_factor();
        position.0.y = scrolled(
            position.0.y,
            step,
            computed.size().y * scale,
            computed.content_size().y * scale,
        );
    }
}

/// Show the shelf's viewport on its scroll bar, in pixels: how far down
/// it is scrolled, how tall it is, and how tall the shelf behind it is.
///
/// Runs every frame the screen is up rather than on a scroll message: the
/// rows are measured by the layout a frame after they are spawned, so the
/// first honest answer is not available at the moment the shelf is built.
pub fn update_shelf_scrollbar(
    shelf: Query<(&ScrollPosition, &ComputedNode), With<Shelf>>,
    mut bars: menu_ui::scroll_bar::ScrollBars<ShelfBar>,
) {
    let Ok((position, computed)) = shelf.single() else {
        return;
    };
    let scale = computed.inverse_scale_factor();
    bars.show(menu_ui::scroll_bar::ScrollWindow {
        first: position.0.y,
        shown: computed.size().y * scale,
        total: computed.content_size().y * scale,
    });
}

/// Where a scroll of `step` lands, given what the viewport shows and how
/// tall the shelf behind it is.
///
/// Clamped here rather than left to the layout, which clamps what it
/// *draws* and leaves the component alone: an unclamped component runs past
/// the end of the list, and the first presses back move nothing.
fn scrolled(from: f32, step: f32, viewport: f32, content: f32) -> f32 {
    (from + step).clamp(0.0, (content - viewport).max(0.0))
}

#[cfg(test)]
mod tests {
    use super::*;

    /// The shelf stops at both ends, and stops *at* them: a component left
    /// to run past the bottom would take several presses to start moving
    /// back up, which feels like a dropped key rather than a limit.
    #[test]
    fn the_shelf_stops_at_both_ends() {
        // Ten rows of content behind a viewport showing four of them.
        let viewport = 4.0 * ROW_PITCH;
        let content = 10.0 * ROW_PITCH;
        let bottom = content - viewport;

        assert_eq!(scrolled(0.0, -ROW_PITCH, viewport, content), 0.0, "at rest");
        assert_eq!(scrolled(0.0, ROW_PITCH, viewport, content), ROW_PITCH);
        assert_eq!(
            scrolled(bottom, ROW_PITCH, viewport, content),
            bottom,
            "the last row is the last row"
        );
        // And one press back from the bottom moves exactly one row, which
        // is what an unclamped component would get wrong.
        assert_eq!(
            scrolled(bottom, -ROW_PITCH, viewport, content),
            bottom - ROW_PITCH
        );

        // A list shorter than its viewport does not scroll at all.
        assert_eq!(scrolled(0.0, ROW_PITCH, viewport, viewport - 10.0), 0.0);
    }

    /// The trophy shelf's bar shows the viewport the trophies scroll
    /// behind, in pixels: at the top at rest, at the bottom once the input
    /// has scrolled as far as it goes, and hidden when the shelf fits.
    #[test]
    fn the_bar_follows_the_shelf_viewport() {
        use crate::app::menu_ui::scroll_bar::{self, reading};
        use bevy::ecs::system::RunSystemOnce;
        let mut app = App::new();
        app.init_resource::<ButtonInput<KeyCode>>();
        let shelf = app
            .world_mut()
            .spawn((
                Shelf,
                ScrollPosition::default(),
                ComputedNode {
                    size: Vec2::new(400.0, 4.0 * ROW_PITCH),
                    content_size: Vec2::new(400.0, 10.0 * ROW_PITCH),
                    inverse_scale_factor: 1.0,
                    ..default()
                },
            ))
            .id();
        app.world_mut()
            .run_system_once(|mut commands: Commands| {
                commands.spawn(Node::default()).with_children(|band| {
                    scroll_bar::spawn(band, ShelfBar);
                });
            })
            .expect("the bar is built");
        app.add_systems(Update, update_shelf_scrollbar);
        let bar = |app: &mut App| {
            app.update();
            reading::<ShelfBar>(app.world_mut())
        };
        assert_eq!(bar(&mut app), Some([0.0, 0.4, 0.6]), "at the top");

        // As far down as the input goes: the bottom of the track.
        let bottom = scrolled(1000.0, 0.0, 4.0 * ROW_PITCH, 10.0 * ROW_PITCH);
        app.world_mut()
            .entity_mut(shelf)
            .insert(ScrollPosition(Vec2::new(0.0, bottom)));
        let [above, thumb, below] = bar(&mut app).expect("still overflows");
        assert!((above - 0.6).abs() < 1e-5 && thumb == 0.4 && below.abs() < 1e-5);

        // A shelf that fits its viewport has no bar.
        app.world_mut().entity_mut(shelf).insert(ComputedNode {
            size: Vec2::new(400.0, 4.0 * ROW_PITCH),
            content_size: Vec2::new(400.0, 3.0 * ROW_PITCH),
            inverse_scale_factor: 1.0,
            ..default()
        });
        assert_eq!(bar(&mut app), None);
    }

    /// The viewport is whole rows, so the shelf never rests showing half of
    /// one. Fifteen tiles and the fourteen gaps between them.
    #[test]
    fn the_viewport_is_whole_rows() {
        assert_eq!(
            SHELF_HEIGHT,
            SHELF_ROWS * TILE_HEIGHT + (SHELF_ROWS - 1.0) * TILE_GAP
        );
    }

    /// An unlock while a host's map page is up waits under it: unseen and
    /// not ageing while the page is up, and shown, its time running, once
    /// it is down. It used to sit over the page's corner and scroll bar.
    #[test]
    fn a_toast_waits_out_the_map_page() {
        use bevy::ecs::system::RunSystemOnce;
        use std::time::Duration;
        let mut app = App::new();
        app.insert_resource(Time::<()>::default());
        app.insert_resource(GameSettings::default());
        app.init_resource::<crate::app::audio::Muted>();
        app.insert_resource(crate::app::match_setup::MatchMenu {
            online: true,
            step: crate::app::match_setup::Step::Map,
            ..Default::default()
        });
        app.add_systems(Update, update_toasts);
        app.world_mut()
            .run_system_once(|mut commands: Commands| spawn_toast(&mut commands, "A", "B"))
            .expect("spawned");
        let toast = |app: &mut App| {
            let world = app.world_mut();
            world
                .query::<(&Toast, &Node)>()
                .iter(world)
                .map(|(toast, node)| (toast.age, node.display))
                .next()
        };
        for _ in 0..3 {
            app.world_mut()
                .resource_mut::<Time>()
                .advance_by(Duration::from_secs(2));
            app.update();
        }
        assert_eq!(toast(&mut app), Some((0.0, Display::None)), "held");
        app.world_mut()
            .resource_mut::<crate::app::match_setup::MatchMenu>()
            .online = false;
        app.world_mut()
            .resource_mut::<Time>()
            .advance_by(Duration::from_secs(1));
        app.update();
        let (age, display) = toast(&mut app).expect("still up");
        assert_eq!(display, Display::Flex, "shown once the page is down");
        assert!(age > 0.0 && age < TOAST_LIFE, "{age}");
    }
}