Score and HUD

/// An enemy's hits: each laser that meets it costs it a hit point, the last one
/// removes it and adds its points to the score, a hit it lives through flashes
/// it white, and meeting the ship removes it too, for no points.
component Enemy : Area {
    /// How many lasers it takes to remove it.
    hit_points: i32 = 1,
    /// How long the white flash of a hit takes to fade.
    #[suffix("s")]
    flash_time: f32 = 0.12,
    /// What shooting it down adds to the score.
    points: f32 = 100.0,

    /// When its Area meets another that it notices, on the node `other`: a
    /// laser's or the ship's.
    fn on_enter(other: NodeId) {
        // The groups `other` is in say which it is.
        if in_group(other, "shot") {
            hit_points -= 1;
            if hit_points <= 0 {
                // Shot down: its points go on the score. The game keeps the
                // score as it keeps the lives, so the HUD can show it.
                add_number("score", points);
                destroy_self();
            } else {
                // A hit it lives through washes it white at once, and the
                // white fades back to its own colours over flash_time.
                set_number("SpriteComponent", "flash", 1.0);
                anneal_number("SpriteComponent", "flash", 0.0, flash_time, .Linear);
            }
        } else if in_group(other, "ship") {
            // Rammed: it goes, and scores nothing. The ship loses a life.
            destroy_self();
        }
    }
}

/// The player's ship: it flies where `move` points, never leaves the field,
/// fires lasers while `fire` is held, and keeps its position for whatever aims
/// at it. Whatever its Area meets costs it a life: it flashes white, then
/// blinks, and nothing can hit it while it does. On its last life it is gone.
/// Each whole second it stays alive adds 10 to the score.
component Ship : Area {

    /// What each whole second alive adds to the score.
    points_a_second: f32 = 10.0,
    /// Seconds alive since the last whole one was scored.
    #[hidden]
    alive: f32 = 0.0,

        // Points for staying alive, a whole second's worth at a time, so the
        // score stays a whole number. The ship counts its own seconds: once it
        // is gone its loop runs no more, and the count stops.
        alive += dt;
        if alive >= 1.0 {
            // Take the second away rather than start again at 0: what is over
            // it counts toward the next one, so the count never falls behind.
            alive -= 1.0;
            add_number("score", points_a_second);
        }

/// The score, on the HUD: the points the game keeps under the name "score",
/// written onto this node's Text as SCORE and the number, whenever it changes.
component Score {
    /// The score the label says. Below any score, so the first step writes it.
    #[hidden]
    shown: f32 = -1.0,

    fn loop() {
        let score = kept_number("score", 0.0);
        // Only when the score changes: the text is written each time it is
        // set, the same text included, and the score stands still on most
        // steps.
        if score != shown {
            shown = score;
            set_text("TextComponent", "text", "SCORE " + text(score));
        }
    }
}

/// The best score, on the HUD: the one saved under the name "best", written
/// onto this node's Text as BEST and the number. It changes only when the
/// saved value does, which is when a game ends.
component Best {
    /// The best the label says. Below any score, so the first step writes it.
    #[hidden]
    shown: f32 = -1.0,

    fn loop() {
        // The saved best, not the score: a score passing it during the game
        // is not a best until the game ends and saves it.
        let best = saved_number("best", 0.0);
        if best != shown {
            shown = best;
            set_text("TextComponent", "text", "BEST " + text(best));
        }
    }
}

/// One of the lives on the HUD: an icon, shown while the ship still has that
/// life and hidden once it is lost.
component Life {
    /// Which life this is, counting from 0 at the left. The icons are 0, 1 and
    /// 2, and the ship loses the rightmost first.
    // A number with decimals, though it only ever counts, because it is
    // compared with the lives, which the game keeps as one.
    index: f32 = 0.0,
    /// The lives it last counted. Below any count, so the first step decides.
    #[hidden]
    counted: f32 = -1.0,

    fn loop() {
        let lives = kept_number("lives", 3.0);
        // Only when the lives change, as the labels do.
        if lives != counted {
            counted = lives;
            // An icon at or above the lives left is a life lost: with 2 left,
            // icons 0 and 1 stay and icon 2 goes. Each icon has a place of its
            // own on the canvas, so hiding one leaves the others where they
            // are.
            if index >= lives {
                hide();
            } else {
                show();
            }
        }
    }
}