Unity incorporates the component based architecture in a seamless manner. However for some games a more data driven approach (entity system architecture) fits better. We had very good experience using entity system architecture for simulation and even match three games. Therefore when we switched our development to Unity, we created a small library and a couple of Unity editor extensions to make Unity work seamlessly with entity system architecture. We called it Entitas-CSharp. The code is open source and available on github. In this talk we would like to show why entity system architecture fits us better and how you can use Entitas-CSharp in your own Unity project.

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