checs 0.2.0

An Entity-Component-System library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# checs

An Entity-Component-System library.

## Example

This is a very basic example of how to use `checs`.

You can find this example at `examples/basic.rs`. Run it with:

```sh
cargo run --example basic
```

---

Define some components and a `World` to store them in.

> Note: Components are just plain old Rust types.

```rust
struct Position { x: u32, y: u32, }
struct Health(i32);
struct Visible;

checs::impl_storage!(
    struct Storage {
        positions: Position,
        healths: Health,
        visibles: Visible,
    }
);

let mut world = world::World::<Storage>::new();
```

Create entities with initial components.

```rust
let player = world.spawn();
world.put(player, Health(80));
world.put(player, Position { x: 0, y: 0 });
world.put(player, Visible);

let obstacle = world.spawn();
world.put(obstacle, Position { x: 1, y: 1 });
world.put(obstacle, Visible);

let trap = world.spawn();
world.put(trap, Position { x: 2, y: 1 });

let enemy = world.spawn();
world.put(enemy, Health(100));
world.put(enemy, Position { x: 1, y: 4 });
world.put(enemy, Visible);
```

Find the entities that have some components.

```rust
use checs::iter::LendingIterator;
use checs::query::Join;

let ps = &world.storage.positions;
let vs = &world.storage.visibles;

let mut query = (ps, vs).join();

while let Some((e, p, h, v)) = query.next() {
    h.0 = h.0 - 17;
    println!("{e:?} is {v:?} at ({}, {})", p.x, p.y);
}

// Entity(0) is Visible at (0, 0)
// Entity(1) is Visible at (1, 1)
// Entity(3) is Visible at (1, 4)
```