Struct OptionsScreen 

pub struct OptionsScreen<G: GameData> { /* private fields */ }

The options screen. Cancel closes it, asking first if anything changed.

Implementations

impl<G: GameData> OptionsScreen<G>

pub const NAME: &'static str = "options"

Name reported by Screen::name.

pub fn new(rows: Rows<G>) -> Self

The screen of rows, its first row focused.

pub fn painted_by(self, paint: Paint<G>) -> Self

The same screen with its view painted by paint instead of glyph::paint: a game’s look for a device of its own.

pub fn focused_on(self, key: &'static str) -> Self

The same screen focused on the row key (on the first row while that one isn’t shown).

pub fn rows(&self, ctx: &Ctx<G>) -> Vec<OptionRow<G>>

The rows ctx shows, top to bottom: the game’s, less the Fullscreen row (OptionRow::fullscreen’s key) where the game isn’t in a window (PlatformFacts::windowed): a device that is always full screen.

pub fn focus(&self, ctx: &Ctx<G>) -> &'static str

The focused row’s key ("" with no rows).

pub fn asking(&self) -> Option<&'static str>

The key of the question open, if any.

pub fn leaving(&self) -> Option<LeaveChoice>

The answer in focus while the question asked on leaving with changes is open.

pub fn changed(&self, ctx: &Ctx<G>) -> bool

Whether any setting, or any row that isn’t one, differs from when the screen opened (the layout aside: it is saved when picked).

pub fn typing(&self) -> Option<&NumberBox>

The volume box, while it is open.

pub fn message(&self) -> Option<&str>

The text key of the message under the panel, if any.

pub fn value(ctx: &Ctx<G>, row: &OptionRow<G>) -> ValueView

What row shows beside its name. (The volume box, while open, is the screen’s: view.)

pub fn view(&self, ctx: &Ctx<G>) -> OptionsView

The screen as it is now, as plain data for a skin to paint (glyph::paint): every row with its name and value, the row in focus, the volume box if it is open, the message, the question and the help line, all in the player’s language and naming their keys.

pub fn help(&self, ctx: &Ctx<G>) -> String

The bottom help line, naming the keys of the active keymap (or their buttons, on a controller): what Confirm does on the focused row, if anything.

Trait Implementations

impl<G: GameData> Debug for OptionsScreen<G>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<G: GameData> Screen<G> for OptionsScreen<G>

fn actions(&self) -> Option<Vec<G::Action>>

Its rows, its questions and the volume box on a controller.

fn name(&self) -> &'static str

A stable, unique snake_case name, for tests and debugging.

fn update( &mut self, ctx: &mut Ctx<G>, input: &FrameInput<G::Action>, ) -> Transition<G>

Handles one frame: input holds this frame’s actions (often none) and elapsed time. Called only while this screen is on top.

fn draw(&self, ctx: &Ctx<G>, buf: &mut GlyphBuffer)

Paints the screen. An opaque screen must cover the whole buffer.

fn as_any(&self) -> Option<&dyn Any>

This screen as Any, for tests that look inside a screen on the stack (ScreenStack::find). None unless the screen opts in.

fn debug_draw(&self, ctx: &Ctx<G>, out: &mut Gizmos)

Hands in what the debug view shows of this screen (ADR-0085): its gizmos, each in its channel, in console pixels, built from self and ctx alone, so looking changes nothing. A channel’s helper (the grid kit’s layout_gizmos) does the work. Called after draw on every screen drawn, bottom up, only while debug tools are on (Ctx::debug_tools). Does nothing unless the screen has something to show.

fn is_overlay(&self) -> bool

Whether the screen below shows through (drawn first, then this one).

fn state_hash(&self) -> Option<StateHash>

The hash of the game’s state this screen holds, which goes in each frame’s hash in a session record (Game::state_hash), most simply shuyi_core::state_hash(&self.rules).ok(): so a playback that plays differently is found at the frame the state moved. None unless the screen opts in.

fn as_any_mut(&mut self) -> Option<&mut dyn Any>

as_any, mutable (ScreenStack::find_mut).

fn covered(&mut self, _ctx: &mut Ctx<G>)

Called when a screen is pushed on top of this one (Transition::Push): it is no longer updated until it is uncovered. Not called when the screen above swaps itself for another (Transition::Replace). Does nothing unless the screen needs it.

fn uncovered( &mut self, ctx: &mut Ctx<G>, result: Option<ScreenResult>, ) -> Transition<G>

Called when the screen above pops and this one is on top again: result is what it popped with (Transition::PopWith), None after a plain Transition::Pop. The transition returned is applied at once, as if from update, so a screen can act on the answer in the same frame: push the next screen, or pop with an answer of its own. By default, nothing happens.