yaks

![Latest Version] ![Documentation] ![Dependencies] ![License]

yaks aims to be a minimalistic, yet featureful and performant entity-component-system (ECS) framework. It is built upon [hecs] and [resources].

The goals are, in no particular order: - safety - simplicity - performance - extensibility - tight engineering - minimal dependencies - effortless concurrency

This is a very early version. It's API is subject to radical change, it does not do any multithreading, or system ordering beyond insertion order.

Example

```rust use yaks::{System, Executor, World, Entity};

struct Position(f32); struct Velocity(f32); struct Acceleration(f32); struct HighestVelocity(f32);

fn main() { let mut world = World::new(); world.add_resource(HighestVelocity(0.0)); world.spawn((Position(0.0), Velocity(3.0))); world.spawn((Position(0.0), Velocity(1.0), Acceleration(1.0)));

let motion = System::builder()
    .query::<(&mut Position, &Velocity)>()
    .query::<(&mut Velocity, &Acceleration)>()
    .build(|world, _, (q_1, q_2)| {
        for (_, (mut pos, vel)) in q_1.query(world).iter() {
            pos.0 += vel.0;
        }
        for (_, (mut vel, acc)) in q_2.query(world).iter() {
            vel.0 += acc.0;
        }
    });

let find_highest = System::builder()
    .resources::<&mut HighestVelocity>()
    .query::<&Velocity>()
    .build(|world, mut highest, query| {
        for (_, vel) in query.query(world).iter() {
            if vel.0 > highest.0 {
                highest.0 = vel.0;
            }
        }
    });

let mut executor = Executor::<()>::new().with(motion).with(find_highest);
assert_eq!(world.fetch::<&HighestVelocity>().0, 0.0);
executor.run(&mut world);
assert_eq!(world.fetch::<&HighestVelocity>().0, 3.0);
executor.run(&mut world);
assert_eq!(world.fetch::<&HighestVelocity>().0, 3.0);
executor.run(&mut world);
assert_eq!(world.fetch::<&HighestVelocity>().0, 4.0);

} ```