Entity System Architecture with Unity - Unite Europe 2015 Entitas - open source Entity Component System for C# and Unity: https://github.com/sschmid/Entitas-CSharp

1. Entity system
architecture
with Unity

2. Maxim Zaks
@icex33 | github.com/mzaks
Simon Schmid
@s_schmid | github.com/sschmid

6. Unity pain points
• Testability
• Code sharing
• Co-dependent logic
• Querying
• Deleting code

7. Testability

8. Code sharing

9. Co-dependent logic

10. Co-dependent logic

11. Co-dependent logic

12. Querying

13. Deleting code

15. Entitas
Match One Demo

16. PositionComponent
using Entitas;
public class PositionComponent : IComponent
{
public int x;
public int y;
}

17. GameBoardElementComponent
using Entitas;
public class GameBoardElementComponent : IComponent {}

18. Entity
• Add
• Replace
• Remove

19. Create Blocker Entity
public static Entity CreateBlocker(this Pool pool, int x, int y)
{
return pool.CreateEntity()
.IsGameBoardElement(true)
.AddPosition(x, y)
.AddResource(Res.Blocker);
}

20. Pool
• Create Entity
• Destroy Entity
• Get all Entities
• Get Group

21. Group
Performance optimization for querying
Matcher is a filter description

22. Get Group
_pool.GetGroup(
Matcher.AllOf(
Matcher.GameBoardElement,
Matcher.Position
)
);

23. +------------------+
| Pool |
|------------------|
| e e | +-----------+
| e e---|----> | Entity |
| e e | |-----------|
| e e e | | Component |
| e e | | | +-----------+
| e e | | Component-|----> | Component |
| e e e | | | |-----------|
| e e e | | Component | | Data |
+------------------+ +-----------+ +-----------+
|
|
| +-------------+
| | e | Groups
| | e e |
+---> | +------------+
| e | | |
| e | e | e |
+--------|----+ e |
| e |
| e e |
+------------+

24. Behaviour

25. System
• Start / Execute
• No State

26. MoveSystem
public void Execute() {
var movables = _pool.GetGroup(
Matcher.AllOf(
Matcher.Move,
Matcher.Position
));
foreach (var e in movables.GetEntities()) {
var move = e.move;
var pos = e.position;
e.ReplacePosition(pos.x, pos.y + move.speed, pos.z);
}
}

27. Chain of Responsibility
+------------+ +------------+ +------------+ +------------+
| | | | | | | |
| System | +---> | System | +---> | System | +---> | System |
| | | | | | | |
+------------+ +------------+ +------------+ +------------+

28. return new Systems()
.Add(pool.CreateSystem <GameBoardSystem> ())
.Add(pool.CreateSystem <CreateGameBoardCacheSystem> ())
.Add(pool.CreateSystem <FallSystem> ())
.Add(pool.CreateSystem <FillSystem> ())
.Add(pool.CreateSystem <ProcessInputSystem> ())
.Add(pool.CreateSystem <RemoveViewSystem> ())
.Add(pool.CreateSystem <AddViewSystem> ())
.Add(pool.CreateSystem <RenderPositionSystem> ())
.Add(pool.CreateSystem <DestroySystem> ())
.Add(pool.CreateSystem <ScoreSystem> ());

29. Reacting to changes in a Group
• On Entity added
• On Entity removed

30. ScoreLabelController
void Start() {
_pool.GetGroup(Matcher.Score).OnEntityAdded +=
(group, entity) => updateScore(entity.score.value);
updateScore(_pool.score.value);
}
void updateScore(int score) {
_label.text = "Score " + score;
}

31. Reactive System
• Executed only when entities in group have changed

32. Render Position System
public class RenderPositionSystem : IReactiveSystem {
public IMatcher GetTriggeringMatcher() {
return Matcher.AllOf(Matcher.View, Matcher.Position);
}
public GroupEventType GetEventType() {
return GroupEventType.OnEntityAdded;
}
public void Execute(Entity[] entities) {
foreach (var e in entities) {
var pos = e.position;
e.view.gameObject.transform.position = new Vector3(pos.x, pos.y);
}
}
}

33. Optimizations

34. Components
mutable vs immutable

37. Entity
Store components in
Dictionary vs Array

38. Comparison
Dictionary
e.AddComponent(new PositionComponent());
var component = e.GetComponent<PositionComponent>();
Array
e.AddComponent(new PositionComponent(), 5);
var component = (PositionComponent)e.GetComponent(5);

41. Code Generator

42. Before Code Generation
PositionComponent component;
if (e.HasComponent(ComponentIds.Position)) {
e.WillRemoveComponent(ComponentIds.Position);
component = (PositionComponent)e.GetComponent(ComponentIds.Position);
} else {
component = new PositionComponent();
}
component.x = 10;
component.y = 10;
e.ReplaceComponent(ComponentIds.Position, component);

43. After Code Generation
e.ReplacePosition(10, 10);

44. Code Generator Demo

45. How does it work?

46. Visual Debugging
Demo

47. Entitas is
open source
github.com/sschmid/Entitas-
CSharp

48. Recap

49. Unity pain points
• Testability
• Code sharing
• Co-dependent logic
• Querying
• Deleting code

50. Advantages
• Straightforward to achieve Determinism and therefore
Replay
• Simulation Speed (2x, 4x)
• Headless Simulation, just remove systems which rely on
GameObjects (render systems)
• Save Game (Serialization / Deserialization) send data to
backend on change
• For us it replaced all OO Design Patterns

51. Q&Atinyurl.com/entitas