feat: Implement mutually exclusive quests

Some world quests should not be rolled and active at the same time.
Allow a way for these dependencies to be described and give the user
a way to override the list via the GameServerSettings.csx. Then on party
create and instance reset when the party rolled world quest list is generated/updated,
enforce those restrictions for the party.

Author: pacampbell

Arrowgene.Ddon.GameServer/Quests/QuestStateManager.cs

@@ -838,6 +838,50 @@ 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);
+                    }
+                }
+            }
         }
 
         public override void EnforceInitialPoolEligibility()
@@ -876,9 +920,34 @@ protected override uint GetEffectiveAreaRank(Character character, QuestAreaId ar
 
         protected override Quest RollQuestVariant(QuestId questId)
         {
+            var lookup = BuildMutualExclusionLookup();
+            if (lookup.TryGetValue(questId, out int groupIndex))
+            {
+                var rolledQuestIds = GetRolledQuestIds();
+                var groups = Server.GameSettings.GameServerSettings.MutuallyExclusiveWorldQuestGroups;
+                if (groups[groupIndex].Any(gid => (QuestId)gid != questId && rolledQuestIds.Contains((QuestId)gid)))
+                {
+                    return null;
+                }
+            }
             return RollEligibleQuestVariant(questId, Party.Leader?.Client.Character);
         }
 
+        private HashSet<QuestId> GetRolledQuestIds()
+        {
+            lock (ActiveQuests)
+            {
+                var result = new HashSet<QuestId>();
+                foreach (var scheduleIds in RolledInstanceWorldQuests.Values)
+                    foreach (var sid in scheduleIds)
+                    {
+                        var quest = QuestManager.GetQuestByScheduleId(sid);
+                        if (quest != null) result.Add(quest.QuestId);
+                    }
+                return result;
+            }
+        }
+
         public override bool CompleteQuestProgress(uint questScheduleId, DbConnection? connectionIn = null)
         {
             Quest quest = GetQuest(questScheduleId);

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.