Similar systems for entities with additional components

What would be the correct ECS approach to creating two systems that would have nearly identical components and functionality in OnUpdate?

Say I have one system MySystem

Code (CSharp):

1. public class MySystem : ComponentSystem
2. {
3.     private struct Group group
4.     {
5.         public EntityArray Entity;
6.         public ComponentDataArray<AddedFlagComponent> AddedFlag;
7.         public ComponentArray<NiceComponent> Nice;
8.         public readonly int Length;
9.     }
10.     [Inject] private Group m_group;
11.  
12.     protected override void OnUpdate
13.     {
14.         for( int i = 0; i < m_group.Length; i++ )
15.         {
16.             // Operate on group.Nice[ i ];
17.  
18.             PostUpdateCommands.RemoveComponent<AddedFlagComponent>( group.Entity[ i ] );
19.         }
20.     }
21. }

and another system AnotherSystem

Code (CSharp):

1. public class MySystem : ComponentSystem
2. {
3.     private struct Group group
4.     {
5.         public EntityArray Entity;
6.         public ComponentDataArray<AddedFlagComponent> AddedFlag;
7.         public ComponentArray<NiceComponent> Nice;
8.         public ComponentArray<CoolComponent> Cool;
9.         public readonly int Length;
10.     }
11.     [Inject] private Group m_group;
12.  
13.     protected override void OnUpdate
14.     {
15.         for( int i = 0; i < m_group.Length; i++ )
16.         {
17.             // Operate on group.Nice[ i ];
18.             // Operate on group.Cool[ i ];
19.  
20.             PostUpdateCommands.RemoveComponent<AddedFlagComponent>( group.Entity[ i ] );
21.         }
22.     }
23. }

What is the appropriate way to make sure that I both MySystem and AnotherSystem don't each act on the entity? I also am imagining that I could separate the Cool operations into another system, but essentially I am using the AddedFlagComponent to work like an event - adding AddedFlagComponent from somewhere, then for the frame that AddedFlagComponent is on the entity, operate on Nice BUT if there is a CoolComponent then operate on Cool as well.

Edit: Playing around more, it seems like having MySystem and the system that processes CoolComponent should be separate systems. No use trying to apply the concept of inheritance and overrides to systems when the operating on the extra component CoolComponent can just be handled in another system.

 

Not sure if I understand your problem correctly but maybe use SubtractiveComponent<NiceComponent> on the second one so it acts only on Cool that is not Nice?

 

From your code examples, it looks like you have 3 different behaviors:

• operate on nice
• operate on cool
• remove AddedFlagComponent

So I would break up each behavior into it's own System with the following injections:

• OperateOnNiceSystem (AddedFlagComponent, NiceComponent)
• OperateOnCoolSystem (AddedFlagComponent, CoolComponent)
• RemoveAddedFlagComponent (AddedFlagComponent, Entity)

That makes it more decoupled thus more flexible and scalable.

 

^ I did forget to note that you should also configure the OperateOnNiceSystem and OperateOnCoolSystem to run before the RemoveAddedFlagComponent system.

 

Yep, breaking everything up into its own system is the way to go, for sure. I hadn't considered configuring having the two systems run before RemoveAddedFlag system, but that seems very appropriate for the situation. Thanks for the replies.