Add LinkedGameObjectMap API (#1013)

Author: Jamie Brynes

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### Added
+
+- Added the `LinkedGameObjectMap` class for finding the `GameObject`(s) linked with a specified `EntityId`. [#1013](https://github.com/spatialos/gdk-for-unity/pull/1013)
+    - This can be used with the `[Require]` annotation to inject it into your `MonoBehaviours` provided you are using the `GameObjectCreation` feature module. For example: `[Require] private LinkedGameObjectMap gameObjectMap;`
+
 ### Internal
 
 - Stopped throwing a `Test Exception` in playground.

workers/unity/Packages/com.improbable.gdk.core/Subscriptions/EntityGameObjectLinker.cs

@@ -15,7 +15,7 @@ public class EntityGameObjectLinker
         private readonly EntityManager entityManager;
         private readonly World world;
 
-        private readonly Dictionary<EntityId, List<GameObject>> entityIdToGameObjects =
+        internal readonly Dictionary<EntityId, List<GameObject>> EntityIdToGameObjects =
             new Dictionary<EntityId, List<GameObject>>();
 
         private readonly Dictionary<GameObject, List<RequiredSubscriptionsInjector>> gameObjectToInjectors =
@@ -66,10 +66,10 @@ public void LinkGameObjectToSpatialOSEntity(EntityId entityId, GameObject gameOb
                     $"GameObject is already linked to the entity with ID {linkedComponent.EntityId}");
             }
 
-            if (!entityIdToGameObjects.TryGetValue(entityId, out var linkedGameObjects))
+            if (!EntityIdToGameObjects.TryGetValue(entityId, out var linkedGameObjects))
             {
                 linkedGameObjects = new List<GameObject>();
-                entityIdToGameObjects.Add(entityId, linkedGameObjects);
+                EntityIdToGameObjects.Add(entityId, linkedGameObjects);
             }
 
             linkedGameObjects.Add(gameObject);
@@ -116,7 +116,7 @@ public void UnlinkGameObjectFromEntity(EntityId entityId, GameObject gameObject)
                 throw new ArgumentException($"Can not unlink null GameObject from entity {entityId}");
             }
 
-            if (!entityIdToGameObjects.TryGetValue(entityId, out var gameObjectSet) ||
+            if (!EntityIdToGameObjects.TryGetValue(entityId, out var gameObjectSet) ||
                 !gameObjectSet.Contains(gameObject))
             {
                 throw new ArgumentException(
@@ -155,13 +155,13 @@ public void UnlinkGameObjectFromEntity(EntityId entityId, GameObject gameObject)
             gameObjectSet.Remove(gameObject);
             if (gameObjectSet.Count == 0)
             {
-                entityIdToGameObjects.Remove(entityId);
+                EntityIdToGameObjects.Remove(entityId);
             }
         }
 
         public void UnlinkAllGameObjects()
         {
-            var ids = entityIdToGameObjects.Keys.ToArray();
+            var ids = EntityIdToGameObjects.Keys.ToArray();
             foreach (var id in ids)
             {
                 UnlinkAllGameObjectsFromEntityId(id);
@@ -170,7 +170,7 @@ public void UnlinkAllGameObjects()
 
         public void UnlinkAllGameObjectsFromEntityId(EntityId entityId)
         {
-            if (!entityIdToGameObjects.TryGetValue(entityId, out var gameObjectSet))
+            if (!EntityIdToGameObjects.TryGetValue(entityId, out var gameObjectSet))
             {
                 return;
             }

workers/unity/Packages/com.improbable.gdk.core/Subscriptions/LinkedGameObjectMap.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using Improbable.Gdk.Core;
+using UnityEngine;
+
+namespace Improbable.Gdk.Subscriptions
+{
+    /// <summary>
+    ///     Represents the mapping between SpatialOS entity IDs and linked GameObjects.
+    /// </summary>
+    public class LinkedGameObjectMap
+    {
+        private readonly EntityGameObjectLinker linker;
+
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="LinkedGameObjectMap"/> class backed with the data from
+        ///     the specified <see cref="EntityGameObjectLinker"/>.
+        /// </summary>
+        /// <param name="linker">The linker which contains the backing data for this map.</param>
+        public LinkedGameObjectMap(EntityGameObjectLinker linker)
+        {
+            this.linker = linker;
+        }
+
+        /// <summary>
+        ///     Gets the GameObjects that are linked to a given SpatialOS entity ID.
+        /// </summary>
+        /// <param name="entityId">The entity ID to get GameObjects for.</param>
+        /// <returns>A readonly list of the linked GameObjects or null if there are none linked.</returns>
+        public IReadOnlyList<GameObject> GetLinkedGameObjects(EntityId entityId)
+        {
+            return linker.EntityIdToGameObjects.TryGetValue(entityId, out var goList) ? goList.AsReadOnly() : null;
+        }
+
+        /// <summary>
+        ///     Tries to get the GameObjects that are linked to a given SpatialOS entity ID.
+        /// </summary>
+        /// <param name="entityId">The entity ID to get GameObjects for.</param>
+        /// <param name="linkedGameObjects">
+        ///     When this method returns, contains the GameObjects linked to the specified <see cref="EntityId"/>,
+        ///     if any are linked; otherwise, null. This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>True, if there are any GameObjects linked to the <see cref="EntityId"/>; otherwise false</returns>
+        public bool TryGetLinkedGameObjects(EntityId entityId, out IReadOnlyList<GameObject> linkedGameObjects)
+        {
+            linkedGameObjects = GetLinkedGameObjects(entityId);
+            return linkedGameObjects != null;
+        }
+    }
+}

workers/unity/Packages/com.improbable.gdk.core/Subscriptions/LinkedGameObjectMap.cs.meta

@@ -14,12 +14,12 @@ namespace Improbable.Gdk.GameObjectCreation
     [UpdateInGroup(typeof(GameObjectInitializationGroup))]
     internal class GameObjectInitializationSystem : ComponentSystem
     {
+        internal EntityGameObjectLinker Linker;
+
         private readonly IEntityGameObjectCreator gameObjectCreator;
 
         private readonly GameObject workerGameObject;
 
-        private EntityGameObjectLinker linker;
-
         private EntitySystem entitySystem;
         private WorkerSystem workerSystem;
 
@@ -36,17 +36,17 @@ protected override void OnCreate()
             entitySystem = World.GetExistingSystem<EntitySystem>();
             workerSystem = World.GetExistingSystem<WorkerSystem>();
 
-            linker = new EntityGameObjectLinker(World);
+            Linker = new EntityGameObjectLinker(World);
 
             if (workerGameObject != null)
             {
-                linker.LinkGameObjectToSpatialOSEntity(new EntityId(0), workerGameObject);
+                Linker.LinkGameObjectToSpatialOSEntity(new EntityId(0), workerGameObject);
             }
         }
 
         protected override void OnDestroy()
         {
-            linker.UnlinkAllGameObjects();
+            Linker.UnlinkAllGameObjects();
 
             foreach (var entityId in entitySystem.GetEntitiesInView())
             {
@@ -61,16 +61,16 @@ protected override void OnUpdate()
             foreach (var entityId in entitySystem.GetEntitiesAdded())
             {
                 workerSystem.TryGetEntity(entityId, out var entity);
-                gameObjectCreator.OnEntityCreated(new SpatialOSEntity(entity, EntityManager), linker);
+                gameObjectCreator.OnEntityCreated(new SpatialOSEntity(entity, EntityManager), Linker);
             }
 
             var removedEntities = entitySystem.GetEntitiesRemoved();
             foreach (var entityId in removedEntities)
             {
-                linker.UnlinkAllGameObjectsFromEntityId(entityId);
+                Linker.UnlinkAllGameObjectsFromEntityId(entityId);
             }
 
-            linker.FlushCommandBuffer();
+            Linker.FlushCommandBuffer();
 
             foreach (var entityId in removedEntities)
             {

workers/unity/Packages/com.improbable.gdk.gameobjectcreation/GameObjectInitializationSystem.cs

@@ -0,0 +1,42 @@
+using Improbable.Gdk.Core;
+using Improbable.Gdk.Subscriptions;
+using Unity.Entities;
+
+namespace Improbable.Gdk.GameObjectCreation
+{
+    [AutoRegisterSubscriptionManager]
+    internal class LinkedGameObjectMapSubscriptionManager : SubscriptionManager<LinkedGameObjectMap>
+    {
+        private readonly World world;
+        private Subscription<LinkedGameObjectMap> linkedGameObjectMapSubscription;
+
+        public LinkedGameObjectMapSubscriptionManager(World world)
+        {
+            this.world = world;
+        }
+
+        public override Subscription<LinkedGameObjectMap> Subscribe(EntityId entityId)
+        {
+            if (linkedGameObjectMapSubscription == null)
+            {
+                linkedGameObjectMapSubscription = new Subscription<LinkedGameObjectMap>(this, new EntityId(0));
+
+                var goSystem = world.GetExistingSystem<GameObjectInitializationSystem>();
+                if (goSystem != null)
+                {
+                    linkedGameObjectMapSubscription.SetAvailable(new LinkedGameObjectMap(goSystem.Linker));
+                }
+            }
+
+            return linkedGameObjectMapSubscription;
+        }
+
+        public override void Cancel(ISubscription subscription)
+        {
+        }
+
+        public override void ResetValue(ISubscription subscription)
+        {
+        }
+    }
+}

workers/unity/Packages/com.improbable.gdk.gameobjectcreation/LinkedGameObjectMapSubscriptionManager.cs

@@ -0,0 +1,22 @@
+{
+    "name": "Improbable.Gdk.GameObjectCreation.EditmodeTests",
+    "references": [
+        "GUID:0603bcb6cd766ea40a053a38fff8a84b",
+        "GUID:edb3612c44ad0d24988d387581fd5fbe",
+        "GUID:6e87be7cacbd7264c9a5b9efc59a4030",
+        "GUID:734d92eba21c94caba915361bd5ac177"
+    ],
+    "optionalUnityReferences": [
+        "TestAssemblies"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}