Struct Game 

pub struct Game<C = StringMap> {
    pub inner: GameInner,
    pub context: C,
    pub tags: GameTags,
    /* private fields */
}

Wraps GameInner with customizable a context used to represent the game-specific state.

The context is exposed to your pages, allowing you to interact with your game state within them.

Example

use ifengine::{GameError, View};
use story::chap1;

let game = ifengine::Game!(chap1::p1);

let view = match game.view() {
   Ok(view: View) => view,
   Err(e: GameError) => {
       panic!("Unhandled err: {e}");
   }
};

ui.render(view, &mut game);

Additional

When processing for rendering, you can use the inner field directly.

Fields

inner: GameInner

context: C

tags: GameTags

Implementations

impl<C: GameContext> Game<C>

pub fn new_with_page(page_name: impl Into<PageId>, page: Page<C>) -> Self

pub fn simulating(&self) -> bool

pub fn view(&mut self) -> Result<View, GameError>

Calls the active page in a loop, until a View is produced.

pub fn id(&self) -> Option<PageId>

impl<C: GameContext> Game<C>

pub fn interact( &mut self, e: Interactable<'_>, pageid: &PageId, ) -> Result<(), GameError>

pub fn interact_all<F>(&self, view: View) -> Vec<Result<Self, GameError>>

impl<C: GameContext> Game<C>

pub fn simulate<F>(&self, visitor: F) -> Simulation

where F: FnMut(&mut SimulationState<C>) -> bool,

The user must ensure that all cycles must be modelled by tunnels. We guarantee to never visit the same tunnel from the same location twice, but the presence of other loops will result in failure to halt. Although certain types of elements generated from proc_macros Panics if current game state is not a view F:

Methods from Deref<Target = GameInner>

pub fn handle_choice(&mut self, key: InternalKey, index: u8)

pub fn handle_action(&mut self, action: Action) -> Result<(), GameError>

pub fn fresh(&self) -> bool

Trait Implementations

impl<C: Clone> Clone for Game<C>

fn clone(&self) -> Game<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Game<C>

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

Formats the value using the given formatter.

impl<C: GameContext> Deref for Game<C>

type Target = GameInner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C: GameContext> DerefMut for Game<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, C> Deserialize<'de> for Game<C>

where C: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Serialize for Game<C>

where C: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.