feat: Mutually Excluive Quests

Added a mechanism to define lists of world quests where only one can be
rolled from at a time in the party.

Author: pacampbell

Arrowgene.Ddon.GameServer/Quests/QuestStateManager.cs

@@ -177,7 +177,7 @@ public abstract class QuestStateManager
         protected Dictionary<uint, QuestState> ActiveQuests { get; set; }
         private Dictionary<StageLayoutId, HashSet<uint>> QuestLookupTable { get; set; }
         private List<QuestId> CompletedWorldQuests { get; set; }
-        private Dictionary<QuestAreaId, HashSet<uint>> RolledInstanceWorldQuests { get; set; }
+        protected Dictionary<QuestAreaId, HashSet<uint>> RolledInstanceWorldQuests { get; set; }
 
         // Deferred Generic Work to be triggered at various points
         public Dictionary<QuestProgressWorkType, List<QuestProgressWork>> ProgressWork { get; set; }
@@ -832,10 +832,70 @@ public SharedQuestStateManager(PartyGroup party, DdonGameServer server)
         {
             this.Party = party;
             this.Server = server;
+            EnforceMutualExclusion();
+        }
+
+        private Dictionary<QuestId, int> BuildMutualExclusionLookup()
+        {
+            var lookup = new Dictionary<QuestId, int>();
+            var groups = Server.GameSettings.GameServerSettings.MutuallyExclusiveWorldQuestGroups;
+            for (int i = 0; i < groups.Count; i++)
+            {
+                foreach (var questId in groups[i])
+                {
+                    lookup[(QuestId)questId] = i;
+                }
+            }
+            return lookup;
+        }
+
+        private void EnforceMutualExclusion()
+        {
+            var lookup = BuildMutualExclusionLookup();
+            var rolledGroups = new HashSet<int>();
+
+            lock (ActiveQuests)
+            {
+                foreach (var scheduleIds in RolledInstanceWorldQuests.Values)
+                {
+                    var toRemove = new List<uint>();
+                    foreach (var scheduleId in scheduleIds)
+                    {
+                        var quest = QuestManager.GetQuestByScheduleId(scheduleId);
+                        if (quest != null && lookup.TryGetValue(quest.QuestId, out int groupIndex))
+                        {
+                            if (!rolledGroups.Add(groupIndex))
+                            {
+                                toRemove.Add(scheduleId);
+                            }
+                        }
+                    }
+                    foreach (var scheduleId in toRemove)
+                    {
+                        scheduleIds.Remove(scheduleId);
+                    }
+                }
+            }
         }
 
         protected override Quest RollQuestVariant(QuestId questId)
         {
+            var lookup = BuildMutualExclusionLookup();
+            if (lookup.TryGetValue(questId, out int groupIndex))
+            {
+                var groups = Server.GameSettings.GameServerSettings.MutuallyExclusiveWorldQuestGroups;
+                foreach (var groupQuestId in groups[groupIndex])
+                {
+                    if ((QuestId)groupQuestId == questId) continue;
+                    foreach (var scheduleIds in RolledInstanceWorldQuests.Values)
+                    {
+                        if (scheduleIds.Any(sid => QuestManager.GetQuestByScheduleId(sid)?.QuestId == (QuestId)groupQuestId))
+                        {
+                            return null;
+                        }
+                    }
+                }
+            }
             return RollEligibleQuestVariant(questId, Party.Leader?.Client.Character);
         }
 

Arrowgene.Ddon.Server/Settings/GameServerSettings.cs

@@ -257,6 +257,35 @@ public uint AdventureGuideMaxQuestList
         }
         private const uint _AdventureGuideMaxQuestList = 50;
 
+        /// <summary>
+        /// Groups of mutually exclusive world quest IDs. When rolling world quests for a party,
+        /// at most one quest from each group will be selected at a time. Use this to prevent
+        /// conflicting quests from appearing simultaneously. Quest IDs should be specified as
+        /// uint values (e.g. 21000079).
+        /// </summary>
+        [DefaultValue(
+            "new List<List<uint>>\n" +
+            "{\n" +
+            "    new List<uint> { 21000079, 21000089 },\n" +
+            "    new List<uint> { 20995009, 21000008 },\n" +
+            "}"
+        )]
+        public List<List<uint>> MutuallyExclusiveWorldQuestGroups
+        {
+            set
+            {
+                SetSetting("MutuallyExclusiveWorldQuestGroups", value);
+            }
+            get
+            {
+                return TryGetSetting("MutuallyExclusiveWorldQuestGroups", new List<List<uint>>
+                {
+                    new List<uint> { 21000079, 21000089 },
+                    new List<uint> { 20995009, 21000008 },
+                });
+            }
+        }
+
         /// <summary>
         /// Uses the automatic exp calculation system for all enemies instead of just using the
         /// ones marked in quest files.