Sparsey

Sparsey is a sparse set-based Entity Component System with lots of features and nice syntax \~( ˘▾˘\~)
Check out the Sparsey Cheat Sheet and examples to get started!

Example

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

// Components are Send + Sync + 'static types. struct Position(f32); struct Velocity(f32); struct Immovable;

// Sets the Velocity of Immovable entities to zero. fn update_velocity(mut vel: CompMut, imv: Comp) { for mut vel in (&mut vel).include(&imv).iter() { vel.0 = 0.0; } }

// Adds the Velocity of each entity to its Position. fn update_position(mut pos: CompMut, vel: Comp) { for (mut pos, vel) in (&mut pos, &vel).iter() { pos.0 += vel.0; } }

fn main() { // Create a World to store our game data. let mut world = World::default();

// Create a Dispatcher to run our systems.
let mut dispatcher = Dispatcher::builder()
    .add_system(update_velocity.system())
    .add_system(update_position.system())
    .build();

// Register all component types we want to use.
dispatcher.register_storages(&mut world);

// Create some entities.
world.create_entity((Position(0.0), Velocity(1.0)));
world.create_entity((Position(0.0), Velocity(2.0)));
world.create_entity((Position(0.0), Velocity(3.0), Immovable));

// Run the systems 3 times.
for _ in 0..3 {
    dispatcher.run_seq(&mut world).unwrap();
    world.increment_tick();
}

} ```

Features

Easy to Write Systems

Systems are plain functions that may return a SystemResult to signal errors.

```rust fn printaliveentities(hp: Comp) { for (entity, hp) in (&hp).iter().entities() { if hp.0 > 0 { println!("{:?} - {:?}", entity, hp); } } }

fn saveentities(savefile: ResMut, position: Comp) -> SystemResult { for (entity, position) in (&position).iter().entities() { savefile.saveentitywithposition(entity, position)?; }

Ok(())

} ```

Expressive Queries

Get, include, exclude and filter 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() {}

// Iter components A from entities with A and B, without C and with D xor E.
for a in (&a).include(&b).exclude(&c).filter(contains(&d) ^ contains(&e)).iter() {}

// Iter A, B component sets where A or B was changed. 
for (a, b) in changed((&a, &b)).iter() {}

// Iter A, B, C component sets where A or B was changed and C was changed. 
for ((a, b), c) in (changed((&a, &b)), changed(&c)).iter() {}

// These would panic if the storages weren't grouped.
let _: &[Entity] = (&a, &b).entities().unwrap();
let _: (&[A], &[B]) = (&a, &b).components().unwrap();
let _: (&[Entity], (&[A], &[B])) = (&a, &b).entities_components().unwrap();