Add worker flag reader (#898)

Author: jamiebrynes7

CHANGELOG.md

@@ -18,6 +18,10 @@
 - Added a `Improbable.Gdk.Core.Collections.Result<T, E>` struct to represent a result which can either contain a value `T` or an error `E`.
 - Added Scripting Define Symbol `DISABLE_REACTIVE_COMPONENTS`. Using this symbol will disable all reactive componts and systems.
     - Currently not compatible with the FPS Starter Project.
+- Added a `WorkerFlagReader` which you can subscribe and `Require`. This allows you to:
+    - Add callbacks for changes to worker flags.
+    - Read the value of worker flags.
+- Expose `GetWorkerFlag(string name)` on the `View`.
 
 ### Changed
 
@@ -35,6 +39,7 @@
 - Tools package now uses PackageManager API instead of parsing manifest.json.
 - Updated default snapshot to have more than one PlayerCreator entity.
 - Fixed package dependencies.
+- Worker flag changes are propagated to the `ViewDiff`.
 
 ## `0.2.0` - 2019-03-18
 

default_launch.json

@@ -42,6 +42,12 @@
         {
           "all": {}
         }
+      ],
+      "flags": [
+        {
+          "name": "my_flag",
+          "value": "has_a_value"
+        }
       ]
     },
     {

test-project/Assets/EditmodeTests/Subscriptions/ReaderWriter/InjectionCriteriaTests.cs

@@ -33,6 +33,7 @@ public void Setup()
             world.CreateManager<WorkerSystem>(connectionHandler, null,
                 new LoggingDispatcher(), "TestWorkerType", Vector3.zero);
             receiveSystem = world.CreateManager<SpatialOSReceiveSystem>();
+            world.GetOrCreateManager<WorkerFlagCallbackSystem>();
             world.GetOrCreateManager<ComponentUpdateSystem>();
             world.GetOrCreateManager<ComponentConstraintsCallbackSystem>();
             world.CreateManager<SubscriptionSystem>();

workers/unity/Assets/Playground/Resources/Prefabs/Common/Character.prefab

@@ -15,6 +15,7 @@ GameObject:
   - component: {fileID: 114079189423237002}
   - component: {fileID: 114894172867123548}
   - component: {fileID: 114602415406350378}
+  - component: {fileID: 2643701918418317171}
   m_Layer: 9
   m_Name: Character
   m_TagString: Untagged
@@ -125,6 +126,18 @@ MonoBehaviour:
   - {fileID: 11400000, guid: f744e75b6283f6d48ad23018d67547ed, type: 2}
   - {fileID: 11400000, guid: ea6888e42dd86884891ba6f89a8df6be, type: 2}
   SetKinematicWhenNotAuthoritative: 1
+--- !u!114 &2643701918418317171
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1292271339760838}
+  m_Enabled: 0
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0d4dfc82aab7b1d43b523a4a5172d6f8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
 --- !u!1 &1494660013534148
 GameObject:
   m_ObjectHideFlags: 0

workers/unity/Assets/Playground/Scripts/MonoBehaviours/WorkerFlagTest.cs

@@ -0,0 +1,20 @@
+using Improbable.Gdk.Core;
+using Improbable.Gdk.Subscriptions;
+using UnityEngine;
+
+namespace Playground
+{
+    [WorkerType(WorkerUtils.UnityGameLogic)]
+    public class WorkerFlagTest : MonoBehaviour
+    {
+        [Require] private WorkerFlagReader workerFlagReader;
+
+        private void OnEnable()
+        {
+            workerFlagReader.OnWorkerFlagChange += (name, value) =>
+            {
+                Debug.Log($"Worker flag change detected: {name} with value {value}");
+            };
+        }
+    }
+}

workers/unity/Assets/Playground/Scripts/MonoBehaviours/WorkerFlagTest.cs.meta

@@ -0,0 +1,40 @@
+using System;
+using Improbable.Gdk.Core;
+using Unity.Entities;
+
+namespace Improbable.Gdk.Subscriptions
+{
+    public class WorkerFlagCallbackManager : ICallbackManager
+    {
+        private readonly Callbacks<(string, string)> callbacks = new Callbacks<(string, string)>();
+        private readonly WorkerSystem workerSystem;
+
+        private ulong nextCallbackId = 1;
+
+        public WorkerFlagCallbackManager(World world)
+        {
+            workerSystem = world.GetExistingManager<WorkerSystem>();
+        }
+
+        public ulong RegisterCallback(Action<(string, string)> callback)
+        {
+            callbacks.Add(nextCallbackId, callback);
+            return nextCallbackId++;
+        }
+
+        public bool UnregisterCallback(ulong callbackKey)
+        {
+            return callbacks.Remove(callbackKey);
+        }
+
+        public void InvokeCallbacks()
+        {
+            var workerFlagChanges = workerSystem.Diff.GetWorkerFlagChanges();
+            for (int i = 0; i < workerFlagChanges.Count; ++i)
+            {
+                var pair = workerFlagChanges[i];
+                callbacks.InvokeAll(pair);
+            }
+        }
+    }
+}

workers/unity/Packages/com.improbable.gdk.core/Subscriptions/CalllbackManagers/WorkerFlagCallbackManager.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using Improbable.Gdk.Subscriptions;
+using Unity.Entities;
+
+namespace Improbable.Gdk.Core
+{
+    [AutoRegisterSubscriptionManager]
+    public class WorkerFlagSubscriptionManager : SubscriptionManager<WorkerFlagReader>
+    {
+        private World world;
+
+        private HashSet<Subscription<WorkerFlagReader>> readerSubscriptions = new HashSet<Subscription<WorkerFlagReader>>();
+
+        public WorkerFlagSubscriptionManager(World world)
+        {
+            this.world = world;
+        }
+
+        public override void Cancel(ISubscription subscription)
+        {
+            var readerSubscription = (Subscription<WorkerFlagReader>) subscription;
+
+            readerSubscription.Value.IsValid = false;
+            readerSubscription.Value.RemoveAllCallbacks();
+            readerSubscriptions.Remove(readerSubscription);
+        }
+
+        public override void ResetValue(ISubscription subscription)
+        {
+            var readerSubscription = (Subscription<WorkerFlagReader>) subscription;
+
+            readerSubscription.Value.RemoveAllCallbacks();
+        }
+
+        public override Subscription<WorkerFlagReader> Subscribe(EntityId entityId)
+        {
+            var subscription = new Subscription<WorkerFlagReader>(this, new EntityId(0));
+            readerSubscriptions.Add(subscription);
+
+            subscription.SetAvailable(new WorkerFlagReader(world));
+
+            return subscription;
+        }
+    }
+
+    public class WorkerFlagReader
+    {
+        public bool IsValid;
+
+        private readonly WorkerFlagCallbackSystem callbackSystem;
+        private readonly View view;
+
+        private Dictionary<Action<string, string>, ulong> callbackToKey;
+
+        public WorkerFlagReader(World world)
+        {
+            IsValid = true;
+            callbackSystem = world.GetExistingManager<WorkerFlagCallbackSystem>();
+            view = world.GetExistingManager<WorkerSystem>().View;
+        }
+
+        public event Action<string, string> OnWorkerFlagChange
+        {
+            add
+            {
+                if (callbackToKey == null)
+                {
+                    callbackToKey = new Dictionary<Action<string, string>, ulong>();
+                }
+
+                var key = callbackSystem.RegisterWorkerFlagChangeCallback(pair =>
+                {
+                    if (!IsValid)
+                    {
+                        return;
+                    }
+
+                    value(pair.Item1, pair.Item2);
+                });
+
+                callbackToKey.Add(value, key);
+            }
+            remove
+            {
+                if (callbackToKey == null)
+                {
+                    return;
+                }
+
+                if (!callbackToKey.TryGetValue(value, out var key))
+                {
+                    return;
+                }
+
+                callbackSystem.UnregisterWorkerFlagChangeCallback(key);
+                callbackToKey.Remove(value);
+            }
+        }
+
+        public string GetFlag(string name)
+        {
+            return view.GetWorkerFlag(name);
+        }
+
+        internal void RemoveAllCallbacks()
+        {
+            if (callbackToKey == null)
+            {
+                return;
+            }
+
+            foreach (var valuePair in callbackToKey)
+            {
+                callbackSystem.UnregisterWorkerFlagChangeCallback(valuePair.Value);
+            }
+
+            callbackToKey.Clear();
+        }
+    }
+}