The document discusses the use of the Entitas framework for entity system architecture in Unity, addressing pain points such as testability, code sharing, and querying. It outlines various components, systems, and optimization techniques, including reactive systems and the use of code generation for efficiency. Additionally, it highlights the framework's advantages, such as determinism and improved simulation speed.

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