flecs 0.1.5

Rust bindings for the Flecs Entity Component System
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

use flecs::*;

// TODO
// Update iteration APIs (each, etc) to support mutable component refs

#[derive(Copy, Clone, Default, Debug, PartialEq)]
struct Attack {
	value: f32,
}

#[derive(Copy, Clone, Default, Debug, PartialEq)]
struct Defense {
	value: f32,
}

#[derive(Copy, Clone, Default, Debug, PartialEq)]
struct FreightCapacity {
	value: f32,
}

#[derive(Copy, Clone, Default, Debug, PartialEq)]
struct ImpulseSpeed {
	value: f32,
}

#[derive(Copy, Clone, Default, Debug, PartialEq)]
struct HasFTL {}

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

fn main() {
	println!("Entity Prefabs starting...");

	let mut world = World::new();

	// We have to manually register all components
	world.component::<Attack>();
	world.component::<Defense>();
	world.component::<FreightCapacity>();
	world.component::<ImpulseSpeed>();
	world.component::<HasFTL>();
	world.component::<Position>();

	// Create a prefab hierarchy. Prefabs are entities that by default are
	// ignored by queries.

	let spaceship = world
		.prefab("Spaceship")
		// Add components to prefab entity as usual
		.set(ImpulseSpeed { value: 50.0 })
		.set(Defense { value: 50.0 })
		// By default components in an inheritance hierarchy are shared between
		// entities. The override function ensures that instances have a private
		// copy of the component.
		.override_component::<Position>();

	let freighter = world
		.prefab("Freighter")
		// Short for .add(flecs::IsA, spaceship). This ensures the entity
		// inherits all components from spaceship.
		.is_a(spaceship)
		.add::<HasFTL>()
		.set(FreightCapacity { value: 100.0 })
		.set(Defense { value: 100.0 });

	let mammoth_freighter = world
		.prefab("MammothFreighter")
		.is_a(freighter)
		.set(FreightCapacity { value: 500.0 })
		.set(Defense { value: 300.0 });

	world
		.prefab("Frigate")
		.is_a(spaceship)
		.add::<HasFTL>()
		.set(Attack { value: 100.0 })
		.set(Defense { value: 75.0 })
		.set(ImpulseSpeed { value: 125.0 });

	// Create a regular entity from a prefab.
	// The instance will have a private copy of the Position component, because
	// of the override in the spaceship entity. All other components are shared.
	let inst = world.entity().named("my_mammoth_freighter").is_a(mammoth_freighter);

	// As of Flecs 3.2.1 the 'uninitialized' Position component started coming back with weird values
	// so let's initialize it properly. Perhaps we need to wire up default constructor to Flecs lifecycle soon!
	inst.set(Position { x: 10.0, y: 200.0 });

	// Inspect the type of the entity. This outputs:
	//    Position,(Identifier,Name),(IsA,MammothFreighter)
	println!("Instance type: [{}]", inst.type_info().to_str());

	// Even though the instance doesn't have a private copy of ImpulseSpeed, we
	// can still get it using the regular API (outputs 50)
	let speed = inst.get::<ImpulseSpeed>();
	println!("Impulse speed: {}", speed.value);

	// Prefab components can be iterated just like regular components:
	world.filter::<(ImpulseSpeed, Position)>().each(|e: Entity, (_is, p)| {
		// TODO - need to support mutable component access
		//p.x += is.value;
		println!("{}: {{ {}, {} }}", e.name(), p.x, p.y);
	});
}

#[cfg(test)]
mod tests {
	#[test]
	fn flecs_entity_prefabs() {
		super::main();
	}
}