Struct Game

pub struct Game<S: Resource + Send + Sync + 'static> { /* private fields */ }

A Game represents the entire game and its data. By default the game will spawn an empty window, and exit upon Esc or closing of the window. Under the hood, Rusty Engine syncs the game data to Bevy to power most of the underlying functionality.

Game forwards method calls to Engine when it can, so you should be able to use all of the methods from Engine on Game during your game setup in your main() function.

Implementations

impl<S: Resource + Send + Sync + 'static> Game<S>

pub fn new() -> Self

Create an new, empty Game with an empty Engine

pub fn window_settings(&mut self, window: Window) -> &mut Self

Use this to set properties of the native OS window before running the game. See the window example for more information.

pub fn run(&mut self, initial_game_state: S)

Start the game.

pub fn add_logic(&mut self, logic_function: fn(&mut Engine, &mut S))

logic_function is a function or closure that takes two parameters and returns nothing:

• engine: &mut Engine
• game_state, which is a mutable reference (&mut) to the game state struct you defined, or &mut () if you didn’t define one.

Methods from Deref<Target = Engine>

pub fn add_sprite<T: Into<String>, P: Into<PathBuf>>( &mut self, label: T, file_or_preset: P, ) -> &mut Sprite

Create and add a Sprite to the game. Use the &mut Sprite that is returned to adjust the translation, rotation, etc. Use a unique label for each sprite. Attempting to add two sprites with the same label will cause a crash.

pub fn add_text<T, S>(&mut self, label: T, text: S) -> &mut Text

where T: Into<String>, S: Into<String>,

Create and add a Text to the game. Use the &mut Text that is returned to adjust the translation, rotation, etc. Use a unique label for each text. Attempting to add two texts with the same label will cause a crash.

Trait Implementations

impl<S: Resource + Send + Sync + 'static> Default for Game<S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Resource + Send + Sync + 'static> Deref for Game<S>

type Target = Engine

The resulting type after dereferencing.

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

Dereferences the value.

impl<S: Resource + Send + Sync + 'static> DerefMut for Game<S>

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

Mutably dereferences the value.