Schedule Job Error and Utility AI

Dnalsi · July 10, 2019, 8:26pm

Hi ! I am trying to create an AI based on the Utility AI from Dave Mark (here). To simplify my question, I create a test to illustrate my problem.
Simple Test

using NUnit.Framework;
using System;
using Unity.Entities;
using Unity.Jobs;

namespace Tests
{
    [Category("ECS Test")]
    public class SimpleFilterJobTests
    {
        World World;
        EntityManager Manager;

        [SetUp]
        public void SetUp()
        {
            World = new World("Test World");
            Manager = World.EntityManager;
        }

        public void TearDown()
        {
            if (World != null)
            {
                World.Dispose();
                World = null;
                Manager = null;
            }
        }

        [Test]
        public void AssertJobPass()
        {
            Assert.Pass();
        }

        public struct SharedValue : ISharedComponentData, IEquatable<SharedValue>
        {
            public int Value;

            public bool Equals(SharedValue other)
            {
                return Value == other.Value;
            }

            public override int GetHashCode()
            {
                return Value;
            }
        }

        public struct SimpleValue : IComponentData
        {
            public float Value;
        }

        public struct SimpleValueJob : IJobForEach<SimpleValue>
        {
            public void Execute(ref SimpleValue simple)
            {
                simple.Value = 10;
            }
        }

        [Test]
        public void TestScheduleOnTwoSeperateChunk()
        {
            for (int i = 0; i < 10; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponent(e, typeof(SimpleValue));
                Manager.AddSharedComponentData(e, new SharedValue { Value = 1 });
            }

            for (int i = 0; i < 10; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponent(e, typeof(SimpleValue));
                Manager.AddSharedComponentData(e, new SharedValue { Value = 2 });
            }

            var query = Manager.CreateEntityQuery(typeof(SharedValue), typeof(SimpleValue));

            query.SetFilter(new SharedValue { Value = 1 });
            var handle1 = new SimpleValueJob().Schedule(query);

            query.SetFilter(new SharedValue { Value = 2 });
            var handle2 = new SimpleValueJob().Schedule(query);

            JobHandle.CompleteAll(ref handle1, ref handle2);
        }
    }
}

And the error, I get.
Test Error

TestScheduleOnTwoSeperateChunk (1.281s)
---
System.InvalidOperationException : The previously scheduled job SimpleFilterJobTests:SimpleValueJob writes to the NativeArray SimpleValueJob.Iterator. You are trying to schedule a new job SimpleFilterJobTests:SimpleValueJob, which writes to the same NativeArray (via SimpleValueJob.Iterator). To guarantee safety, you must include SimpleFilterJobTests:SimpleValueJob as a dependency of the newly scheduled job.
---
at Unity.Entities.JobForEachExtensions.Schedule (System.Void* fullData, Unity.Collections.NativeArray`1[T] prefilterData, System.Int32 unfilteredLength, System.Int32 innerloopBatchCount, System.Boolean isParallelFor, System.Boolean isFiltered, Unity.Entities.JobForEachExtensions+JobForEachCache& cache, System.Void* deferredCountData, Unity.Jobs.JobHandle dependsOn, Unity.Jobs.LowLevel.Unsafe.ScheduleMode mode) [0x00066] in D:\Project\VoxelWar\Library\PackageCache\com.unity.entities@0.0.12-preview.33\Unity.Entities\IJobForEach.cs:451
at Unity.Entities.JobForEachExtensions.ScheduleInternal_C[T] (T& jobData, Unity.Entities.ComponentSystemBase system, Unity.Entities.EntityQuery query, System.Int32 innerloopBatchCount, Unity.Jobs.JobHandle dependsOn, Unity.Jobs.LowLevel.Unsafe.ScheduleMode mode) [0x0007c] in D:\Project\VoxelWar\Library\PackageCache\com.unity.entities@0.0.12-preview.33\Unity.Entities\IJobForEach.gen.cs:1510
at Unity.Entities.JobForEachExtensions.Schedule[T] (T jobData, Unity.Entities.EntityQuery query, Unity.Jobs.JobHandle dependsOn) [0x00020] in D:\Project\VoxelWar\Library\PackageCache\com.unity.entities@0.0.12-preview.33\Unity.Entities\IJobForEach.gen.cs:1152
at Tests.SimpleFilterJobTests.TestScheduleOnTwoSeperateChunk () [0x00190] in D:\Project\VoxelWar\Assets\Tests\AI\Behaviour\SimpleFilterJobTests.cs:93
at (wrapper managed-to-native) System.Reflection.MonoMethod.InternalInvoke(System.Reflection.MonoMethod,object,object[ ],System.Exception&)
at System.Reflection.MonoMethod.Invoke (System.Object obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, System.Object[ ] parameters, System.Globalization.CultureInfo culture) [0x00032] in <1f0c1ef1ad524c38bbc5536809c46b48>:0

If I understand, I should make my second JobHandle depends from the first job. But why ? If I understand SharedComponentData, the first and second job should read on 2 separates chunks, so they shouldn’t have a problem to write in the NativeArray ?

Now for the context like I say I want to maximize the use of ECS in my Utility System. I know I will have random access but I can still multi-thread my code and use the burst compiler, so I am thinking it’s worth it.

My data is structure like that. I have DecisionMaker which have Decisions which have Considerations. Each considerations and decisions need to give a score. All decisions are unique but, considerations are fixed and there score can be reuse in the same DecisionMaker. So if I have 2 decision that need to consider its health, I can score HealthConsideration one time for 2 decisions. Each decision score is multiply and compensate on one ComponentData and the highest of all decisions in all DecisionMaker is the winner.

One solution, it’s to use one attribute by DecisionMaker

Test One Attribute

using NUnit.Framework;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;

namespace Tests
{
    [Category("VoxelWar")]
    public class AgentBrainTests
    {
        World World;
        EntityManager Manager;

        [SetUp]
        public void SetUp()
        {
            World = new World("Test World");
            Manager = World.EntityManager;

            for (int i = 0; i < 10; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponentData(e, new TestHealth { Value = 10f });
                Manager.AddComponent(e, typeof(TestHealthScore));
                Manager.AddComponent(e, typeof(TestHighestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionMaker1));
            }

            for (int i = 0; i < 5; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponentData(e, new TestHealth { Value = 5f });
                Manager.AddComponentData(e, new TestDistance { Value = 25f });
                Manager.AddComponent(e, typeof(TestHealthScore));
                Manager.AddComponent(e, typeof(TestDistanceScore));
                Manager.AddComponent(e, typeof(TestHighestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionMaker2));
                Manager.AddComponent(e, typeof(TestDecisionMaker1));
            }
        }

        public void TearDown()
        {
            if (World != null)
            {
                World.Dispose();
                World = null;
                Manager = null;
            }
        }

        // A Test behaves as an ordinary method
        [Test]
        public void AgentBrainTestsSimplePasses()
        {
            Assert.Pass();
        }

        public struct TestDecisionMaker1 : IComponentData { }
        public struct TestDecisionMaker2 : IComponentData { }

        public struct TestHighestDecisionScore : IComponentData { public float Value; }
        public struct TestDecisionScore : IComponentData { public float Value; }

        public struct TestHealthScore : IComponentData { public float Value; }
        public struct TestHealth : IComponentData { public float Value; }

        public struct TestDistanceScore : IComponentData { public float Value; }
        public struct TestDistance : IComponentData { public float Value; }

        public class TestBarrier : EntityCommandBufferSystem { }

        public interface ITestConsideration
        {
            void Init(EntityManager manager, EntityQuery query);
            JobHandle Score(EntityQuery query);
            JobHandle Merge(EntityQuery query, JobHandle inputDeps);
        }

        public class TestHealthConsideration : ITestConsideration
        {
            struct HealthJob : IJobForEach<TestHealthScore, TestHealth>
            {
                public void Execute(ref TestHealthScore c0, [ReadOnly] ref TestHealth c1)
                {
                    c0.Value = c1.Value / 10;
                }
            }

            struct MergeHealth : IJobForEachWithEntity<TestDecisionScore, TestHealthScore>
            {
                public void Execute(Entity entity, int index, ref TestDecisionScore c0, [ReadOnly] ref TestHealthScore c1)
                {
                    c0.Value *= c1.Value;
                }
            }

            public void Init(EntityManager manager, EntityQuery query)
            {
                manager.AddComponent(query, typeof(TestHealthScore));
            }

            public JobHandle Score(EntityQuery query)
            {
                return new HealthJob().Schedule(query);
            }

            public JobHandle Merge(EntityQuery query, JobHandle inputDeps)
            {
                return new MergeHealth().Schedule(query, inputDeps);
            }
        }

        public class TestDistanceConsideration : ITestConsideration
        {
            struct DistanceJob : IJobForEach<TestDistanceScore, TestDistance>
            {
                public void Execute(ref TestDistanceScore c0, [ReadOnly] ref TestDistance c1)
                {
                    c0.Value = c1.Value / 50;
                }
            }

            struct MergeDistance : IJobForEachWithEntity<TestDecisionScore, TestDistanceScore>
            {
                public void Execute(Entity entity, int index, ref TestDecisionScore c0, [ReadOnly] ref TestDistanceScore c1)
                {
                    c0.Value *= c1.Value;
                }
            }

            public void Init(EntityManager manager, EntityQuery query)
            {
                manager.AddComponent(query, typeof(TestDistanceScore));
            }

            public JobHandle Score(EntityQuery query)
            {
                return new DistanceJob().Schedule(query);
            }

            public JobHandle Merge(EntityQuery query, JobHandle inputDeps)
            {
                return new MergeDistance().Schedule(query, inputDeps);
            }
        }

        public struct TestCompareHighestDecisionScore : IJobForEach<TestHighestDecisionScore, TestDecisionScore>
        {
            public void Execute(ref TestHighestDecisionScore c0, ref TestDecisionScore c1)
            {
                c0.Value = math.max(c0.Value, c1.Value);
            }
        }

        [Test]
        public void AgentBrainDecisionTagComponent()
        {
            ITestConsideration[] considerations = new ITestConsideration[]
            {
                new TestHealthConsideration(),
                new TestDistanceConsideration()
            };

            EntityQueryDesc[] decisions = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealth), typeof(TestDistance) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDistance) } }
            };
            EntityQueryDesc[] decisionScores = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealthScore), typeof(TestDistanceScore), typeof(TestHealth), typeof(TestDistance) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealthScore), typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDistanceScore), typeof(TestDistance) } }
            };

            int[][] decisionConsiderations = new int[][]
            {
                new int[] { 1, 0 },
                new int[] { 0 },
                new int[] { 1 }
            };

            int[] sortedDecision = new int[] { 1, 0, 2 };
            int[] sortedDecisionMaker = new int[] { 0, 1, 1 };
            EntityQueryDesc[] decisionMakers = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDecisionMaker1), typeof(TestHighestDecisionScore), typeof(TestDecisionScore), typeof(TestHealthScore), typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDecisionMaker2), typeof(TestDecisionMaker1), typeof(TestHighestDecisionScore), typeof(TestDecisionScore), typeof(TestHealthScore), typeof(TestDistanceScore), typeof(TestHealth), typeof(TestDistance) } }
            };

            EntityQuery[] queries = new EntityQuery[decisionMakers.Length];
            queries[0] = Manager.CreateEntityQuery(decisionMakers[0]);
            queries[1] = Manager.CreateEntityQuery(decisionMakers[1]);

            Assert.AreEqual(15, queries[0].CalculateLength());
            Assert.AreEqual(5, queries[1].CalculateLength());

            for (int i = 0; i < decisions.Length; i++)
            {
                EntityQuery query = queries[sortedDecisionMaker[i]];

                JobHandle handle = default;
                int[] consIndice = decisionConsiderations[sortedDecision[i]];
                for (int j = 0; j < consIndice.Length; j++)
                {
                    var consideration = considerations[consIndice[j]];

                    JobHandle inputDeps = consideration.Score(query);
                    inputDeps = consideration.Merge(query, JobHandle.CombineDependencies(handle, inputDeps));
                    handle = JobHandle.CombineDependencies(handle, inputDeps);
                }
                handle = new TestCompareHighestDecisionScore().Schedule(query, handle);
                handle.Complete();
            }

            using (var scores = queries[0].ToComponentDataArray<TestHealthScore>(Allocator.TempJob))
            {
                for (int i = 0; i < scores.Length; i++)
                {
                    Assert.IsTrue(scores[i].Value == 1f || scores[i].Value == 0.5f);
                }
            }

            Assert.Pass();
        }
    }
}

The problem with this solution is that I need to hardcode my DecisionMaker struct. I want to let my designer and player create decision outside the game. So what I can do, it’s create like 100 DecisionMaker struct, which represent one index and could access in a big switch or array and use the unique index of the DecisionMaker to tag my entity. Which I feel is kind a bad practice to be honest. I looked at the generation of ComponentType and there doesn’t seem to be a way to create a fake ComponentType at runtime or something like that.

So my second solution is to use SharedComponentData to seperate create something like above.

Test SharedComponent

using System;
using System.Collections;
using System.Collections.Generic;
using NUnit.Framework;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.TestTools;

namespace Tests
{
    [Category("VoxelWar")]
    public class AgentBrainSharedTests
    {
        World World;
        EntityManager Manager;

        [SetUp]
        public void SetUp()
        {
            World = new World("Test World");
            Manager = World.EntityManager;

            for (int i = 0; i < 10; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponentData(e, new TestHealth { Value = 10f });
                Manager.AddComponent(e, typeof(TestHealthScore));
                Manager.AddComponent(e, typeof(TestHighestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionScore));
                Manager.AddSharedComponentData(e, new TestBrainChunk { Value = 1 });
            }

            for (int i = 0; i < 5; i++)
            {
                var e = Manager.CreateEntity();
                Manager.AddComponentData(e, new TestHealth { Value = 5f });
                Manager.AddComponentData(e, new TestDistance { Value = 25f });
                Manager.AddComponent(e, typeof(TestHealthScore));
                Manager.AddComponent(e, typeof(TestDistanceScore));
                Manager.AddComponent(e, typeof(TestHighestDecisionScore));
                Manager.AddComponent(e, typeof(TestDecisionScore));
                Manager.AddSharedComponentData(e, new TestBrainChunk { Value = 2 });
            }
        }

        public void TearDown()
        {
            if (World != null)
            {
                World.Dispose();
                World = null;
                Manager = null;
            }
        }

        // A Test behaves as an ordinary method
        [Test]
        public void AgentBrainTestsSimplePasses()
        {
            Assert.Pass();
        }

        public struct TestBrainChunk : ISharedComponentData, IEquatable<TestBrainChunk>
        {
            public int Value;

            public bool Equals(TestBrainChunk other)
            {
                return other.Value == Value;
            }

            public override int GetHashCode()
            {
                return Value;
            }
        }

        public struct TestHighestDecisionScore : IComponentData { public float Value; }
        public struct TestDecisionScore : IComponentData { public float Value; }

        public struct TestHealthScore : IComponentData { public float Value; }
        public struct TestHealth : IComponentData { public float Value; }

        public struct TestDistanceScore : IComponentData { public float Value; }
        public struct TestDistance : IComponentData { public float Value; }

        public class TestBarrier : EntityCommandBufferSystem { }

        public interface ITestConsideration
        {
            void Init(EntityManager manager, EntityQuery query);
            JobHandle Score(EntityQuery query);
            JobHandle Merge(EntityQuery query, JobHandle inputDeps);
        }

        public class TestHealthConsideration : ITestConsideration
        {
            struct HealthJob : IJobForEach<TestHealthScore, TestHealth>
            {
                public void Execute(ref TestHealthScore c0, [ReadOnly] ref TestHealth c1)
                {
                    c0.Value = c1.Value / 10;
                }
            }

            struct MergeHealth : IJobForEachWithEntity<TestDecisionScore, TestHealthScore>
            {
                public void Execute(Entity entity, int index, ref TestDecisionScore c0, [ReadOnly] ref TestHealthScore c1)
                {
                    c0.Value *= c1.Value;
                }
            }

            public void Init(EntityManager manager, EntityQuery query)
            {
                manager.AddComponent(query, typeof(TestHealthScore));
            }

            public JobHandle Score(EntityQuery query)
            {
                return new HealthJob().Schedule(query);
            }

            public JobHandle Merge(EntityQuery query, JobHandle inputDeps)
            {
                return new MergeHealth().Schedule(query, inputDeps);
            }
        }

        public class TestDistanceConsideration : ITestConsideration
        {
            struct DistanceJob : IJobForEach<TestDistanceScore, TestDistance>
            {
                public void Execute(ref TestDistanceScore c0, [ReadOnly] ref TestDistance c1)
                {
                    c0.Value = c1.Value / 50;
                }
            }

            struct MergeDistance : IJobForEachWithEntity<TestDecisionScore, TestDistanceScore>
            {
                public void Execute(Entity entity, int index, ref TestDecisionScore c0, [ReadOnly] ref TestDistanceScore c1)
                {
                    c0.Value *= c1.Value;
                }
            }

            public void Init(EntityManager manager, EntityQuery query)
            {
                manager.AddComponent(query, typeof(TestDistanceScore));
            }

            public JobHandle Score(EntityQuery query)
            {
                return new DistanceJob().Schedule(query);
            }

            public JobHandle Merge(EntityQuery query, JobHandle inputDeps)
            {
                return new MergeDistance().Schedule(query, inputDeps);
            }
        }

        public struct TestCompareHighestDecisionScore : IJobForEach<TestHighestDecisionScore, TestDecisionScore>
        {
            public void Execute(ref TestHighestDecisionScore c0, ref TestDecisionScore c1)
            {
                c0.Value = math.max(c0.Value, c1.Value);
            }
        }

        [Test]
        public void AgentBrainDecisionSharedComponent()
        {
            ITestConsideration[] considerations = new ITestConsideration[]
            {
                new TestHealthConsideration(),
                new TestDistanceConsideration()
            };

            EntityQueryDesc[] decisions = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealth), typeof(TestDistance) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDistance) } }
            };
            EntityQueryDesc[] decisionScores = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealthScore), typeof(TestDistanceScore), typeof(TestHealth), typeof(TestDistance) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestHealthScore), typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestDistanceScore), typeof(TestDistance) } }
            };

            int[][] decisionConsiderations = new int[][]
            {
                new int[] { 1, 0 },
                new int[] { 0 },
                new int[] { 1 }
            };

            int[] sortedDecision = new int[] { 1, 0, 2 };
            int[] sortedDecisionMaker = new int[] { 0, 1, 1 };
            EntityQueryDesc[] decisionMakers = new EntityQueryDesc[]
            {
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestBrainChunk), typeof(TestHighestDecisionScore), typeof(TestDecisionScore), typeof(TestHealthScore), typeof(TestHealth) } },
                new EntityQueryDesc { All = new ComponentType[] { typeof(TestBrainChunk), typeof(TestHighestDecisionScore), typeof(TestDecisionScore), typeof(TestHealthScore), typeof(TestDistanceScore), typeof(TestHealth), typeof(TestDistance) } }
            };

            EntityQuery[] queries = new EntityQuery[decisionMakers.Length];
            queries[0] = Manager.CreateEntityQuery(decisionMakers[0]);
            queries[1] = Manager.CreateEntityQuery(decisionMakers[1]);

            Dictionary<int, List<int>> brainChunkDecisionMaker = new Dictionary<int, List<int>>();
            brainChunkDecisionMaker.Add(0, new List<int> { 1, 2 });
            brainChunkDecisionMaker.Add(1, new List<int> { 2 });

            List<int> keys = new List<int>();
            NativeList<JobHandle> values = new NativeList<JobHandle>(10, Allocator.Temp);
            try
            {
                for (int i = 0; i < decisions.Length; i++)
                {
                    EntityQuery query = queries[sortedDecisionMaker[i]];
                    brainChunkDecisionMaker.TryGetValue(sortedDecisionMaker[i], out List<int> makerIndice);

                    int[] consIndice = decisionConsiderations[sortedDecision[i]];
                    for (int index = 0; index < makerIndice.Count; index++)
                    {
                        int valueIndex = FindOrCreateIndexOf(makerIndice[index], ref keys, ref values);
                        query.SetFilter(new TestBrainChunk { Value = makerIndice[index] });

                        for (int j = 0; j < consIndice.Length; j++)
                        {
                            JobHandle inputDeps = considerations[consIndice[j]].Score(query);
                            inputDeps = considerations[consIndice[j]].Merge(query, JobHandle.CombineDependencies(inputDeps, values[valueIndex]));
                            values[valueIndex] = new TestCompareHighestDecisionScore().Schedule(query, inputDeps);
                        }
                    }

                    JobHandle.CompleteAll(values);
                    values.Clear();
                    keys.Clear();
                }
            }
            finally
            {
                values.Dispose();
            }

            queries[0].ResetFilter();
            queries[1].ResetFilter();

            queries[0].SetFilter(new TestBrainChunk { Value = 1 });
            using (var scores = queries[0].ToComponentDataArray<TestHealthScore>(Allocator.TempJob))
            {
                for (int i = 0; i < scores.Length; i++)
                {
                    Assert.AreEqual(1f, scores[i].Value);
                }
            }

            queries[0].SetFilter(new TestBrainChunk { Value = 2 });
            using (var scores = queries[0].ToComponentDataArray<TestHealthScore>(Allocator.TempJob))
            {
                for (int i = 0; i < scores.Length; i++)
                {
                    Assert.AreEqual(0.5f, scores[i].Value);
                }
            }

            queries[1].SetFilter(new TestBrainChunk { Value = 2 });
            using (var scores = queries[0].ToComponentDataArray<TestHealthScore>(Allocator.TempJob))
            {
                for (int i = 0; i < scores.Length; i++)
                {
                    Assert.AreEqual(0.5f, scores[i].Value);
                }
            }
        }

        private int FindOrCreateIndexOf(int item, ref List<int> keys, ref NativeList<JobHandle> values)
        {
            int index = keys.IndexOf(item);
            if (index == -1)
            {
                index = keys.Count;
                keys.Add(item);
                values.Add(default);
            }

            return index;
        }
    }
}

So in my example BrainChunk has either the value 1 or 2. The value 1 represent the DecisionMaker1 and the value 2 represent DecisionMaker1 and DecisionMaker2. I keep in memory in brainChunkDecisionMaker where every DecisionMaker1 is and in what chunk, and sefilter by this value. Maybe you see now my comparison with my first issue. It give me the same error, because even if I am on different chunk I cannot access the same NativeArray for the same job

So my question is, is it normal behaviour or a bug ? And if normal, what should I do ? My next idea was to create my own chunk or get my chunks from my EntityQuery. Else I thought maybe to read a dll that my tool create which have a attribute custom for each DecisionMaker and bind to a unique index. It would need to be recompile because type need to be know at compilation. It could be an Ok solution for my designer but not for my player.
Another question in the same context. This system need to run in another World to keep my fps stable. I found the EntityManager.MoveEntitiesFrom to move the data of All my agents on another EntityManager. One thing I want to do in my system is to keep a cache of my precedent consideration score. So every update, I want to sync my entity from one world to the other. Is it possible or a good idea ?
Last question, I keep my raycast in a DynamicBuffer to reuse for other consideration, so I create my own collector to add the value directly in my DynamicBuffer. Because the DynamicBuffer has a internal max buffer I would like to stop the query when the DynamicBuffer is full. I saw that in an ICollector.Add you need to return a bool. If I return false, does the collector stop its query and if not is there another way to create this behavior ?

Thank you.

Dnalsi · July 12, 2019, 7:08pm

Another solution would be to manage all the score outside EntityManager. With that no more problem with job Schedule and Sync value. I would need to find a way to align EntityManager chunks and my score chunks and process both at same time in an IJobParallelFor

Still curious about why I can’t query 2 jobs when I filter them and process them in 2 separate chunks.

Dnalsi · August 9, 2019, 1:30am

Hey ! I made some progress and thought some people could be interested.

First thing first, I did some performance tests that schedule 2 jobs which write to 2 different part of an array. One test has one jobs depends on the other and another test has no dependency. The result is that both go at approximately the same speed. My theory is that the Job Scheduling system can see when there is no collision and schedule accordingly. At least, I think…

Anyway, I wandered from my initial solution. My initial solution was to schedule every considerations and removing entity with IJobParallelForFilter. At first, I chose this solution because I wanted to minimize my cache miss, but after some thinking I realize it was not a good solution. Using SharedComponent and IJobParallelForFilter for my jobs would create small chunk of entity, so each jobs would work with 10 entities. So overall it was a lot of work on the mainthread for not a lot of performance gain. Anyway, after some research and rereading this post , I realize what people was proposing. Creating a big job that process all entities, one at a time. It was a lot easier to write because it was just following the implementation of Dave in a job. This is my implementation of Utility AI using ECS:

AIBehaviourSystem

using System.Collections.Generic;
using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Transforms;
using VoxelWar.AI.Navigation;
using VoxelWar.Generic;
using VoxelWar.Helper;

namespace VoxelWar.AI.Behaviour
{
    readonly struct ActorContext
    {
        public readonly Entity Entity;
        public readonly Entity MyTarget;
        public readonly float3 Position;
        public readonly ActorDecision LastDecision;

        public ActorContext(Entity entity, Entity myTarget, float3 position, ActorDecision decision)
        {
            Entity = entity;
            MyTarget = myTarget;
            Position = position;
            LastDecision = decision;
        }
    }

    struct BrainContext
    {
        public int Decision;

        public float Self;
        public float Factor;

        public NativeList<float> Targets;
        public NativeList<Entity> Identities;
        public NativeList<DistanceHit> Hits;
    }

    public class AIBehaviourSystem : JobComponentSystem
    {
        [BurstCompile]
        struct ActorBrainScoreJob : IJobForEachWithEntity_EBCCC<ActorBrain, Translation, ActorDecision, ActorTarget>
        {
            [ReadOnly] public CollisionWorld CollisionWorld;

            [ReadOnly] public NativeArray<DecisionEvaluator> Evaluators;
            [ReadOnly] public NativeArray<Consideration> Considerations;

            [ReadOnly] public ComponentDataFromEntity<Health> Healths;
            [ReadOnly] public ComponentDataFromEntity<Translation> Positions;

            const float momentum = 0.04f;

            public void Execute(Entity entity, int index, DynamicBuffer<ActorBrain> decisions,
                [ReadOnly] ref Translation myPosition, ref ActorDecision myDecision, [ReadOnly] ref ActorTarget myTarget)
            {
                var actor = new ActorContext(entity, myTarget.Value, myPosition.Value, myDecision);

                var brain = new BrainContext
                {
                    Targets = new NativeList<float>(Allocator.Temp),
                    Identities = new NativeList<Entity>(Allocator.Temp),
                    Hits = new NativeList<DistanceHit>(Allocator.Temp)
                };

                var highest = new ActorDecision
                {
                    Decision = -1,
                    Score = float.MinValue,
                    Target = Entity.Null
                };

                for (int dec = 0; dec < decisions.Length; dec++)
                {
                    brain.Decision = decisions[dec].Decision;

                    var evaluator = Evaluators[brain.Decision];
                    if (evaluator.Weight < highest.Score)
                        break;

                    if (evaluator.Context == EvaluatorContext.Self)
                    {
                        EvaluateSelfDecision(evaluator, actor, ref highest, ref brain);
                    }
                    else
                    {
                        EvaluateMultipleDecision(evaluator, actor, ref highest, ref brain);
                    }
                }

                brain.Targets.Dispose();
                brain.Identities.Dispose();
                brain.Hits.Dispose();

                myDecision = highest;
            }

            private void EvaluateSelfDecision(in DecisionEvaluator evaluator, in ActorContext actor, ref ActorDecision highest, ref BrainContext brain)
            {
                var considerations = evaluator.Considerations;

                brain.Self = evaluator.Weight + math.select(0, momentum, brain.Decision == actor.LastDecision.Decision) * evaluator.Weight;
                brain.Factor = 1f - (1f / considerations.Length);

                for (int c = 0; c < considerations.Length && brain.Self > highest.Score; c++)
                {
                    ScoreConsideration(Considerations[considerations.Start + c], actor, ref brain);
                }

                bool newHighest = brain.Self > highest.Score;
                highest.Score = math.select(highest.Score, brain.Self, newHighest);
                highest.Decision = math.select(highest.Decision, brain.Decision, newHighest);
                highest.Target = newHighest ? Entity.Null : highest.Target;
            }

            private void EvaluateMultipleDecision(in DecisionEvaluator evaluator, in ActorContext actor, ref ActorDecision highest, ref BrainContext brain)
            {
                FilterLayer layer = FilterLayer.Default;
                switch (evaluator.Context)
                {
                    case EvaluatorContext.Allies: layer = FilterLayer.Allies; break;
                    case EvaluatorContext.Enemies: layer = FilterLayer.Enemies; break;
                }

                CollisionWorld.CalculateDistance(new PointDistanceInput
                {
                    Position = actor.Position,
                    MaxDistance = 50f,
                    Filter = CollisionFilterUtils.Interact(layer)
                }, ref brain.Hits);

                if (brain.Hits.Length != 0)
                {
                    for (int i = 0; i < brain.Hits.Length; i++)
                    {
                        var entity = CollisionWorld.Bodies[brain.Hits[i].RigidBodyIndex].Entity;
                        brain.Targets.Add(1f + math.select(0, momentum, brain.Decision == actor.LastDecision.Decision && actor.LastDecision.Target == entity));
                        brain.Identities.Add(entity);
                    }

                    var considerations = evaluator.Considerations;

                    brain.Self = evaluator.Weight + math.select(0, momentum, brain.Decision == actor.LastDecision.Decision);
                    brain.Factor = 1f - (1f / considerations.Length);

                    for (int c = 0; c < considerations.Length && brain.Targets.Length != 0; c++)
                    {
                        ScoreConsideration(Considerations[considerations.Start + c], actor, ref brain);

                        RemoveLowScoreTargets(highest.Score, ref brain);
                    }

                    for (int i = 0; i < brain.Targets.Length; i++)
                    {
                        float score = brain.Self * brain.Targets[i];
                        bool newHighest = score > highest.Score;
                        highest.Score = math.select(highest.Score, score, newHighest);
                        highest.Decision = math.select(highest.Decision, brain.Decision, newHighest);
                        highest.Target = newHighest ? brain.Identities[i] : highest.Target;
                    }

                    brain.Targets.Clear();
                    brain.Identities.Clear();
                }

                brain.Hits.Clear();
            }

            private void ScoreConsideration(in Consideration consideration, in ActorContext actor, ref BrainContext brain)
            {
                switch (consideration.Type)
                {
                    case ConsiderationType.MyHealth:
                        {
                            brain.Self = ScoreHealth(brain.Self, actor.Entity, consideration.Curve, brain.Factor);
                        }
                        break;
                    case ConsiderationType.MyTargetHealth:
                        {
                            brain.Self = ScoreHealth(brain.Self, actor.MyTarget, consideration.Curve, brain.Factor);
                        }

                        break;
                    case ConsiderationType.HealthOf:
                        {
                            for (int i = 0; i < brain.Targets.Length; i++)
                            {
                                brain.Targets[i] = ScoreHealth(brain.Targets[i], brain.Identities[i], consideration.Curve, brain.Factor);
                            }
                        }

                        break;
                    case ConsiderationType.MyDistanceToTarget:
                        {
                            var range = consideration.Params.ToRange();

                            for (int i = 0; i < brain.Targets.Length; i++)
                            {
                                float3 targetPos = CollisionWorld.Bodies[brain.Hits[i].RigidBodyIndex].WorldFromBody.pos;
                                float input = (math.distance(actor.Position, targetPos) - range.Min) / range.Distance;

                                brain.Targets[i] = Compensate(brain.Targets[i] * CurveSolver.Solve(input, consideration.Curve), ref brain.Factor);
                            }
                        }

                        break;
                    case ConsiderationType.MyDistanceToMyTarget:
                        {
                            var range = consideration.Params.ToRange();
                            float input = (math.distance(actor.Position, Positions[actor.MyTarget].Value) - range.Min) / range.Distance;

                            brain.Self = Compensate(brain.Self * CurveSolver.Solve(input, consideration.Curve), ref brain.Factor);
                        }

                        break;
                    case ConsiderationType.MyDistanceToFixTarget:
                        {
                            var target = consideration.Params.ToTarget();
                            var range = consideration.Params.ToRange();
                            float input = (math.distance(actor.Position, Positions[target.Value].Value) - range.Min) / range.Distance;

                            brain.Self = Compensate(brain.Self * CurveSolver.Solve(input, consideration.Curve), ref brain.Factor);
                        }

                        break;
                    case ConsiderationType.DistanceToMyTarget:
                        {
                            var range = consideration.Params.ToRange();

                            for (int i = 0; i < brain.Targets.Length; i++)
                            {
                                float3 targetPos = CollisionWorld.Bodies[brain.Hits[i].RigidBodyIndex].WorldFromBody.pos;
                                float input = (math.distance(Positions[actor.MyTarget].Value, targetPos) - range.Min) / range.Distance;

                                brain.Targets[i] = Compensate(brain.Targets[i] * CurveSolver.Solve(input, consideration.Curve), ref brain.Factor);
                            }
                        }

                        break;
                    case ConsiderationType.DistanceToFixTarget:
                        {
                            var target = consideration.Params.ToTarget();
                            var range = consideration.Params.ToRange();

                            for (int i = 0; i < brain.Targets.Length; i++)
                            {
                                float3 targetPos = CollisionWorld.Bodies[brain.Hits[i].RigidBodyIndex].WorldFromBody.pos;
                                float input = (math.distance(actor.Position, targetPos) - range.Min) / range.Distance;

                                brain.Targets[i] = Compensate(brain.Targets[i] * CurveSolver.Solve(input, consideration.Curve), ref brain.Factor);
                            }
                        }

                        break;
                }
            }

            private float ScoreHealth(float score, Entity target, in Curve curve, float factor)
            {
                if (!Healths.Exists(target))
                    return 0;
                 
                var health = Healths[target];
                float input = health.Value / health.Max;

                return Compensate(score * CurveSolver.Solve(input, curve), ref factor);
            }

            private static void RemoveLowScoreTargets(float highestScore, ref BrainContext brain)
            {
                int i = 0;
                //Remove any target who are under the highest decision score
                while (i < brain.Targets.Length)
                {
                    if (brain.Targets[i] * brain.Self < highestScore)
                    {
                        brain.Targets.RemoveAtSwapBack(i);
                        brain.Hits.RemoveAtSwapBack(i);
                        brain.Identities.RemoveAtSwapBack(i);
                    }
                    else
                    {
                        i++;
                    }
                }
            }

            private static float Compensate(float score, ref float factor)
            {
                return score + (((1.0f - score) * factor) * score);
            }
        }

        struct ActorBrainResponseJob : IJobForEachWithEntity<ActorDecision, Translation>
        {
            public EntityCommandBuffer.Concurrent CommandBuffer;

            [ReadOnly] public NativeArray<Decision> Responses;

            [ReadOnly] public ComponentDataFromEntity<Health> Healths;
            [ReadOnly] public ComponentDataFromEntity<Translation> Positions;

            public void Execute(Entity entity, int index, [ReadOnly] ref ActorDecision brain, [ReadOnly] ref Translation myPosition)
            {
                var response = Responses[brain.Decision];

                switch (response.Type)
                {
                    case DecisionType.StayInPlace:
                        CommandBuffer.RemoveComponent(index, entity, typeof(Moving));
                        break;
                    case DecisionType.MoveToEntity:
                        CommandBuffer.AddComponent(index, entity, new Moving());
                        CommandBuffer.SetComponent(index, entity, new MoveTo { Target = Positions[response.Params.Entity].Value });
                        break;
                    case DecisionType.FleeToSafeSpot:
                        float3 heading = Positions[brain.Target].Value - myPosition.Value;
                        heading.y = 0;

                        float3 target = myPosition.Value + -heading * 5f;
                        CommandBuffer.AddComponent(index, entity, new Moving());
                        CommandBuffer.SetComponent(index, entity, new MoveTo { Target = target });
                        break;
                    case DecisionType.FollowEntity:
                        CommandBuffer.AddComponent(index, entity, new Moving());
                        CommandBuffer.SetComponent(index, entity, new MoveTo { Target = Positions[brain.Target].Value });
                        break;
                }
            }
        }

        public EvaluatorBacklog Backlog;

        public EndInitializationEntityCommandBufferSystem EndInitializationSystem;

        public BuildPhysicsWorld PhysicSystem;

        protected override void OnCreate()
        {
            PhysicSystem = World.GetOrCreateSystem<BuildPhysicsWorld>();

            EndInitializationSystem = World.GetOrCreateSystem<EndInitializationEntityCommandBufferSystem>();
        }

        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var healthsFromEntity = GetComponentDataFromEntity<Health>(true);
            var positionsFromEntity = GetComponentDataFromEntity<Translation>(true);

            inputDeps = new ActorBrainScoreJob
            {
                CollisionWorld = PhysicSystem.PhysicsWorld.CollisionWorld,
             
                Evaluators = Backlog.Evaluators,
                Considerations = Backlog.Considerations,

                Healths = healthsFromEntity,
                Positions = positionsFromEntity
            }.Schedule(this, inputDeps);

            inputDeps = new ActorBrainResponseJob
            {
                CommandBuffer = EndInitializationSystem.CreateCommandBuffer().ToConcurrent(),

                Responses = Backlog.Responses,

                Healths = healthsFromEntity,
                Positions = positionsFromEntity
            }.Schedule(this, inputDeps);

            EndInitializationSystem.AddJobHandleForProducer(inputDeps);

            return inputDeps;
        }

        protected override void OnDestroy()
        {
            Backlog.Dispose();
        }

        public void SetEvaluator(List<DecisionEvaluator> evaluators, List<Decision> responses, List<Consideration> considerations)
        {
            Backlog = new EvaluatorBacklog
            {
                Evaluators = new NativeArray<DecisionEvaluator>(evaluators.ToArray(), Allocator.Persistent),
                Considerations = new NativeArray<Consideration>(considerations.ToArray(), Allocator.Persistent),
                Responses = new NativeArray<Decision>(responses.ToArray(), Allocator.Persistent)
            };
        }
    }


}

I made a demo to showcase the system

dependentgravekinglet

A list of thing I want to change and add right now are:
-Remove all NativeList allocation in job
-Cache the raycast between entity
-Add a Influence Map

Feedback are welcome and if you made your own Utility system, I would like to know what you did

Topic		Replies	Views
IJobForEach.Schedule(ComponentSystemBase) did not work correctly (p31) Unity Engine Entities , com_unity_entities	8	1615	July 31, 2019
Unit testing parallel scheduled jobs? Unity Engine Entities , com_unity_entities	1	1706	July 28, 2020
Make Job/Entities available everywhere. Unity Engine Entities , com_unity_entities	4	893	July 31, 2020
Error with IJobForEach Unity Engine Entities , com_unity_entities	3	1022	May 2, 2019
false alert of `EntityCommandBuffer` in multiple jobs of one system? Unity Engine Entities , com_unity_entities	2	1273	March 23, 2020

Schedule Job Error and Utility AI

Related topics