Building a turn-based game prototype using ECS - Unite Copenhagen 2019

Building a Turn-Based
Game Prototype …
the ECS Way

Setting the stage!
3
— Not the next Civilization game
— Code focussed
— No ECS experience is fine
— Agenda
– My background
– Concepts of this talk
– Non-turn-based prototype with ECS
– Turn it turn-based

Turn Based Game Loop
6
— Continuous update
— Poll all events
— Change game world
Game world continuously changes
every frame
while (true)
{
processInput();
update(elapsed);
render();
}
System A
System Y
System Z
…
…

7
— Frame != Turn
— We have continuous systems: update every frame
— We have turn based systems: update every turn

8
— Continuous update
— Poll all events
— Wait for player action
— Update other actors only when
player makes a move
Game world only changes in
response to player action
while (true)
{
action = processInput();
if(action != null)
{
update(elapsed);
}
render();
}
Player Action
TB System
TB System
…

— Composition vs
Inheritance
— Atomic parts
— Filtering
— Systematic design
Entity
Component
System
Unity ECS
9
DATA
DATA

Unity ECS
10
— Quite useable today
— High degree of control over gameworld (Savegames!)
— Performance and data layout
— Path into future awesomeness of Unity

Example Project Setup
12
— Unity 2019.2.6f1
— 3D Template
— Packages:
– Entities 0.1.1 [preview]
– Hybrid Renderer 0.1.1 [preview]
— Content from different assets:
– PolyWorks FullPack, GalaxyBox1, SurrounDead - Free Sample, Bitgem Texture pack
— https://github.com/floAr/UniteCPH_TurnBasedPrototypeECS

“Flying Gardener”
13
— Grid based world
— Two kind of actors:
– Player(s)
– NPCs (Evil Snails)
— 2DOF Movement

Creating actors
14
— Actors move on grid in
game world
— Current- and target
position
[Serializable]
public struct ActorComponent : IComponentData
{
public float3 position;
public float3 target_positon;
}
public void Convert(Entity entity,
EntityManager dstManager,
GameObjectConversionSystem conversionSystem)
{
float3 grid_pos = new float3(
math.floor(transform.position.x),
0,
math.floor(transform.position.z)
);
dstManager.AddComponentData(entity,
new ActorComponent()
{
position = grid_pos,
target_positon = grid_pos
});
}

Creating actors
15
game world
position
[Serializable]
{
}
{
0,
);
{
});
}

Creating actors
16
game world
position
— Convert from
MonoBehaviour to
Component
[Serializable]
{
}
{
0,
);
{
});
}

Creating actors
17
game world
position
— Convert from
MonoBehaviour to
Component
[Serializable]
{
}
{
0,
);
{
});
}

— Show player prefab with scripts be converted to entity
— Highlight entity debugger
[Editor / Live Code]
18

Moving actors
19
— Interpolate between
current and target
position
struct ActorSystemJob : IJobForEach<Translation, Rotation, ActorComponent>
{
public float deltaTime;
public void Execute(ref Translation translation,
ref Rotation rotation,
ref ActorComponent actor )
{
var direction = actor.target_positon - actor.position;
if (math.length(direction) > 0.1f)
{
direction = math.normalize(direction);
rotation.Value= quaternion.LookRotation(direction, math.up());
translation.Value = translation.Value + direction * deltaTime;
actor.position = translation.Value;
}
else
{
translation.Value = actor.target_positon;
}
}
}

Moving actors
20
current and target
position
— Change Translation and
Rotation accordingly
{
{
{
}
else
{
}
}
}

Moving actors
21
current and target
position
— Execute on all entities
with Translation,
Rotation and
ActorComponent
{
{
{
}
else
{
}
}
}

Moving actors
22
current and target
position
with Translation,
Rotation and
ActorComponent
{
{
{
}
else
{
}
}
}

Moving actors
23
current and target
position
with Translation,
Rotation and
ActorComponent
— Pipe external data in
and schedule the job
public class ActorSystem : JobComponentSystem
{
[BurstCompile]
struct ActorSystemJob
{ […] }
protected override JobHandle OnUpdate(JobHandle inputDependencies)
{
var job = new ActorSystemJob();
job.deltaTime = UnityEngine.Time.deltaTime;
return job.Schedule(this, inputDependencies);
}
}

public struct MoveIntention : IComponentData
{
public int2 direction_xz;
}
protected override void OnUpdate()
{
Entities.WithAll<ActorComponent>().ForEach((Entity id) =>
{
var direction = generateMove();
var intent = new MoveIntention()
{
direction_xz = direction
};
PostUpdateCommands.AddComponent<MoveIntention>(id, intent);
});
}
Moving actors
24
— Create MoveIntention

{
}
{
{
{
};
});
}
Moving actors
25

{
}
{
{
{
};
});
}
Moving actors
26
— System that generate
random intentions (for
our non-player actors)

{
}
{
{
{
};
});
}
Moving actors
27

{
}
{
{
{
};
});
}
Moving actors
28

{
}
{
{
{
};
});
}
Moving actors
29
— Component changes
need synchronization

{
}
{
{
{
};
});
}
Moving actors
30
— Component changes
need synchronization

New scene -> grid + player + enemies
31

— Player input / way to pass the turn
— Communicate between systems when allowed to run
— Variant 1: Manual control
— Variant 2: Component based control
Changes:
— PlayerComponent
— InputSystem: WASD -> MoveIntention
Bringing things in order. The player update
lock
32

Show InputSystem
Filter Player Entities from RandomMoveSystem
33

Variant 1: Manual Update
34
— Remove turn-based systems from
ECS update loop
— Manually trigger update after
each turn
— [DisableAutoCreation] of turn
based systems
— World.GetOrCreateSystem()
— System.Update()
TB System
TB System
Player Action
…

35
— Remove turn-based systems from
ECS update loop
— Manually trigger update after
each turn
— [DisableAutoCreation] of turn
based systems
— World.GetOrCreateSystem()
— System.Update()
TB System
TB System
Player Action
…

[Disable on Load] Move and RandomMove
Manually call them from TurnBasedGameLoop
36

37
One column body text
lorem ipsum dolor sit
amet, consectetur
adipiscing elit. Nunc
lacinia, nisi ac vehicula
pellentesque, justo tellus
dignissim velit, nec
rhoncus tellus lorem id
sapien.
Fine grained control
Low footprint
Manual effort for each system
Does not scale well

Variant 2: Interlocked Components
38
— Components to communicate
— Player has AwaitAction
— InputSystem consumes
AwaitAction
— If no player is waiting,
TurnBasedSystem hand out
ReadyToHandle flag
— After one frame every other
system updated so we remove
the flag again
Player Action
TB System
TB System
…

39
— Components to communicate
— Player has AwaitAction
— InputSystem consumes
AwaitAction
— If no player is waiting,
TurnBasedSystem hand out
ReadyToHandle flag
— After one frame every other
system updated so we remove
the flag again
Player Action
TB System
TB System
…

40
Player gets await flag
Input system consumes await flag
Talk about Query
If no one is waiting:
Hand out ready to handle tokens
Refresh await action token
Include handle token in move system

41
One column body text
lorem ipsum dolor sit
amet, consectetur
adipiscing elit. Nunc
lacinia, nisi ac vehicula
pellentesque, justo tellus
dignissim velit, nec
rhoncus tellus lorem id
sapien.
Scales nicely
Frontloading effort
Extensible
Multiple players out of the box
Complexity
Order related problems

What could be next?
42
— Gameplay!
— Alternative turn modes: Timed, multiple actions
— Integrate awesome Unity packages:
– Deterministic, stateless Physics
– Mulitplayer
– Live Play
– …

Recap
43
— ECS building blocks
— MonoBehaviours ECS
— Turn based game loop
— Player action triggers world
change
— Variants of turn based systems

Thank you!
Florian Uhde
@florianuhde
florian.uhde@posteo.de
44

Bonus Slide! Local Multiplayer
— Give ID to PlayerComponent
— Filter InputSystem based on ID
— MoveSystem -> WithAny

Bonus Slide! Update Groups
46
— Use attributes to sort systems
into update order
— [UpdateAfter] [UpdateBefore]
Player Action
TB System
TB System
…

Building a turn-based game prototype using ECS - Unite Copenhagen 2019

More Related Content

What's hot (20)

Similar to Building a turn-based game prototype using ECS - Unite Copenhagen 2019 (20)

More from Unity Technologies (20)

Recently uploaded (20)

Building a turn-based game prototype using ECS - Unite Copenhagen 2019