Struct InitContext 

pub struct InitContext<'a, G: Game> { /* private fields */ }

The work the startup closure run takes may do.

Implementations

impl<'a, G: Game> InitContext<'a, G>

pub fn startup(&mut self) -> &mut Startup<'a>

The startup work that is typed by no vocabulary of the game’s own.

Required if you want to start two games the same way: Startup is one type whatever the game, so code shared between them takes &mut Startup<'_>.

Examples found in repository

examples/sprite-adventure.rs (line 1008)

    fn init(ctx: &mut InitContext<'_, Keep>) -> Result<Self, Error> {
        let startup = ctx.startup();
        let gem_taken = startup.saved(Flag::GemTaken);
        let area = if startup.saved(Flag::InCave) {
            Area::Cave
        } else {
            Area::Overworld
        };
        let position = Vec3::new(
            startup.saved(Position::X) as f32,
            0.0,
            startup.saved(Position::Z) as f32,
        );

        Ok(Self {
            area,
            position,
            previous: position,
            facing: Facing::Toward,
            walk_ticks: 0,
            simulated: Duration::ZERO,
            door_opening: gem_taken,
            swing_ticks: if gem_taken { DOOR_SWING_TICKS } else { 0 },
            gem_taken,
            ghost: 0.0,
            reset_requested: false,
        })
    }

examples/ui-fonts.rs (line 603)

    fn init(ctx: &mut InitContext<'_, Self>) -> Result<Self, Error> {
        let startup = ctx.startup();
        let mut fonts = egui::FontDefinitions::default();
        for (family, names) in [
            (egui::FontFamily::Proportional, &[PROPORTIONAL_FONT][..]),
            (egui::FontFamily::Monospace, &[MONOSPACE_FONT][..]),
            (
                egui::FontFamily::Name(DISPLAY_FAMILY.into()),
                &[DISPLAY_FONT][..],
            ),
            (
                egui::FontFamily::Name(PIXEL_ONLY_FAMILY.into()),
                &[PROPORTIONAL_FONT][..],
            ),
            (
                egui::FontFamily::Name(PROMPT_FAMILY.into()),
                &[PROMPT_FONT, PROPORTIONAL_FONT][..],
            ),
        ] {
            install_family(&mut fonts, startup, family, names)?;
        }
        startup.set_fonts(fonts)?;

        Ok(Self {
            elapsed: Duration::ZERO,
            orbit: Orbit::default(),
            hailed: None,
            dialogue: None,
            sheet_open: false,
        })
    }

pub fn duration(&mut self, sound: G::Sounds) -> Duration

How long sound plays for at its own pitch: the whole clip, before any trim.

Required if you want to time a game against a sound. Every value the vocabulary catalogs is built before this runs, and a streamed one reports what the decode at startup measured.

pub fn durations(&mut self) -> HashMap<G::Sounds, Duration>

How long each value that the vocabulary catalogs plays for, keyed by the value.

Required if you want to time a game against a whole vocabulary. A value the catalog leaves out is absent from the map; read that one through duration.

Examples found in repository

examples/sound-lab.rs (line 413)

    fn init(ctx: &mut InitContext<'_, SoundCheck>) -> Result<Self, Error> {
        let durations = ctx.durations();

        let picked = Sound::Bounce;
        let trim_end = durations.get(&picked).copied().unwrap_or_default();

        Ok(Self {
            master_volume: 1.0,

            picked,
            one_shot_gain: 1.0,
            one_shot_pitch: 1.0,
            one_shot_fade: SoundCue::<Sound>::DEFAULT_FADE.as_secs_f32(),
            trim_start: 0.0,
            trim_end: trim_end.as_secs_f32(),
            one_shot_loop_from: 0.0,

            theme_on: false,
            menu_on: false,
            pulse_on: false,
            cue_fade: 1.0,

            merge_demo: false,
            ring_demo: false,

            player: Vec2::ZERO,
            player_prev: Vec2::ZERO,
            sources: [
                Source::new(-2.5, -2.0, Sound::Bounce, 4.0, false),
                Source::new(2.5, -2.0, Sound::Serve, 4.0, false),
                Source::new(0.0, 2.8, Sound::Theme, 7.0, true),
            ],
            dragging: None,

            durations,
        })
    }

pub fn prepare<M>(&mut self, mesh: M)

where G::Meshes: Holds<M>,

Builds and uploads mesh now, instead of on its first draw; the copy is then held like any drawn mesh’s under Config::with_mesh_memory, and no longer than that.

Takes a mesh of Game::Meshes and no other.

Examples found in repository

examples/isometric-board.rs (line 369)

    fn init(ctx: &mut InitContext<'_, Board>) -> Result<Self, Error> {
        for &(_, _, seed, _) in &ROCKS {
            ctx.prepare(Rock { seed });
        }

        let (sprite_lift, _) = unit_geometry(Turn::Sprite);
        let (block_lift, _) = unit_geometry(Turn::Block);
        Ok(Self {
            sprite: Unit::resting((1, 1), sprite_lift),
            block: Unit::resting((BOARD_TILES - 2, BOARD_TILES - 2), block_lift),
            turn: Turn::Sprite,
            selected: false,
        })
    }