Skip to main content

Screen

shuyi_ui::screen

Trait Screen 

Source 
pub trait Screen<G: GameData> {
    // Required methods
    fn name(&self) -> &'static str;
    fn update(
        &mut self,
        ctx: &mut Ctx<G>,
        input: &FrameInput<G::Action>,
    ) -> Transition<G>;
    fn draw(&self, ctx: &Ctx<G>, buf: &mut GlyphBuffer);

    // Provided methods
    fn debug_draw(&self, ctx: &Ctx<G>, out: &mut Gizmos) { ... }
    fn is_overlay(&self) -> bool { ... }
    fn actions(&self) -> Option<Vec<G::Action>> { ... }
    fn state_hash(&self) -> Option<StateHash> { ... }
    fn as_any(&self) -> Option<&dyn Any> { ... }
    fn as_any_mut(&mut self) -> Option<&mut dyn Any> { ... }
    fn covered(&mut self, _ctx: &mut Ctx<G>) { ... }
    fn uncovered(
        &mut self,
        ctx: &mut Ctx<G>,
        result: Option<ScreenResult>,
    ) -> Transition<G> { ... }
}
Expand description

One screen of a game: a title, a map, a menu overlay, …

Required Methods§

Source

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

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

Source

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.

Source

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

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

Provided Methods§

Source

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.

Source

fn is_overlay(&self) -> bool

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

Source

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

The actions this screen reacts to, in any order (ADR-0008 §3): every one it reads from its input, through ActionSet::ui or not. None, the default, has not declared them, and counts as every action of the game: shuyi check --target warns about it. An overlay declares its own, and is checked on its own.

ui_actions gives a game’s actions for the UiActions an engine screen or widget reacts to.

Source

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.

Source

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.

Source

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

as_any, mutable (ScreenStack::find_mut).

Source

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.

Source

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.

// A question screen answers yes…
let result = Some(ScreenResult::new(true));
// …and the screen below reads it as the type the two agree on.
let yes = result.and_then(ScreenResult::take::<bool>) == Some(true);
assert!(yes);

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§