Sparsey

Sparsey is a sparse set-based Entity Component System with lots of features and beautiful syntax \~( ˘▾˘\~)

Example

```rust use sparsey::prelude::*;

struct Position(f32); struct Velocity(f32); struct Frozen;

fn updatevelocities(mut velocities: CompMut, frozen: Comp) { (&mut velocities).include(&frozen).foreach(|velocity| { velocity.0 = 0.0; }); }

fn updatepositions(mut positions: CompMut, velocities: Comp) { (&mut positions, &velocities).foreach(|(position, velocity)| { position.0 += velocity.0; }); }

fn main() { let mut schedule = Schedule::builder() .addsystem(updatevelocities) .addsystem(updatepositions) .build();

let mut world = World::default();
schedule.set_up(&mut world);

world.create((Position(0.0), Velocity(1.0)));
world.create((Position(0.0), Velocity(2.0)));
world.create((Position(0.0), Velocity(3.0), Frozen));

let mut resources = Resources::default();

for _ in 0..5 {
    schedule.run(&mut world, &mut resources);
}

} ```

Features

Easy to Use Systems

Systems are plain functions that borrow data from World and Resources.

```rust fn updatepositions(mut positions: CompMut, velocities: Comp) { (&mut positions, &velocities).foreach(|(position, velocity)| { position.0 += velocity.0; }); }

fn updatehps(mut hps: CompMut, heals: Comp, healmultipler: Res) { (&mut hps, &heals).foreach(|(hp, heal)| { hp.0 += heal.0 * healmultiplier.0; }); } ```

Systems will be scheduled to run in parallel if their paramters don't conflict.

rust let schedule = Schedule::builder() .add_system(update_positions) .add_system(update_hps) .build();

Expressive Queries

Get, include and exclude components using Sparsey's query API.

```rust fn queries(a: Comp, b: Comp, c: Comp, d: Comp, e: Comp) { // Iter components A and B from entities with A and B. for (a, b) in (&a, &b).iter() {}

// Iter components A from entities with A and B.
for a in (&a).include(&b).iter() {}

// Iter components A from entities with A and without B.
for a in (&a).exclude(&b).iter() {}

// Iter components A from entities with A and B, without C.
for a in (&a).include(&b).exclude(&c).iter() {}

// These return Some(_) if the storages are grouped and None otherwise.
let _: Option<&[Entity]> = (&a, &b).as_entity_slice();
let _: Option<(&[A], &[B])> = (&a, &b).as_component_slices();
let _: Option<(&[Entity], (&[A], &[B]))> = (&a, &b).as_entity_and_component_slices();