Struct BasicGame 

pub struct BasicGame<A: ActionSet, T: Debug + 'static = ()> { /* private fields */ }

A game on the short path: its data is a BasicData of actions A and its own part T, read from one layer of files.

Implementations

impl<A: ActionSet> BasicGame<A>

pub fn new(app: AppInfo, files: Layer, first: First<A, ()>) -> Self

The game app (its name, and the storage its saves are kept under), its files in files, starting on the screen first makes.

impl<A: ActionSet, T: Debug + 'static> BasicGame<A, T>

pub fn with_own( app: AppInfo, files: Layer, own: Own<T>, first: First<A, T>, ) -> Self

As BasicGame::new, for a game with a part of its own, which own reads from its files (BasicData::own).

pub fn console(self, console: ConsoleSpec) -> Self

The same game on console (BASIC_CONSOLE until said).

pub fn screens(self, screens: Screens<A, T>) -> Self

The same game, with screens every screen it can show (its first alone until said).

pub fn modules(self, modules: Modules<A, T>) -> Self

The same game, with the modules modules makes installed in its Game (none until said).

pub fn crash_record(self, hook: CrashRecord<BasicData<A, T>>) -> Self

The same game, with hook its record of its play in a crash report (Start::crash_record; none until said).

pub fn app(&self) -> AppInfo

Who it is.

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

Its name: the window’s title and the loading card’s line.

pub fn storage_name(&self) -> &'static str

The name its saves are kept under.

pub fn console_spec(&self) -> ConsoleSpec

The console it starts on.

pub fn over(self, layer: Layer) -> Self

The same game with layer laid over its files: a folder on disk (shuyi_app::watched_layer, cargo shuyi run --watch), or a mod.

pub fn bundle(&self) -> Bundle

Its files, as a bundle of their one layer, under the one laid over them if it has one.

pub fn data(&self) -> Result<BasicData<A, T>, Vec<ContentError>>

Its data from its files, or every problem of every file.

pub fn ctx(&self) -> Result<Ctx<BasicData<A, T>>, String>

Its context, in its keymap file’s first layout; or every problem of its files, one per line.

pub fn game( &self, ctx: Ctx<BasicData<A, T>>, ) -> Result<Game<BasicData<A, T>>, ModuleError>

The game on ctx, at its first screen, with its modules installed; or why one could not be.

pub fn every_screen( &self, ctx: &mut Ctx<BasicData<A, T>>, ) -> Vec<Box<dyn Screen<BasicData<A, T>>>>

Every screen it can show (screens), made on ctx.

pub fn made(&self) -> Made

What made this build, for its records: its id and version as the game’s word, and the fingerprint of its files.

pub fn start(self) -> Start<BasicData<A, T>>

How a backend starts it: a card with its name, then its context on the platform and its first screen. A file that doesn’t load, or a module that can’t be installed, is the load’s error, which the platform shows in place of the game. A session record of it carries its made, and each frame’s hash the state hash of its screens (Screen::state_hash). A crash report carries its crash_record, if it has one.

pub fn harness(&self) -> Harness<BasicData<A, T>>

The game in the test Harness, at its first screen.

Panics

If its files don’t load, or a module can’t be installed: the panic gives every problem.

Trait Implementations

impl<A: ActionSet, T: Debug + 'static> Clone for BasicGame<A, T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: ActionSet, T: Debug + 'static> Copy for BasicGame<A, T>

impl<A: ActionSet, T: Debug + 'static> Debug for BasicGame<A, T>

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

Formats the value using the given formatter.