freecs 2.0.1

A high-performance, archetype-based Entity Component System (ECS) written in Rust.
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use freecs::{Entity, Schedule, ecs};

#[derive(Default, Debug, Clone)]
pub struct Position {
    pub x: f32,
    pub y: f32,
}

#[derive(Default, Debug, Clone)]
pub struct Velocity {
    pub x: f32,
    pub y: f32,
}

#[derive(Default, Debug, Clone)]
pub struct Sprite {
    pub id: u32,
}

#[derive(Default, Debug, Clone)]
pub struct Color {
    pub r: f32,
    pub g: f32,
    pub b: f32,
}

#[derive(Debug, Clone)]
pub struct CollisionEvent {
    pub entity_a: Entity,
    pub entity_b: Entity,
}

ecs! {
    GameEcs {
        CoreWorld {
            position: Position => POSITION,
            velocity: Velocity => VELOCITY,
        }
        RenderWorld {
            sprite: Sprite => SPRITE,
            color: Color => COLOR,
        }
    }
    Tags { player => PLAYER }
    Events { collision: CollisionEvent }
    GameResources { delta_time: f32 }
}

fn physics_system(ecs: &mut GameEcs) {
    let dt = ecs.resources.delta_time;
    ecs.core_world
        .for_each_mut(POSITION | VELOCITY, 0, |_entity, table, idx| {
            table.position[idx].x += table.velocity[idx].x * dt;
            table.position[idx].y += table.velocity[idx].y * dt;
        });
}

fn render_system(ecs: &GameEcs) {
    let GameEcs {
        core_world,
        render_world,
        player,
        ..
    } = ecs;

    core_world.for_each(POSITION, 0, |entity, table, idx| {
        let tag = if player.contains(&entity) {
            " [PLAYER]"
        } else {
            ""
        };
        if let Some(sprite) = render_world.get_sprite(entity) {
            println!(
                "  Entity {:?}: pos=({:.1}, {:.1}), sprite={}{tag}",
                entity, table.position[idx].x, table.position[idx].y, sprite.id,
            );
        } else {
            println!(
                "  Entity {:?}: pos=({:.1}, {:.1}), no sprite{tag}",
                entity, table.position[idx].x, table.position[idx].y,
            );
        }
    });
}

fn main() {
    let mut ecs = GameEcs::default();
    ecs.resources.delta_time = 1.0 / 60.0;

    let entities = EntityBuilder::new()
        .with_position(Position { x: 0.0, y: 0.0 })
        .with_velocity(Velocity { x: 60.0, y: 30.0 })
        .with_sprite(Sprite { id: 1 })
        .with_color(Color {
            r: 1.0,
            g: 0.0,
            b: 0.0,
        })
        .spawn(&mut ecs, 1);
    ecs.add_player(entities[0]);

    let bg_entity = ecs.spawn();
    ecs.core_world
        .set_position(bg_entity, Position { x: 100.0, y: 50.0 });

    let mut schedule: Schedule<GameEcs> = Schedule::new();
    schedule.push("physics", physics_system);
    schedule.push_readonly("render", render_system);

    println!("Multi-world ECS: {} worlds, {} entities", 2, 2);
    println!(
        "Mask independence: POSITION={}, SPRITE={} (both bit 0)",
        POSITION, SPRITE
    );
    println!();

    for frame in 0..3 {
        println!("--- Frame {frame} ---");
        schedule.run(&mut ecs);
        ecs.step();
        println!();
    }
}