Optimizations

Runtime/EncounterTable.cs

@@ -8,6 +8,24 @@ namespace Jovian.EncounterSystem {
         public string id;
         public List<Encounter> encounters;
 
+        private Dictionary<string, Encounter> idCache;
+
+        /// <summary>O(1) lookup by <see cref="EncounterDefinition.internalId"/>. Used by <see cref="EncounterLink"/>.
+        /// Call <see cref="InvalidateCache"/> if you mutate the <see cref="encounters"/> list at runtime.</summary>
+        public IEncounter Resolve(string internalId) {
+            if(string.IsNullOrEmpty(internalId) || encounters == null || encounters.Count == 0) {
+                return null;
+            }
+
+            EnsureCache();
+            return idCache.TryGetValue(internalId, out var encounter) ? encounter : null;
+        }
+
+        /// <summary>Force the id lookup cache to rebuild on next use.</summary>
+        public void InvalidateCache() {
+            idCache = null;
+        }
+
         public IEncounter GetRandomEncounter() {
             if(encounters == null || encounters.Count == 0) {
                 return null;
@@ -16,50 +34,92 @@ namespace Jovian.EncounterSystem {
             return encounters[UnityEngine.Random.Range(0, encounters.Count)];
         }
 
+        /// <summary>Random pick restricted to encounters whose runtime type matches <paramref name="type"/>.
+        /// Zero-alloc — uses reservoir sampling instead of building an intermediate filtered list.</summary>
         public IEncounter GetRandomEncounter(Type type) {
+            if(encounters == null || encounters.Count == 0 || type == null) {
+                return null;
+            }
+
+            IEncounter selected = null;
+            var seen = 0;
+            for(int i = 0; i < encounters.Count; i++) {
+                var encounter = encounters[i];
+                if(encounter == null || encounter.GetType() != type) {
+                    continue;
+                }
+                seen++;
+                if(UnityEngine.Random.Range(0, seen) == 0) {
+                    selected = encounter;
+                }
+            }
+            return selected;
+        }
+
+        /// <summary>Random pick restricted by <paramref name="filter"/>. Used with
+        /// <see cref="QuestProgress.IsGated"/> to exclude gated encounters. Zero-alloc via reservoir sampling.</summary>
+        public IEncounter GetRandomEncounter(Predicate<IEncounter> filter) {
             if(encounters == null || encounters.Count == 0) {
                 return null;
             }
-
-            var encountersOfType = encounters.FindAll(encounter => encounter.GetType() == type);
-            if(encountersOfType.Count > 0) {
-                return encountersOfType[UnityEngine.Random.Range(0, encountersOfType.Count)];
-            }
-
-            return null;
-        }
-
-        /// <summary>Random pick limited by a predicate. Used with <see cref="QuestProgress.IsGated"/> to exclude gated encounters.</summary>
-        public IEncounter GetRandomEncounter(Predicate<IEncounter> filter) {
-            if(encounters == null || encounters.Count == 0 || filter == null) {
+            if(filter == null) {
                 return GetRandomEncounter();
             }
 
-            var pool = encounters.FindAll(filter);
-            if(pool.Count == 0) {
-                return null;
+            IEncounter selected = null;
+            var seen = 0;
+            for(int i = 0; i < encounters.Count; i++) {
+                var encounter = encounters[i];
+                if(encounter == null || !filter(encounter)) {
+                    continue;
+                }
+                seen++;
+                if(UnityEngine.Random.Range(0, seen) == 0) {
+                    selected = encounter;
+                }
+            }
+            return selected;
+        }
+
+        private void EnsureCache() {
+            if(idCache != null) {
+                return;
             }
 
-            return pool[UnityEngine.Random.Range(0, pool.Count)];
+            idCache = new Dictionary<string, Encounter>(encounters?.Count ?? 0);
+            if(encounters == null) {
+                return;
+            }
+
+            for(int i = 0; i < encounters.Count; i++) {
+                var encounter = encounters[i];
+                var internalId = encounter?.EncounterDefinition?.internalId;
+                if(!string.IsNullOrEmpty(internalId)) {
+                    idCache[internalId] = encounter;
+                }
+            }
         }
 
 #if UNITY_EDITOR
         // Unity's inspector "+" duplicates the previous list element, including nested internalId
         // GUIDs. Regenerate any duplicates so every encounter carries a unique internalId.
         private void OnValidate() {
+            InvalidateCache();
+
             if(encounters == null) {
                 return;
             }
 
-            var seen = new HashSet<string>();
+            var seen = new HashSet<string>(encounters.Count);
             var changed = false;
-            foreach(var encounter in encounters) {
+            for(int i = 0; i < encounters.Count; i++) {
+                var encounter = encounters[i];
                 if(encounter?.EncounterDefinition == null) {
                     continue;
                 }
 
-                var id = encounter.EncounterDefinition.internalId;
-                if(string.IsNullOrEmpty(id) || !seen.Add(id)) {
+                var entryId = encounter.EncounterDefinition.internalId;
+                if(string.IsNullOrEmpty(entryId) || !seen.Add(entryId)) {
                     encounter.EncounterDefinition.internalId = Guid.NewGuid().ToString();
                     seen.Add(encounter.EncounterDefinition.internalId);
                     changed = true;