pub trait Screen<G>where
G: GameData,{
// Required methods
fn name(&self) -> &'static str;
fn update(
&mut self,
ctx: &mut Ctx<G>,
input: &FrameInput<<G as GameData>::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 as GameData>::Action>> { ... }
fn state_hash(&self) -> Option<StateHash> { ... }
fn as_any(&self) -> Option<&(dyn Any + 'static)> { ... }
fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)> { ... }
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§
Sourcefn update(
&mut self,
ctx: &mut Ctx<G>,
input: &FrameInput<<G as GameData>::Action>,
) -> Transition<G>
fn update( &mut self, ctx: &mut Ctx<G>, input: &FrameInput<<G as GameData>::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.
Sourcefn draw(&self, ctx: &Ctx<G>, buf: &mut GlyphBuffer)
fn draw(&self, ctx: &Ctx<G>, buf: &mut GlyphBuffer)
Paints the screen. An opaque screen must cover the whole buffer.
Provided Methods§
Sourcefn debug_draw(&self, ctx: &Ctx<G>, out: &mut Gizmos)
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.
Sourcefn is_overlay(&self) -> bool
fn is_overlay(&self) -> bool
Whether the screen below shows through (drawn first, then this one).
Sourcefn actions(&self) -> Option<Vec<<G as GameData>::Action>>
fn actions(&self) -> Option<Vec<<G as GameData>::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.
Sourcefn state_hash(&self) -> Option<StateHash>
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.
Sourcefn as_any(&self) -> Option<&(dyn Any + 'static)>
fn as_any(&self) -> Option<&(dyn Any + 'static)>
This screen as Any, for tests that look inside a screen on the
stack (ScreenStack::find). None unless the screen opts in.
Sourcefn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>
fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>
as_any, mutable (ScreenStack::find_mut).
Sourcefn covered(&mut self, _ctx: &mut Ctx<G>)
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.
Sourcefn uncovered(
&mut self,
ctx: &mut Ctx<G>,
result: Option<ScreenResult>,
) -> Transition<G>
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".