public class GameLogicSystemGroup : ComponentSystemGroup
    {
    }

    [UpdateInGroup(typeof(GameLogicSystemGroup))]
    public class StatUpdateSystemGroup : ComponentSystemGroup
    {
    }

    [UpdateInGroup(typeof(StatUpdateSystemGroup))]
    [UpdateAfter(typeof(SystemCalcStats))]
    public class SkillUpdateSystemGroup: ComponentSystemGroup
    {
    }

    [UpdateInGroup(typeof(StatUpdateSystemGroup), OrderFirst = true)]
    public class StatsStartBufferGroup : EntityCommandBufferSystem
    {
    }
    [UpdateInGroup(typeof(StatUpdateSystemGroup), OrderLast = true)]
    public class StatsEndBufferGroup : EntityCommandBufferSystem
    {
    }

    public struct StatBlock
    {
        public int Str;
        public int Dex;
        public int Int;
        public int Con;

        public static StatBlock operator +(StatBlock a, StatBlock b)
        {
            return new StatBlock()
            {
                Str = a.Str + b.Str,
                Dex = a.Dex + b.Dex,
                Int = a.Int + b.Int,
                Con = a.Con + b.Con
            };
        }
    }

    public struct TagStatsChanged : IComponentData
    {
    }


    public struct StatsBase : IComponentData
    {
        public StatBlock Value;
    }

    [InternalBufferCapacity(10)]
    public struct StatMods : IBufferElementData
    {
        public StatBlock Value;
    }


    public struct StatsModTotal : IComponentData
    {
        public StatBlock Value;
    }

    public struct Stats : IComponentData
    {
        public StatBlock Value;
    }

    public struct SomeSkillA : IComponentData
    {
        public int Value;
    }

    public struct SomeSkillB : IComponentData
    {
        public int Value;
    }

    [UpdateInGroup(typeof(StatUpdateSystemGroup))]
    public partial class SystemCalcMods : SystemBase
    {
        protected override void OnUpdate()
        {
            Entities.WithAll<TagStatsChanged>().ForEach((ref StatsModTotal total, in DynamicBuffer<StatMods> mods) =>
            {
                total.Value = new StatBlock();
                for (int i = 0; i < mods.Length; i++)
                    total.Value += mods[i].Value;
            }).ScheduleParallel(Dependency);
        }
    }

    [UpdateInGroup(typeof(StatUpdateSystemGroup))]
    [UpdateAfter(typeof(SystemCalcMods))]
    public partial class SystemCalcStats : SystemBase
    {
        protected override void OnUpdate()
        {
            Entities.ForEach((ref Stats total, in StatsModTotal mods, in StatsBase stats) =>
            {
                total.Value = stats.Value + mods.Value;
            }).ScheduleParallel(Dependency);
        }
    }

    [UpdateInGroup(typeof(SkillUpdateSystemGroup))]
    public partial class SystemCalcSkillA : SystemBase
    {
        protected override void OnUpdate()
        {
            Entities.WithAll<TagStatsChanged>().ForEach((ref SomeSkillA skill, in Stats stats) =>
            {
                skill.Value = 50 + (stats.Value.Str + stats.Value.Int) / 2;
            }).ScheduleParallel(Dependency);
        }
    }

    [UpdateInGroup(typeof(SkillUpdateSystemGroup))]
    public partial class SystemCalcSkillB : SystemBase
    {
        protected override void OnUpdate()
        {
            Entities.WithAll<TagStatsChanged>().ForEach((ref SomeSkillB skill, in Stats stats) =>
            {
                skill.Value = 25 + (stats.Value.Dex + stats.Value.Con + stats.Value.Str) / 3;
            }).ScheduleParallel(Dependency);
        }
    }


    [UpdateInGroup(typeof(GameLogicSystemGroup))]
    public partial class SystemClearTagStatsChanged : SystemBase
    {
        private StatsEndBufferGroup ecbSystem;

        protected override void OnCreate()
        {
            ecbSystem = World.GetOrCreateSystem<StatsEndBufferGroup>();
        }

        protected override void OnUpdate()
        {
            var ecb = ecbSystem.CreateCommandBuffer().AsParallelWriter();
            Entities.WithAll<TagStatsChanged>().ForEach((Entity e, int entityInQueryIndex) =>
            {
                ecb.RemoveComponent<TagStatsChanged>(entityInQueryIndex, e);
            }).ScheduleParallel();

            ecbSystem.AddJobHandleForProducer(Dependency);
        }
    }