made some improvements on how the encounters trigger

Assets/Code/GameState/NoxSaveData.cs

@@ -1,7 +1,10 @@
 using Jovian.SaveSystem;
 using Jovian.InGameLogging;
+using Jovian.EncounterSystem;
 using Nox.Core;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using ZLinq;
 using UnityEngine;
 using PlayMode = Nox.Core.PlayMode;
@@ -36,14 +39,15 @@ namespace Nox.Game {
             gameDataState.activeSessionId = latestSession.sessionId;
             gameDataState.savedPartyPosition = saveData.partyPosition.ToVector3();
             gameDataState.ActiveParty = saveData.activeParty;
-          adventureData.isPartyMoving = saveData.adventureData.isPartyMoving;
+            adventureData.isPartyMoving = saveData.adventureData.isPartyMoving;
             adventureData.isEncounterActive = saveData.adventureData.isEncounterActive;
             adventureData.currentDay = saveData.adventureData.currentDay;
             adventureData.suppliesAvailable = saveData.adventureData.suppliesAvailable;
             adventureData.currentTime = saveData.adventureData.currentTime;
             adventureData.currentDayPhase = saveData.adventureData.currentDayPhase;
-            adventureData.completedEncounterIds.Clear();
             adventureData.completedEncounterIds.AddRange(saveData.adventureData.completedEncounterIds);
+            adventureData.abandonedEncounterIds.AddRange(saveData.adventureData.abandonedEncounterIds ?? Enumerable.Empty<string>());
+            adventureData.questLogEntries.AddRange(saveData.questLogEntries ?? Enumerable.Empty<QuestLogEntry>());
 
             if(gameLogStore != null && saveData.gameLogData != null) {
                 gameLogStore.RestoreFromSaveData(saveData.gameLogData);
@@ -65,6 +69,9 @@ namespace Nox.Game {
         //game mode specific data
         public AdventureData adventureData;
 
+        // Quest progression
+        public List<QuestLogEntry> questLogEntries;
+
         // Party
         public PartyDefinition activeParty;
         public SerializableVector3 partyPosition;

Assets/Code/GameState/PlayModes/AdventurePlayMode.cs

@@ -10,6 +10,7 @@ using Nox.Platform;
 using Nox.Game.UI;
 using Nox.UI;
 using System;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
 using ZLinq;
@@ -25,7 +26,9 @@ namespace Nox.Game {
         public int suppliesAvailable = -1;
         public float currentTime = -1f;
         public DayPhase currentDayPhase = DayPhase.Morning;
-        public List<string> completedEncounterIds = new List<string>();
+        public List<string> completedEncounterIds = new ();
+        public List<string> abandonedEncounterIds = new ();
+        public List<QuestLogEntry> questLogEntries = new ();
     }
 
     public class AdventurePlayMode : IPlayMode {
@@ -85,6 +88,9 @@ namespace Nox.Game {
                 .WaitForCompletion().ActivateAsync().completed += InitializeGameMode;
         }
 
+        private QuestProgress questProgress;
+        private QuestLog questLog;
+
         private void InitializeGameMode(AsyncOperation obj) {
             inputActions.Player.Enable();
             inputActions.UI.PauseMenu.Enable();
@@ -118,18 +124,29 @@ namespace Nox.Game {
                 adventureData.currentTime = 0.25f;
             }
 
+            var collection = encounterRegistry.encounterCollections?.FirstOrDefault(c => c?.encounterTables != null);
+            if(collection != null) {
+                questProgress = new QuestProgress(collection);
+                questLog = new QuestLog(questProgress);
+                if(adventureData.questLogEntries.Count > 0) {
+                    questLog.Restore(adventureData.questLogEntries);
+                    questProgress.LoadResolvedIds(questLog.ResolvedEncounterIds());
+                }
+            }
+
             partyInventoryHandler ??= new PartyInventoryHandler(adventureData, adventureSettings);
             partyInventoryHandler.Initialize();
 
-         var calendarSettings = Addressables.LoadAssetAsync<CalendarSettings>("CalendarSettings").WaitForCompletion();
+       var calendarSettings = Addressables.LoadAssetAsync<CalendarSettings>("CalendarSettings").WaitForCompletion();
             var worldClock = new WorldClock(calendarSettings);
             var totalMinutes = adventureData.currentDay * calendarSettings.MinutesPerDay
                 + (int)(adventureData.currentTime * calendarSettings.MinutesPerDay);
             worldClock.AdvanceMinutes(totalMinutes);
+            worldClock.Tick(adventureData.currentTime);
             timeHandler ??= new TimeHandler(adventureSettings, adventureData, worldClock);
 
             zoneSystem ??= new ZoneSystem(mapRef.zonesObjectHolder);
-            encounterHandler = new EncounterHandler(zoneSystem, encounterRegistry, encounterPrefabs, adventureData);
+            encounterHandler = new EncounterHandler(zoneSystem, encounterRegistry, encounterPrefabs, adventureData, questProgress);
             partyMovementHandler ??= new PartyMovementHandler(
                 partyRef,
                 cameraController,
@@ -190,7 +207,8 @@ namespace Nox.Game {
                 activePlayMode = PlayMode.Adventure,
                 activeParty = partyDefinition,
                 partyPosition = partyRef ? SerializableVector3.FromVector3(partyRef.transform.position) : SerializableVector3.Zero,
-                adventureData = this.adventureData
+                adventureData = this.adventureData,
+                questLogEntries = questLog?.CreateSnapshot() ?? new List<QuestLogEntry>()
             };
         }
 

Assets/Code/GameState/PlayModes/Encounters/EncounterHandler.cs

@@ -9,20 +9,64 @@ namespace Nox.Game {
         private readonly EncounterRegistry encounterRegistry;
         private readonly EncounterView encounterView;
         private readonly AdventureData adventureData;
+        private readonly QuestProgress questProgress;
+        private readonly EncounterResolver resolver;
         private Vector3 lastKnownPosition;
         private string previousZoneId;
         private IEncounter activeEncounter;
         private int lastCheckedDay;
+        private float nextEncounterRollTime;
+        private bool encounterRolledToday;
 
-        public EncounterHandler(ZoneSystem zoneSystem, EncounterRegistry encounterRegistry, EncounterPrefabs encounterPrefabs, AdventureData adventureData) {
+        public EncounterHandler(ZoneSystem zoneSystem, EncounterRegistry encounterRegistry, EncounterPrefabs encounterPrefabs, AdventureData adventureData, QuestProgress questProgress) {
             this.zoneSystem = zoneSystem;
             this.encounterRegistry = encounterRegistry;
             this.adventureData = adventureData;
+            this.questProgress = questProgress;
+            this.resolver = new EncounterResolver();
+            RegisterHandlers();
             encounterView = new EncounterView(encounterPrefabs);
             encounterView.OptionSelected += OnOptionSelected;
             lastCheckedDay = adventureData.currentDay;
         }
 
+        private void RegisterHandlers() {
+            resolver.Register<ChainToEncounterEvent>(HandleChain);
+            resolver.Register<LogEvent>(HandleLog);
+            resolver.Register<AbandonEncounterEvent>(HandleAbandon);
+            resolver.Register<StartCombatEvent>(HandleCombat);
+            resolver.Register<GiveRewardEvent>(HandleReward);
+        }
+
+        private bool HandleChain(ChainToEncounterEvent evt, EncounterContext ctx) {
+            if(encounterRegistry.GetEncounters().TryGetValue(evt.nextEncounterId, out var next)) {
+                RecordEncounterCompleted(activeEncounter);
+                TriggerEncounter(next);
+                return true;
+            }
+            return false;
+        }
+
+        private bool HandleLog(LogEvent evt, EncounterContext ctx) {
+            Debug.Log($"[Encounter '{ctx.CurrentEncounter?.EncounterDefinition?.id}'] {evt.message}");
+            return false;
+        }
+
+        private bool HandleAbandon(AbandonEncounterEvent evt, EncounterContext ctx) {
+            FinishEncounter(abandoned: true);
+            return true;
+        }
+
+        private bool HandleCombat(StartCombatEvent evt, EncounterContext ctx) {
+            Debug.Log($"[Encounter] unhandled event {evt.GetType().Name}");
+            return false;
+        }
+
+        private bool HandleReward(GiveRewardEvent evt, EncounterContext ctx) {
+            Debug.Log($"[Encounter] unhandled event {evt.GetType().Name}");
+            return false;
+        }
+
         public bool AskForRandomEncounter(ZoneContext zoneContext, string encounterTableId, out IEncounter encounter) {
             return ResolveEncounter(zoneContext, encounterTableId, out encounter);
         }
@@ -49,7 +93,7 @@ namespace Nox.Game {
                 return false;
             }
 
-            var filter = new Predicate<IEncounter>(e => e != null && !IsAlreadyCompleted(e));
+            var filter = new Predicate<IEncounter>(e => e != null && !IsAlreadyCompleted(e) && !IsGated(e));
 
             if(encounterKind == null) {
                 encounter = encounterRegistry.GetRandomEncounter(filter, encounterTableId);
@@ -88,9 +132,18 @@ namespace Nox.Game {
                 return false;
             }
 
+            // abandoned non-repeatable encounters are re-triggerable
+            if(adventureData.abandonedEncounterIds.Contains(def.id)) {
+                return false;
+            }
+
             return adventureData.completedEncounterIds.Contains(def.id);
         }
 
+        private bool IsGated(IEncounter encounter) {
+            return questProgress != null && questProgress.IsGated(encounter);
+        }
+
         private void RecordEncounterCompleted(IEncounter encounter) {
             var def = encounter?.EncounterDefinition;
             if(def == null || string.IsNullOrEmpty(def.id)) {
@@ -108,6 +161,19 @@ namespace Nox.Game {
             }
         }
 
+        private void RecordEncounterAbandoned(IEncounter encounter) {
+            var def = encounter?.EncounterDefinition;
+            if(def == null || string.IsNullOrEmpty(def.id)) {
+                return;
+            }
+
+            if(!adventureData.abandonedEncounterIds.Contains(def.id)) {
+                adventureData.abandonedEncounterIds.Add(def.id);
+                Debug.Log($"Recorded abandoned encounter: {def.id}");
+                questProgress?.OnEncounterAbandoned(encounter);
+            }
+        }
+
         private void TrackZoneTransition(Vector3 position) {
             var zoneContext = zoneSystem.QueryZone(position);
             var currentZoneId = zoneContext.resolvedZoneId;
@@ -115,6 +181,9 @@ namespace Nox.Game {
             if(currentZoneId != previousZoneId) {
                 if(!string.IsNullOrEmpty(currentZoneId)) {
                     Debug.Log($"Entered zone: {currentZoneId} (encounter: {zoneContext.encounterTableId}, safe: {zoneContext.isSafe})");
+                    if(!zoneContext.isSafe) {
+                        RollForEncounter(zoneContext);
+                    }
                 }
                 else if(!string.IsNullOrEmpty(previousZoneId)) {
                     Debug.Log($"Left zone: {previousZoneId}");
@@ -123,8 +192,7 @@ namespace Nox.Game {
             }
         }
 
-        private void DailyEncounterCheck(Vector3 position) {
+        private void RollForEncounter(ZoneContext zoneContext) {
-            var zoneContext = zoneSystem.QueryZone(position);
             if(string.IsNullOrEmpty(zoneContext.resolvedZoneId) || zoneContext.isSafe) {
                 return;
             }
@@ -140,14 +208,20 @@ namespace Nox.Game {
                 default:
                     activeEncounter = encounter;
                     adventureData.isEncounterActive = true;
+                    questProgress?.OnEncounterTriggered(encounter);
                     encounterView?.SetCurrentEncounter(encounter);
                     encounterView?.Show();
                     break;
             }
         }
 
-        private void FinishEncounter() {
+        private void FinishEncounter(bool abandoned = false) {
-            RecordEncounterCompleted(activeEncounter);
+            if(abandoned) {
+                RecordEncounterAbandoned(activeEncounter);
+            }
+            else {
+                RecordEncounterCompleted(activeEncounter);
+            }
             encounterView?.Hide();
             activeEncounter = null;
             adventureData.isEncounterActive = false;
@@ -173,30 +247,14 @@ namespace Nox.Game {
                 return;
             }
 
-            for(var i = 0; i < option.events.Count; i++) {
+            var context = new EncounterContext(encounter) {
-                var encounterEvent = option.events[i];
+                Registry = encounterRegistry
-                if(encounterEvent == null) {
+            };
-                    continue;
+            resolver.Resolve(option.events, context);
-                }
-                switch(encounterEvent) {
-                    case ChainToEncounterEvent chain:
-                        if(AskForEncounter(chain.nextEncounterId, out var next)) {
-                            RecordEncounterCompleted(activeEncounter);
-                            TriggerEncounter(next);
-                            return;
-                        }
-                        break;
-                    case LogEvent log:
-                        Debug.Log($"[Encounter '{encounter.EncounterDefinition.id}'] {log.message}");
-                        break;
-                    case StartCombatEvent _:
-                    case GiveRewardEvent _:
-                        Debug.Log($"[Encounter] unhandled event {encounterEvent.GetType().Name}");
-                        break;
-                }
-            }
 
-            FinishEncounter();
+            if(!context.ShouldStopEvents) {
+                FinishEncounter();
+            }
         }
 
         public void CheckForEncounters(Vector3 position) {
@@ -206,8 +264,14 @@ namespace Nox.Game {
 
         public void Tick() {
             if(adventureData.currentDay != lastCheckedDay) {
+                nextEncounterRollTime = UnityEngine.Random.Range(adventureData.currentTime, 1f);
                 lastCheckedDay = adventureData.currentDay;
-                DailyEncounterCheck(lastKnownPosition);
+                encounterRolledToday = false;
+            }
+
+            if(!encounterRolledToday && adventureData.currentTime >= nextEncounterRollTime) {
+                encounterRolledToday = true;
+                RollForEncounter(zoneSystem.QueryZone(lastKnownPosition));
             }
         }
 

Packages/com.jovian.encounter-system/Runtime/EncounterContext.cs

@@ -2,6 +2,10 @@ namespace Jovian.EncounterSystem {
     /// <summary>Per-resolution scratch object passed to every event handler. Extend with fields as handlers need them.</summary>
     public class EncounterContext {
         public IEncounter CurrentEncounter { get; }
+        public EncounterRegistry Registry { get; set; }
+
+        /// <summary>Set to <c>true</c> to halt processing of remaining events.</summary>
+        public bool ShouldStopEvents { get; set; }
 
         public EncounterContext(IEncounter currentEncounter) {
             CurrentEncounter = currentEncounter;

Packages/com.jovian.encounter-system/Runtime/EncounterRegistry.cs

@@ -11,7 +11,9 @@ namespace Jovian.EncounterSystem {
 
         private readonly Dictionary<string, IEncounter> encounters = new();
 
-        public Dictionary<string, IEncounter> GetEncounters() => encounters;
+        public Dictionary<string, IEncounter> GetEncounters() {
+            return encounters;
+        }
 
         public void RegisterEncounter(IEncounter encounter) {
             var id = encounter?.EncounterDefinition?.internalId;
@@ -38,19 +40,19 @@ namespace Jovian.EncounterSystem {
                 return;
             }
 
-            for(int c = 0; c < encounterCollections.Length; c++) {
+            for(var c = 0; c < encounterCollections.Length; c++) {
                 var collection = encounterCollections[c];
                 if(collection?.encounterTables == null) {
                     continue;
                 }
 
-                for(int t = 0; t < collection.encounterTables.Length; t++) {
+                for(var t = 0; t < collection.encounterTables.Length; t++) {
                     var table = collection.encounterTables[t];
                     if(table?.encounters == null) {
                         continue;
                     }
 
-                    for(int i = 0; i < table.encounters.Count; i++) {
+                    for(var i = 0; i < table.encounters.Count; i++) {
                         RegisterEncounter(table.encounters[i]);
                     }
                 }
@@ -67,12 +69,12 @@ namespace Jovian.EncounterSystem {
             return null;
         }
 
-         public IEncounter GetRandomEncounter(string encounterTableId) {
+        public IEncounter GetRandomEncounter(string encounterTableId) {
-             var table = GetEncounterTable(encounterTableId);
+            var table = GetEncounterTable(encounterTableId);
-             if(!table) {
+            if(!table) {
-                 return null;
+                return null;
-             }
+            }
-             var ec = table.encounters;
+            var ec = table.encounters;
             return ec[UnityEngine.Random.Range(0, ec.Count)];
         }
 
@@ -86,7 +88,7 @@ namespace Jovian.EncounterSystem {
 
             IEncounter selected = null;
             var seen = 0;
-            for(var i = 0; i < encounters.Count; i++) {
+            for(var i = 0; i < table.encounters.Count; i++) {
                 var encounter = table.encounters[i];
                 if(encounter == null || encounter.GetType() != encounterKind.GetType()) {
                     continue;

Packages/com.jovian.encounter-system/Runtime/EncounterResolver.cs

@@ -2,13 +2,12 @@ using System;
 using System.Collections.Generic;
 
 namespace Jovian.EncounterSystem {
-    /// <summary>Dispatches <see cref="IEncounterEvent"/> instances to per-type handlers. Unknown types are skipped.</summary>
+    /// <summary>Dispatches <see cref="IEncounterEvent"/> instances to per-type handlers.
+    /// Handlers return <c>true</c> to stop processing remaining events.</summary>
     public class EncounterResolver {
-        private readonly Dictionary<Type, Action<IEncounterEvent, EncounterContext>> handlers = new();
+        private readonly Dictionary<Type, Func<IEncounterEvent, EncounterContext, bool>> handlers = new();
 
-        public void Register<T>(Action<T, EncounterContext> handler) where T : IEncounterEvent {
+        public void Register<T>(Func<T, EncounterContext, bool> handler) where T : IEncounterEvent {
-            // Wrap the typed delegate so the dictionary can hold handlers for any event type uniformly.
-            // Cast is safe because the wrapper is only invoked via lookup under typeof(T).
             handlers[typeof(T)] = (evt, ctx) => handler((T)evt, ctx);
         }
 
@@ -17,22 +16,26 @@ namespace Jovian.EncounterSystem {
         }
 
         /// <summary>Indexed iteration over <paramref name="events"/> — avoids the boxed enumerator
-        /// that an <c>IEnumerable&lt;T&gt;</c> parameter would force. <see cref="EncounterDialogOption.events"/>
+        /// that an <c>IEnumerable&lt;T&gt;</c> parameter would force. Stops when a handler
-        /// is a <c>List</c>, which implements <c>IReadOnlyList</c>, so call sites just pass it directly.</summary>
+        /// returns <c>true</c> or <see cref="EncounterContext.ShouldStopEvents"/> is set.</summary>
         public void Resolve(IReadOnlyList<IEncounterEvent> events, EncounterContext context) {
             if(events == null) {
                 return;
             }
 
             var count = events.Count;
-            for(int i = 0; i < count; i++) {
+            for(var i = 0; i < count; i++) {
                 var evt = events[i];
-                if(evt == null) {
+                if(evt == null || context.ShouldStopEvents) {
                     continue;
                 }
 
-                if(handlers.TryGetValue(evt.GetType(), out var handler)) {
+                if(!handlers.TryGetValue(evt.GetType(), out var handler)) {
-                    handler(evt, context);
+                    continue;
+                }
+
+                if(handler(evt, context)) {
+                    context.ShouldStopEvents = true;
                 }
             }
         }

Packages/com.jovian.encounter-system/Runtime/IEncounterEvent.cs

@@ -24,4 +24,8 @@ namespace Jovian.EncounterSystem {
     public class GiveRewardEvent : IEncounterEvent {
         public Reward reward;
     }
+
+    [Serializable]
+    public class AbandonEncounterEvent : IEncounterEvent {
+    }
 }

Packages/com.jovian.encounter-system/Runtime/QuestProgress.cs

@@ -14,6 +14,7 @@ namespace Jovian.EncounterSystem {
         public event Action<IEncounter> QuestStarted;
         public event Action<IEncounter, IEncounter> QuestAdvanced;
         public event Action<IEncounter> QuestCompleted;
+        public event Action<IEncounter> QuestAbandoned;
 
         public IReadOnlyCollection<string> ResolvedIds => resolvedIds;
 
@@ -76,6 +77,19 @@ namespace Jovian.EncounterSystem {
             }
         }
 
+        public void OnEncounterAbandoned(IEncounter encounter) {
+            if(encounter?.EncounterDefinition.Kind is not QuestKind questKind) {
+                return;
+            }
+
+            var id = encounter.EncounterDefinition?.internalId;
+            if(string.IsNullOrEmpty(id) || !resolvedIds.Remove(id)) {
+                return;
+            }
+
+            QuestAbandoned?.Invoke(encounter);
+        }
+
         public void LoadResolvedIds(IEnumerable<string> ids) {
             resolvedIds.Clear();
             if(ids == null) {