Game features with ECS: we add kits to the shooter

From carpets to serious things. We have already told about ECS, what frameworks for Unity are and why we wrote our own (the list can be found at the end of the article). And now we’ll focus on specific examples of how we use ECS in our new mobile PvP shooter and how we implement game features. I note that we apply this architecture only to simulate the world on the server and the client prediction system. Visualization and rendering of objects are implemented using the MVP pattern - but today is not about that.

The ECS architecture is Data-oriented, all data from the game world is stored in the so-called GameState and is a list of entities with some components (components) on each of them. A set of components determines the behavior of an object. And the logic of the behavior of components is concentrated in the systems.
')
Gamestate in our ECS consists of two parts: RuleBook and WorldState. RuleBook is a set of components that do not change during a match. All static data is stored there (characteristics of weapons / characters, teams) and sent to the client only once - when logging in to the game server.

Consider a simple example: spawn a character and move it in 2D space using two joysticks. First, let's declare the components.

This identifies the player and is required to render the character:

[Component] public class Player { } 

The next component is a request to create a new character. It contains two fields: the character's spawn time (in ticks) and its ID:

 [Component] public class PlayerSpawnRequest { public int SpawnTime; public unit PlayerId; } 

Component orientation of the object in space:

 [Component] public class Transform { public Vector2 Position; public float Rotation; } 

Component storing the current speed of the object:

 [Component] public class Movement { public Vector2 Velocity; public float RotateToAngle; } 

Component that stores player input (motion joystick vector and character rotation joystick vector):

 [Component] public class Input { public Vector2 MoveVector; public Vector2 RotateVector; } 

Component with static characteristics of the character (it will be stored in RuleBook, since this is a basic characteristic and does not change during the game session):

 [Component] public class PlayerStats { public float MoveSpeed; } 

When decomposing features into systems, we are often guided by the single responsibility principle: each system must perform one and only one function.

Features can consist of several systems. Let's start by defining the character spawn system. The system passes through all requests for creating a character in the gamestate, and if the current world time matches the required one, it creates a new entity and attaches to it the components that define the player: Player , Transform , Movement .

 public class SpawnPlayerSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.SpawnAvatarRequest); foreach (var avatarRequest in gs.WorldState.SpawnAvatarRequest) { if (avatarRequest.Value.SpawnTime == gs.Time) { // create new entity with player ID var playerEntity = gs.WorldState.CreateEntity(avatarRequest.Value.PlayerId); // add components to determinate player behaviour playerEntity.AddPlayer(); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(Vector2.zero, 0); // delete player spawn request deleter.Delete(avatarRequest.Key); } } } } 

Now consider the movement of the player on the joystick. We need a system that will handle the input. It passes through all the components of the input, calculates the player’s speed (standing or moving) and converts the rotation vector of the joystick to the rotation angle:

 MovementControlSystem public class MovementControlSystem : ExecutableSystem { public override void Execute(GameState gs) { var playerStats = gs.RuleBook.PlayerStats[1]; foreach (var pair in gs.Input) { var movement = gs.WorldState.Movement[pair.Key]; movement.Velocity = pair.Value.MoveVector.normalized * playerStats.MoveSpeed; movement.RotateToAngle = Math.Atan2(pair.Value.RotateVector.y, pair.Value.RotateVector.x); } } } 

Next is the movement system:

 public class MovementSystem : ExecutableSystem { public override void Execute(GameState gs) { foreach (var pair in gs.WorldState.Movement) { var transform = gs.WorldState.Transform[pair.Key]; transform.Position += pair.Value.Velocity * GameState.TickDurationSec; } } } 

The system responsible for the rotation of the object:

 public class RotationSystem : ExecutableSystem { public override void Execute(GameState gs) { foreach (var pair in gs.WorldState.Movement) { var transform = gs.WorldState.Transform[pair.Key]; transform.Angle = pair.Value.RotateToAngle; } } } 

The MovementSystem and RotationSystem systems work only with Transform and Movement components. They are independent of the essence of the player. If other entities with the Movement and Transform components appear in our game, the movement logic will also work with them.

For example, let's add a first-aid kit that will move in a straight line along the spawn and, when selected, will replenish the health of the character. Declare the components:

 [Component] public class Health { public uint CurrentHealth; public uint MaxHealth; } [Component] public class HealthPowerUp { public uint NextChangeDirection; } [Component] public class HealthPowerUpSpawnRequest { public uint SpawnRequest; } [Component] public class HealthPowerUpStats { public float HealthRestorePercent; public float MoveSpeed; public float SecondsToChangeDirection; public float PickupRadius; public float TimeToSpawn; } 

Modify the stat component of the character by adding the maximum number of lives there:

 [Component] public class PlayerStats { public float MoveSpeed; public uint MaxHealth; } 

Now we modify the character's spawn system so that the character appears with maximum health:

 public class SpawnPlayerSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.SpawnAvatarRequest); var playerStats = gs.RuleBook.PlayerStats[1]; foreach (var avatarRequest in gs.WorldState.SpawnAvatarRequest) { if (avatarRequest.Value.SpawnTime <= gs.Time) { // create new entity with player ID var playerEntity = gs.WorldState.CreateEntity(avatarRequest.Value.PlayerId); // add components to determinate player behaviour playerEntity.AddPlayer(); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(Vector2.zero, 0); playerEntity.AddHealth(playerStats.MaxHealth, playerStats.MaxHealth); // delete player spawn request deleter.Delete(avatarRequest.Key); } } } } 

Then we announce the spawn system of our first-aid kits:

 public class SpawnHealthPowerUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.HealthPowerUpSpawnRequest); var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach (var spawnRequest in gs.WorldState.HealthPowerUpSpawnRequest) { // create new entity var powerUpEntity = gs.WorldState.CreateEntity(); // add components to determine healthPowerUp behaviour powerUpEntity.AddHealthPowerUp((uint)(healthPowerUpStats.SecondsToChangeDirection * GameState.Hz)); playerEntity.AddTransform(Vector2.zero, 0); playerEntity.AddMovement(healthPowerUpStats.MoveSpeed, 0); // delete player spawn request deleter.Delete(spawnRequest.Key); } } } 

And the system changes the speed of the first-aid kit. For simplicity, the first-aid kit will change direction every few seconds:

 public class HealthPowerUpMovementSystem : ExecutableSystem { public override void Execute(GameState gs) { var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach (var pair in gs.WorldState.HealthPowerUp) { var movement = gs.WorldState.Movement[pair.Key]; if(pair.Value.NextChangeDirection <= gs.Time) { pair.Value.NextChangeDirection = (uint) (healthPowerUpStats.SecondsToChangeDirection * GameState.Hz); movement.Velocity *= -1; } } } } 

Since we have already announced the MovementSystem to move objects in the game, we will only need the HealthPowerUpMovementSystem system to change the motion speed vector every N seconds.

Now we finish the selection of the first-aid kit and the accrual of the HP character. We will need another auxiliary component to store the number of lives that a character will receive after selecting a first aid kit.

 [Component] public class HealthToAdd { public int Health; public Entity Target; } 

And the component to remove our call:

 [Component] public class DeleteHealthPowerUpRequest { } 

We write the system processing the selection of first-aid kits:

 public class HealthPowerUpPickUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var healthPowerUpStats = gs.RoolBook.healthPowerUpStats[1]; foreach(var powerUpPair in gs.WorldState.HealthPowerUp) { var powerUpTransform = gs.WorldState.Transform[powerUpPair.Key]; foreach(var playerPair in gs.WorldState.Player) { var playerTransform = gs.WorldState.Transform[playerPair.Key]; var distance = Vector2.Distance(powerUpTransform.Position, playerTransform.Position) if(distance < healthPowerUpStats.PickupRadius) { var healthToAdd = gs.WorldState.Health[playerPair.Key].MaxHealth * healthPowerUpStats.HealthRestorePercent; var entity = gs.WorldState.CreateEntity(); entity.AddHealthToAdd(healthToAdd, gs.WorldState.Player[playerPair.Key]); var powerUpEnity = gs.WorldState[powerUpPair.Key]; powerUpEnity.AddDeleteHealthPowerUpRequest(); break; } } } } } 

The system passes through all active rapers and calculates the distance to the player. If any player is in the selection radius, the system creates two query components:

HealthToAdd - "request" to add character to lives;
DeleteHealthPowerUpRequest - "request" to delete the first-aid kit.

Why not add the required number of lives in the same system? We assume that the player receives HP not only from first-aid kits, but also from other sources. In this case, it is more expedient to separate the systems for selecting the first-aid kit and the system for charging the lives of the character. In addition, it is more consistent with the Single Responsibility Principle.

Implement a character's life accrual system:

 public class HealingSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.HealthToAdd); foreach(var healtToAddPair in gs.WorldState.HealthToAdd) { var healthToAdd = healtToAddPair.Value.Health; var health = healtToAddPair.Value.Target.Health; health.CurrentHealth += healthToAdd; health.CurrentHealth = Mathf.Clamp(health.CurrentHealth, 0, health.MaxHealth); deleter.Delete(healtToAddPair.Key); } } } 

The system traverses all components of HealthToAdd , charges the required number of lives in the Health component of the target entity Target . This entity knows nothing about the source and target object and is rather universal. This system can be used not only for the accrual of character’s lives, but for any objects that assume the presence of lives and their regeneration.

To implement the features with the first-aid kits, it remains to add the latest system: the system for removing the first-aid kit after its selection.

 public class DeleteHealthPowerUpSystem : ExecutableSystem { public override void Execute(GameState gs) { var deleter = gs.Pools.Deferred.GetDeleter(gs.WorldState.DeleteHealthPowerUpReques); foreach(var healthRequest in gs.WorldState.DeleteHealthPowerUpReques) { var id = healthRequest.Key; gs.WorldState.DelHealthPowerUp(id); gs.WorldState.DelTransform(id); gs.WorldState.DelMovement(id); deleter.Delete(id); } } } 

The HealthPowerUpPickUpSystem system creates a request to remove the first-aid kit. The DeleteHealthPowerUpSystem system follows all such requests and deletes all components that belong to the essence of the first-aid kit.

Is done. All systems from our examples are implemented. There is one thing about working with ECS - all systems are executed sequentially and this order is important.

In our example, the order of the systems is as follows:

 _systems = new List<ExecutableSystem> { new SpawnPlayerSystem(), new SpawnHealthPowerUpSystem(), new MovementControlSystem(), new HealthPowerUpMovementSystem(), new MovementSystem(), new RotationSystem(), new HealthPowerUpPickUpSystem(), new HealingSystem(), new DeleteHealthPowerUpSystem() }; 

In general, the first to go are the systems responsible for creating new entities and components. Then the processing systems and, at the end, the removal and cleaning systems.

With proper decomposition, ECS has great flexibility. Yes, our implementation is not perfect, but it allows to implement features in a short time, and also has good performance on modern mobile devices. You can read more about ECS here:

• How and why we wrote our ECS .
• As we are debugging in the browser samopisny ECS on the game server .
• Like ECS, C # Job System and SRP change the approach to architecture .
• Unity ECS .
• Unity, ECS and all-all-all. Good article on ECS in examples.