Struct KeyBindingsScreen 

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

The Key bindings screen for one layout and the controller. Cancel saves and closes it, unless a required action has no key or no button.

Implementations

impl<G: GameData> KeyBindingsScreen<G>

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

Name reported by Screen::name.

pub fn new(ctx: &Ctx<G>, rows: &'static [KeyRow<G::Action>]) -> Self

The screen listing rows, for the layout in use (the keymap file’s first if none is chosen yet), focused on the first action’s first slot, showing the side the player pressed last: the controller’s buttons after a button press, else the keys. With no keyboard (Keyboard::Absent) it shows the controller’s alone.

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 is_controller_only(&self) -> bool

Whether only the controller side is shown: the platform has no keyboard, so there is no switch.

pub fn with_bindings(self, bindings: LayoutBindings<G::Action>) -> Self

The same screen editing bindings instead of the saved ones.

pub fn bindings(&self) -> &LayoutBindings<G::Action>

The edited keys (saved when the screen closes).

pub fn pad_bindings(&self) -> &PadBindings<G::Action>

The edited controller buttons (saved when the screen closes).

pub fn side(&self) -> Side

Which bindings are shown.

pub fn focus(&self) -> Option<(G::Action, usize)>

The focused action and slot; None on Restore defaults and on the keyboard / controller switch.

pub fn is_on_switch(&self) -> bool

Whether the focus is on the keyboard / controller switch.

pub fn is_capturing(&self) -> bool

Whether the focused slot is waiting for a key or button.

pub fn choice(&self) -> Option<usize>

The focused line of CHOICES, while they are open.

pub fn is_asking_restore(&self) -> bool

Whether the screen is asking before it restores the defaults.

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

The question asked before restoring the shown side’s defaults.

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

The message under the panel, if any.

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

The bottom help line, naming the keys the screen was opened with (or their buttons, on a controller): the same as ctx’s until the screen closes.

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

The screen as it is now, as plain data for a skin to paint (glyph::paint): the switch, the slot columns, every action with what its slots hold, the restore row, the message, the question or the choices open, and the help line, all in the player’s language and naming their keys.

Trait Implementations

impl<G: GameData> Clone for KeyBindingsScreen<G>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Its rows and slots, and its questions; the keys and buttons it captures are not actions.

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.