Struct Resources 

pub struct Resources { /* private fields */ }

Implementations

impl Resources

pub fn new() -> Self

pub fn insert<T: 'static>(&mut self, resource: T)

Examples found in repository

examples/shooter_game.rs (line 42)

fn setup(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    // Spawn player
    let player = engine.entities.spawn()
        .at_position(400.0, 500.0)
        .with_colored_square(Color::BLUE, 32.0)
        .build();
    resources.insert(player);
    Ok(())
}

pub fn get<T: 'static>(&self) -> Option<&T>

Examples found in repository

examples/shooter_game.rs (line 47)

fn update(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    let player = *resources.get::<EntityId>().unwrap();
    let input = &engine.input;
    let mut pos = engine.entities.get_transform(player).unwrap().position;
    let speed = 300.0 * engine.time.delta_time();
    if input.is_key_pressed(KeyCode::ArrowLeft) || input.is_key_pressed(KeyCode::KeyA) {
        pos.x -= speed;
    }
    if input.is_key_pressed(KeyCode::ArrowRight) || input.is_key_pressed(KeyCode::KeyD) {
        pos.x += speed;
    }
    if input.is_key_pressed(KeyCode::ArrowUp) || input.is_key_pressed(KeyCode::KeyW) {
        pos.y -= speed;
    }
    if input.is_key_pressed(KeyCode::ArrowDown) || input.is_key_pressed(KeyCode::KeyS) {
        pos.y += speed;
    }
    if let Some(transform) = engine.entities.get_transform_mut(player) {
        transform.position = pos;
    }

    // Shooting
    if input.is_key_just_pressed(KeyCode::Space) {
        engine.entities.spawn()
            .at_position(pos.x, pos.y - 20.0)
            .with_colored_square(Color::new(1.0, 1.0, 0.0, 1.0), 8.0)
            .with_velocity(Velocity::new(0.0, -500.0))
            .build();
    }

    // Move bullets
    // Move bullets (iterate over all entities and update those with velocity)
    let entity_ids: Vec<_> = engine.entities.entities().to_vec();
        // Collect (entity, velocity) pairs first
        let moves: Vec<_> = entity_ids.iter()
            .filter_map(|&entity| engine.entities.get_velocity(entity).map(|vel| (entity, vel.velocity)))
            .collect();
        // Now mutate transforms in a separate loop
        let mut to_remove = Vec::new();
        for (entity, velocity) in moves {
            if let Some(transform) = engine.entities.get_transform_mut(entity) {
                transform.position.x += velocity.x * engine.time.delta_time();
                transform.position.y += velocity.y * engine.time.delta_time();
                if transform.position.y < -10.0 {
                    to_remove.push(entity);
                }
            }
        }
        for entity in to_remove {
            engine.entities.remove_entity(entity);
    }

    // TODO: Spawn/move enemies, collision, scoring

    Ok(())
}

fn ui_system(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    // Split borrows for UiContext and GameState
    // Clone needed GameState fields first
    let (volume, player_name, score) = {
        let state_ref = resources.get::<GameState>().unwrap();
        (state_ref.volume, state_ref.player_name.clone(), state_ref.score)
    };
    let ui = resources.get_mut::<UiContext>().unwrap();
    ui.text("Volume", Position::new(20.0, 20.0), Color::WHITE);
    ui.slider(
        Rect::new(100.0, 20.0, 180.0, 24.0),
        0.0,
        1.0,
        volume,
        0.01,
        SliderStyle::default(),
    );
    ui.text("Name", Position::new(20.0, 60.0), Color::WHITE);
    ui.text_input(
        Rect::new(100.0, 60.0, 180.0, 32.0),
        &player_name,
        TextInputStyle::default(),
    );
    ui.text(format!("Score: {}", score), Position::new(20.0, 110.0), Color::WHITE);
    Ok(())
}

pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T>

Examples found in repository

examples/shooter_game.rs (line 110)

fn ui_system(engine: &mut Engine, resources: &mut Resources) -> EngineResult<()> {
    // Split borrows for UiContext and GameState
    // Clone needed GameState fields first
    let (volume, player_name, score) = {
        let state_ref = resources.get::<GameState>().unwrap();
        (state_ref.volume, state_ref.player_name.clone(), state_ref.score)
    };
    let ui = resources.get_mut::<UiContext>().unwrap();
    ui.text("Volume", Position::new(20.0, 20.0), Color::WHITE);
    ui.slider(
        Rect::new(100.0, 20.0, 180.0, 24.0),
        0.0,
        1.0,
        volume,
        0.01,
        SliderStyle::default(),
    );
    ui.text("Name", Position::new(20.0, 60.0), Color::WHITE);
    ui.text_input(
        Rect::new(100.0, 60.0, 180.0, 32.0),
        &player_name,
        TextInputStyle::default(),
    );
    ui.text(format!("Score: {}", score), Position::new(20.0, 110.0), Color::WHITE);
    Ok(())
}

pub fn remove<T: 'static>(&mut self) -> Option<T>

pub fn contains<T: 'static>(&self) -> bool

Trait Implementations

impl Debug for Resources

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

Formats the value using the given formatter.

impl Default for Resources

fn default() -> Self

Returns the “default value” for a type.