trail-into-darkness/Packages/com.jovian.encounter-system/Runtime/EncounterTable.cs

using System;
using System.Collections.Generic;
using UnityEngine;

namespace Jovian.EncounterSystem {
    [CreateAssetMenu(fileName = "EncounterTable", menuName = "Jovian/Encounter System/Encounter Table", order = 1)]
    public class EncounterTable : ScriptableObject {
        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.GetValueOrDefault(internalId);
        }

        /// <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;
            }

            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(var 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;
            }
            if(filter == null) {
                return GetRandomEncounter();
            }

            IEncounter selected = null;
            var seen = 0;
            for(var 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;
            }

            idCache = new Dictionary<string, Encounter>(encounters?.Count ?? 0);
            if(encounters == null) {
                return;
            }

            for(var 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>(encounters.Count);
            var changed = false;
            for(int i = 0; i < encounters.Count; i++) {
                var encounter = encounters[i];
                if(encounter?.EncounterDefinition == null) {
                    continue;
                }

                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;
                }
            }

            if(changed) {
                UnityEditor.EditorUtility.SetDirty(this);
            }
        }
#endif
    }
}