Struct Turns 

pub struct Turns { /* private fields */ }

Which entities update this tick, from Ctx::turns.

Implementations

impl Turns

pub fn includes(self, entity: Entity) -> bool

true if entity’s turn is this tick.

if ctx.turns(8).includes(e) { /* expensive update */ }

Examples found in repository

examples/ants.rs (line 233)

fn forage(ctx: &mut Ctx) {
    let turn = ctx.turns(2);
    let mut food_grid = SpatialGrid::new(8.0);
    food_grid.rebuild_from(
        ctx.world
            .query::<(Entity, &Transform2D, &Food)>()
            .iter()
            .map(|(e, t, _)| (e, t.position)),
    );
    let grid = &food_grid;
    ctx.world
        .query::<(Entity, &Transform2D, &mut Ant)>()
        .par_for_each(|(e, t, ant)| {
            ant.event = Event::None;
            if ant.energy <= 0.0 {
                ant.event = Event::Starved;
                return;
            }
            if !turn.includes(e) {
                return;
            }
            let at_home = t.position.distance(ant.home_at) < NEST_RADIUS;
            if ant.carrying {
                if at_home {
                    ant.carrying = false;
                    ant.since = 0.0;
                    ant.energy = LIFESPAN;
                    ant.heading += std::f32::consts::PI;
                    ant.event = Event::Delivered;
                }
            } else if at_home {
                ant.since = 0.0;
            } else if let Some(f) = grid.nearest(t.position, 4.0, |_| true) {
                ant.carrying = true;
                ant.since = 0.0;
                ant.heading += std::f32::consts::PI;
                ant.event = Event::PickedUp(f.entity);
            }
        });

    let (mut picked, mut delivered) = (Vec::new(), Vec::new());
    let cmds = &mut ctx.commands;
    ctx.world
        .query::<(Entity, &Ant)>()
        .for_each(|(e, ant)| match ant.event {
            Event::None => {}
            Event::Starved => cmds.despawn(e),
            Event::PickedUp(food) => picked.push(food),
            Event::Delivered => delivered.push(ant.home),
        });
    for f in picked {
        if let Some(food) = ctx.world.get_mut::<Food>(f) {
            food.amount = food.amount.saturating_sub(1);
            if food.amount == 0 {
                ctx.world.despawn(f);
            }
        }
    }
    for nest in delivered {
        if let Some(n) = ctx.world.get_mut::<Nest>(nest) {
            n.stored += 1;
            n.delivered += 1;
        }
    }
}

examples/battle.rs (line 268)

fn fight() -> impl FnMut(&mut Ctx) {
    // Per team: a fine grid for friends (only the closest few matter) and a
    // coarse one for enemies (seen from afar). Marching armies far from the
    // enemy then cost almost nothing to search, however packed they are.
    let mut near = [
        SpatialGrid::new(PERSONAL_SPACE * 2.0),
        SpatialGrid::new(PERSONAL_SPACE * 2.0),
    ];
    let mut far = [SpatialGrid::new(SIGHT), SpatialGrid::new(SIGHT)];
    let mut positions: Vec<(Entity, Vec2, Team)> = Vec::new();
    move |ctx: &mut Ctx| {
        let (dt, random, look) = (ctx.dt(), ctx.random(), ctx.turns(4));
        let crowding = ctx.sim_tick().is_multiple_of(2);
        ctx.world
            .query::<(Entity, &Transform2D, &Unit)>()
            .par_collect_into(&mut positions, |(e, t, u)| (e, t.position, u.team));
        // The four grids are independent: build them at the same time.
        let [near_red, near_blue] = &mut near;
        let [far_red, far_blue] = &mut far;
        let all = &positions;
        let of = |team: Team| all.iter().filter(move |p| p.2 == team).map(|&(e, at, _)| (e, at));
        rayon::scope(|s| {
            if crowding {
                s.spawn(|_| near_red.rebuild_from(of(Team::Red)));
                s.spawn(|_| near_blue.rebuild_from(of(Team::Blue)));
            }
            s.spawn(|_| far_red.rebuild_from(of(Team::Red)));
            s.spawn(|_| far_blue.rebuild_from(of(Team::Blue)));
        });
        let over = ctx.world.resource::<Score>().winner.is_some();
        let battle = ctx.world.remove_resource::<Battle>().expect("battle");
        let (near, far, b) = (&near, &far, &battle);
        ctx.world
            .query::<(Entity, &mut Transform2D, &mut Unit)>()
            .par_for_each(|(e, t, unit)| {
                let mut rng = random.of(e);
                let me = t.position;
                unit.hit = None;
                unit.cooldown -= dt;
                if crowding {
                    let mut push = Vec2::ZERO;
                    near[unit.team.index()].for_each_in_radius(me, PERSONAL_SPACE, |other| {
                        if other.entity != e {
                            let away = me - other.position;
                            push += away / (away.length_squared() + 0.01);
                        }
                    });
                    unit.push = push.clamp_length_max(1.0);
                }
                let mut nearest = None;
                if unit.engaged || look.includes(e) {
                    let enemies = &far[unit.team.enemy().index()];
                    nearest = enemies
                        .nearest(me, REACH, |_| true)
                        .or_else(|| enemies.nearest(me, SIGHT, |_| true))
                        .map(|g| (g.position.distance_squared(me), g.entity, g.position));
                    unit.engaged = nearest.is_some();
                }
                let enemy_base = b.bases[unit.team.enemy().index()];
                let mut want = match nearest {
                    Some((d2, target, _)) if d2 < REACH * REACH => {
                        if unit.cooldown <= 0.0 {
                            unit.cooldown = COOLDOWN * rng.range(0.8, 1.2);
                            unit.hit = Some(Hit::Unit(target));
                        }
                        Vec2::ZERO
                    }
                    Some((_, _, at)) => (at - me).normalize_or_zero() * SPEED,
                    None if me.distance(enemy_base) < BASE_RADIUS + REACH => {
                        if unit.cooldown <= 0.0 && !over {
                            unit.cooldown = COOLDOWN;
                            unit.hit = Some(Hit::Base);
                        }
                        Vec2::ZERO
                    }
                    None => b.fields[unit.team.index()].direction_at(me) * SPEED,
                };
                let slow = b.nav.cell_at(me).and_then(|c| b.nav.cost(c.x, c.y)).unwrap_or(1).max(1) as f32;
                want = want / slow + unit.push * SPEED;
                unit.vel = unit.vel.lerp(want, 0.2) + rng.unit_vec2() * 2.0;
                // Slide along walls instead of walking into them.
                let next = me + unit.vel * dt;
                if b.nav.walkable(next) {
                    t.position = next;
                } else if b.nav.walkable(vec2(next.x, me.y)) {
                    t.position.x = next.x;
                } else if b.nav.walkable(vec2(me.x, next.y)) {
                    t.position.y = next.y;
                }
            });
        ctx.world.insert_resource(battle);
    }
}

pub fn dt(self) -> f32

Time since an entity’s previous turn: every times ctx.dt().

let turn = ctx.turns(4);
assert_eq!(turn.dt(), ctx.dt() * 4.0);

Trait Implementations

impl Clone for Turns

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Turns

impl Debug for Turns

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

Formats the value using the given formatter.

impl PartialEq for Turns

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Turns