Game over

/// The end of a game, on the game-over screen's root: the game's music stops,
/// and a jingle says how the game went, rising for a new best and falling
/// otherwise. A score that beats the best is saved as the new best, here,
/// where the game ends.
component GameOver {
    fn on_create() {
        // The music plays on through a change of scene, on its one channel,
        // so it is stopped here, and the jingle is heard alone.
        stop_music();
        // Both as this step began: the score the game kept, and the best saved
        // before it.
        let score = kept_number("score", 0.0);
        let best = saved_number("best", 0.0);
        if score > best {
            save_number("best", score);
            // This node's Audio Source is on the music bus, so the jingles are
            // too.
            play_sound("new best");
        } else {
            play_sound("game over");
        }
    }
}

/// The best score, on the game-over screen: the best saved before this game,
/// or this game's score where it beat it. That is the best the screen saves
/// as it opens, shown from its first picture.
component FinalBest {
    fn on_create() {
        let best = max(saved_number("best", 0.0), kept_number("score", 0.0));
        set_text("TextComponent", "text", "BEST " + text(best));
    }
}

/// The NEW BEST! label, on the game-over screen: hidden, unless the game that
/// just ended beat the best, and then shown, pulsing.
component NewBest {
    /// How much bigger the label grows at the top of a pulse.
    grow_to: f32 = 1.2,
    /// How long a pulse takes to grow, and the same again to shrink.
    #[suffix("s")]
    pulse_time: f32 = 0.4,

    fn on_create() {
        // As this step began: the best saved before this game, which the
        // screen replaces at the end of this step.
        if kept_number("score", 0.0) > saved_number("best", 0.0) {
            show();
            // Its Text's size, not the node's: a label on a canvas is placed
            // by its Rect, and its node's scale is never read.
            pulse_number("TextComponent", "scale", grow_to, pulse_time, .InOutSine);
        }
    }
}

/// The game-over screen's buttons. They come up a moment after the screen
/// does, so a press of Space meant for the ship's lasers, just as the game
/// ends, starts nothing. Retry is the NewGame beside this; Title goes back to
/// the title.
component GameOverMenu {
    /// How long the buttons wait before they come up.
    #[suffix("s")]
    delay: f32 = 1.0,
    /// Whether they have come up.
    #[hidden]
    shown: bool = false,

    fn on_create() {
        // Hidden until now: a hidden button can be neither focused nor
        // pressed.
        await wait(delay);
        show();
        shown = true;
    }

    fn loop() {
        if shown && (pressed("ui_up") || pressed("ui_down")) {
            play_sound("move");
        }
        if pressed("title") {
            // A sound asked for on the step that changes scene plays on after
            // it.
            play_sound("press");
            change_scene("title");
        }
    }
}

/// The game itself, on the scene's root node: it starts the game's music, and
/// when the ship has lost its last life, it waits 1.5 s and moves the game on
/// to the game-over screen.
///
/// The root, because it stays in the scene from the first step to the last.
/// The ship cannot do this itself: it is gone on its last life, and a node
/// that is gone runs no hooks. So the ship sends "game over" to the group
/// "game", which this node is in.
component Game {
    /// Seconds from the last life to the game-over screen.
    #[suffix("s")]
    restart_delay: f32 = 1.5,

    fn on_create() {
        // The track this node's Audio Source names "music", on the channel
        // music plays on. A new game asks for it as it starts: it replaces the
        // title's loop, or starts again from the top after the game-over
        // screen stopped the music.
        play_music("music");
    }

    fn loop() {
        await signal("game over");
        await wait(restart_delay);
        // The game-over screen saves a beaten best, and its Retry starts a new
        // game with its kept values set. Here the game only ends.
        change_scene("game_over");
    }
}

        // The saved best, not the score: a score passing it during the game
        // is not a best until the game ends and the game-over screen saves it.

        // Once the last stage has begun, there is nothing left to count to. And
        // once the last life is lost the game is over: no stage begins while it
        // waits to move on to the game-over screen. A game played straight from
        // its own scene has kept no lives yet, and has 3.

/// A new game, from the button whose action this names: its press's sound,
/// the game's kept values as a new game starts with them, and the game's
/// scene. The button is Play on the title, and Retry on the game-over screen.

/// The score, on the HUD and on the game-over screen: the points the game
/// keeps under the name "score", written onto this node's Text as SCORE and
/// the number, whenever it changes.

        // The lives are kept rather than held in a field of the ship's, so
        // that any script can read them, as the HUD does. NewGame keeps 3
        // before each new game, as the title's Play or the game-over screen's
        // Retry is pressed. A game played straight from its own scene has kept
        // none, and has 3.

            // The last life: a bigger shake, a big explosion where the ship
            // was, and the ship is gone. A node that is gone runs no hooks, so
            // the ship cannot wait to move the game on to the game-over
            // screen: the game's own node, which stays, does that when it
            // hears "game over".