Sparsey

Sparsey is a sparse set-based Entity Component System (ECS).

Design Goals

• Be flexible: Any Send + Sync + 'static type can be used as a component.
• Be concise: The most commonly used functionalities should require the least amount of typing.
• Make use of sparse sets: Provide features exclusive to sparse set-based ECS.

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 mut schedule = Schedule::builder() .addsystem(updatepositions) .addsystem(updatehps) .build();

schedule.run(&mut world, &mut resources); ```

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() {}

if let Some((a_slice, b_slice)) = (&a, &b).into_components() {
    // ...
}

if let Some((entities, (a_slice, b_slice))) = (&a, &b).into_entities_and_components() {
    // ...
}