A performant, zero-dependency ECS library with a nice API written in Rust.

Usage

```toml

Cargo.toml

[dependecies] kiwi-ecs = "1.1" ```

rust // lib.rs use kiwi_ecs::*;

The world

To start, create a new World. This is the starting point of the ecs. The program can have multiple independent worlds.

rust pub fn main() { let mut world = World::new(); }

Components

Components are defined as follows:

```rust

[derive(Component)]

struct Position { x: u32, y: u32 } ```

Entities

To spawn a new entity with the given ids:

rust // spawn_entity macro accepts the world as the first parameter, and the // components to add to the entity as the other parameters let id = spawn_entity!(world, Pos { x: 0, y: 0 });

Systems

There are two ways to define systems.

The first is using the `system` macro:

```rust // immutable system

[system(pos: Position)]

fn print_positions(world: &World) { println!("{:?}", pos); }

// mutable system

[system(pos: Pos, vel: Vel)]

fn move_entities(world: &mut World) { pos.x += vel.x; pos.y += vel.y }

// query entity ids as well

[system(id: EntityId, pos: Position)]

/// prints all entities ids having the position component fn printentityids(world: &World) { println!("{id}"); }

pub fn main() { let mut world = World::new();

//--snip

// Call the systems printpositions(&world); moveentities(&mut world); printentityids(&world); } ```

To create a mutable system, the function should contain world: &mut World as its first argument, for an immutable one, add world: &World.

The function can contain any number of arguments you can pass to it when calling.

The function can return any type of Result<(), Any>. If this function has the given result return type, Ok(()) will be returned at the end of the system.

The second is using the `query` and `query_mut` macros:

```rust pub fn main() { let mut world = World::new();