Merge pull request #414 from MUnique/dev/fix-sets

Fixed item set completion bonuses
MUnique · Jun 8, 2024 · 3ac0828 · 3ac0828
2 parents d59e889 + 2421611
commit 3ac0828
Show file tree

Hide file tree

Showing 18 changed files with 10,105 additions and 75 deletions.
diff --git a/src/DataModel/Configuration/Items/ItemSetGroup.cs b/src/DataModel/Configuration/Items/ItemSetGroup.cs
@@ -5,6 +5,7 @@
 namespace MUnique.OpenMU.DataModel.Configuration.Items;
 
 using MUnique.OpenMU.Annotations;
+using MUnique.OpenMU.DataModel.Entities;
 
 /// <summary>
 /// Defines an item set group. With (partial) completion of the set, additional options are getting applied.
@@ -28,8 +29,9 @@ public partial class ItemSetGroup
     public string Name { get; set; } = string.Empty;
 
     /// <summary>
-    /// Gets or sets a value indicating whether all of the options of this item set always apply.
-    /// If not, the minimum item count and the minimum set levels are respected.
+    /// Gets or sets a value indicating whether the options of this item set always apply to an item,
+    /// even if the group wasn't explicitly added to the <see cref="Item.ItemSetGroups"/>.
+    /// The minimum item count and the minimum set levels are respected.
     /// </summary>
     public bool AlwaysApplies { get; set; }
 
@@ -57,8 +59,7 @@ public partial class ItemSetGroup
     /// <remarks>
     /// The order is defined by <see cref="ItemOption.Number"/>.
     /// </remarks>
-    [MemberOfAggregate]
-    public virtual ICollection<IncreasableItemOption> Options { get; protected set; } = null!;
+    public virtual ItemOptionDefinition? Options { get; set; } = null!;
 
     /// <summary>
     /// Gets or sets the items of this set.

diff --git a/src/DataModel/GameConfigurationHelper.cs b/src/DataModel/GameConfigurationHelper.cs
@@ -34,7 +34,6 @@ public static class GameConfigurationHelper
         { typeof(ItemOptionDefinition), c => c.ItemOptions },
         {
             typeof(IncreasableItemOption), c => c.ItemOptions.SelectMany(o => o.PossibleOptions)
-                .Concat(c.ItemSetGroups.SelectMany(o => o.Options))
         },
         { typeof(ItemSetGroup), c => c.ItemSetGroups },
         { typeof(ItemOfItemSet), c => c.ItemSetGroups.SelectMany(o => o.Items) },

diff --git a/src/GameLogic/DefaultDropGenerator.cs b/src/GameLogic/DefaultDropGenerator.cs
@@ -42,7 +42,7 @@ public DefaultDropGenerator(GameConfiguration config, IRandomizer randomizer)
     {
         this._randomizer = randomizer;
         this._droppableItems = config.Items.Where(i => i.DropsFromMonsters).ToList();
-        this._ancientItems = this._droppableItems.Where(i => i.PossibleItemSetGroups.Any(o => o.Options.Any(o => o.OptionType == ItemOptionTypes.AncientOption))).ToList();
+        this._ancientItems = this._droppableItems.Where(i => i.PossibleItemSetGroups.Any(o => o.Options?.PossibleOptions.Any(o => o.OptionType == ItemOptionTypes.AncientOption) ?? false)).ToList();
     }
 
     /// <inheritdoc/>
@@ -327,7 +327,7 @@ private static bool IsGroupRelevant(MonsterDefinition monsterDefinition, DropIte
 
     private void ApplyRandomAncientOption(Item item)
     {
-        var ancientSet = item.Definition?.PossibleItemSetGroups.Where(g => g!.Options.Any(o => o.OptionType == ItemOptionTypes.AncientOption)).SelectRandom(this._randomizer);
+        var ancientSet = item.Definition?.PossibleItemSetGroups.Where(g => g!.Options?.PossibleOptions.Any(o => o.OptionType == ItemOptionTypes.AncientOption) ?? false).SelectRandom(this._randomizer);
         if (ancientSet is null)
         {
             return;

diff --git a/src/GameLogic/ItemPowerUpFactory.cs b/src/GameLogic/ItemPowerUpFactory.cs
@@ -78,17 +78,14 @@ public IEnumerable<PowerUpWrapper> GetSetPowerUps(
             .Distinct();
 
         var result = Enumerable.Empty<PowerUpDefinition>();
-        foreach (var group in itemGroups)
-        {
-            if (group.AlwaysApplies)
-            {
-                result = result.Concat(group.Options.Select(o => o.PowerUpDefinition ?? throw Error.NotInitializedProperty(o, nameof(o.PowerUpDefinition))));
-
-                continue;
-            }
+        var alwaysGroups = activeItems.SelectMany(i => i.Definition!.PossibleItemSetGroups).Where(i => i.AlwaysApplies).Distinct();
 
-            var itemsOfGroup = activeItems.Where(i => i.ItemSetGroups.Any(ios => ios.ItemSetGroup == group)
-                                                      && (group.SetLevel == 0 || i.Level >= group.SetLevel));
+        foreach (var group in alwaysGroups.Concat(itemGroups).Distinct())
+        {
+            var itemsOfGroup = activeItems.Where(i =>
+                ((group.AlwaysApplies && i.Definition!.PossibleItemSetGroups.Contains(group))
+                 || i.ItemSetGroups.Any(ios => ios.ItemSetGroup == group))
+                && (group.SetLevel == 0 || i.Level >= group.SetLevel));
             var setMustBeComplete = group.MinimumItemCount == group.Items.Count;
             if (group.SetLevel > 0 && setMustBeComplete && itemsOfGroup.All(i => i.Level > group.SetLevel))
             {
@@ -97,19 +94,27 @@ public IEnumerable<PowerUpWrapper> GetSetPowerUps(
                 continue;
             }
 
+            if (group.Options is not { } options)
+            {
+                this._logger.LogWarning("Options of set {group} is not initialized", group);
+                continue;
+            }
+
             var itemCount = group.CountDistinct ? itemsOfGroup.Select(item => item.Definition).Distinct().Count() : itemsOfGroup.Count();
             var setIsComplete = itemCount == group.Items.Count;
             if (setIsComplete)
             {
                 // Take all options when the set is complete
-                result = result.Concat(group.Options.Select(o => o.PowerUpDefinition ?? throw Error.NotInitializedProperty(o, nameof(o.PowerUpDefinition))));
+                result = result.Concat(
+                    options.PossibleOptions
+                        .Select(o => o.PowerUpDefinition ?? throw Error.NotInitializedProperty(o, nameof(o.PowerUpDefinition))));
                 continue;
             }
 
             if (itemCount >= group.MinimumItemCount)
             {
                 // Take the first n-1 options
-                result = result.Concat(group.Options.OrderBy(o => o.Number)
+                result = result.Concat(options.PossibleOptions.OrderBy(o => o.Number)
                     .Take(itemCount - 1)
                     .Select(o => o.PowerUpDefinition ?? throw Error.NotInitializedProperty(o, nameof(o.PowerUpDefinition))));
             }

diff --git a/src/GameServer/RemoteView/IItemSerializer.cs b/src/GameServer/RemoteView/IItemSerializer.cs
@@ -305,7 +305,7 @@ private static void ReadAncientOption(byte ancientByte, IContext persistenceCont
         var bonusLevel = (ancientByte & AncientBonusLevelMask) >> 2;
         var setDiscriminator = ancientByte & AncientDiscriminatorMask;
         var ancientSets = item.Definition!.PossibleItemSetGroups
-            .Where(set => set.Options.Any(o => o.OptionType == ItemOptionTypes.AncientOption))
+            .Where(set => set.Options?.PossibleOptions.Any(o => o.OptionType == ItemOptionTypes.AncientOption) ?? false)
             .SelectMany(i => i.Items).Where(i => i.ItemDefinition == item.Definition)
             .Where(set => set.AncientSetDiscriminator == setDiscriminator).ToList();
         if (ancientSets.Count > 1)

diff --git a/src/Persistence/BasicModel/ItemSetGroup.Generated.cs b/src/Persistence/BasicModel/ItemSetGroup.Generated.cs
@@ -25,27 +25,6 @@ public partial class ItemSetGroup : MUnique.OpenMU.DataModel.Configuration.Items
     /// </summary>
     public Guid Id { get; set; }
 
-    /// <summary>
-    /// Gets the raw collection of <see cref="Options" />.
-    /// </summary>
-    [System.Text.Json.Serialization.JsonPropertyName("options")]
-    public ICollection<IncreasableItemOption> RawOptions { get; } = new List<IncreasableItemOption>();
-
-    /// <inheritdoc/>
-    [System.Text.Json.Serialization.JsonIgnore]
-    public override ICollection<MUnique.OpenMU.DataModel.Configuration.Items.IncreasableItemOption> Options
-    {
-        get => base.Options ??= new CollectionAdapter<MUnique.OpenMU.DataModel.Configuration.Items.IncreasableItemOption, IncreasableItemOption>(this.RawOptions);
-        protected set
-        {
-            this.Options.Clear();
-            foreach (var item in value)
-            {
-                this.Options.Add(item);
-            }
-        }
-    }
-
     /// <summary>
     /// Gets the raw collection of <see cref="Items" />.
     /// </summary>
@@ -67,6 +46,24 @@ protected set
         }
     }
 
+    /// <summary>
+    /// Gets the raw object of <see cref="Options" />.
+    /// </summary>
+    [System.Text.Json.Serialization.JsonPropertyName("options")]
+    public ItemOptionDefinition RawOptions
+    {
+        get => base.Options as ItemOptionDefinition;
+        set => base.Options = value;
+    }
+
+    /// <inheritdoc/>
+    [System.Text.Json.Serialization.JsonIgnore]
+    public override MUnique.OpenMU.DataModel.Configuration.Items.ItemOptionDefinition Options
+    {
+        get => base.Options;
+        set => base.Options = value;
+    }
+
     /// <inheritdoc />
     public override MUnique.OpenMU.DataModel.Configuration.Items.ItemSetGroup Clone(MUnique.OpenMU.DataModel.Configuration.GameConfiguration gameConfiguration)
     {

diff --git a/src/Persistence/EntityFramework/CachingRepositoryProvider.cs b/src/Persistence/EntityFramework/CachingRepositoryProvider.cs
@@ -59,8 +59,9 @@ protected override void Initialize()
 
         this.RegisterRepository(new ConfigurationTypeRepository<ItemOptionDefinition>(this._parent, this.LoggerFactory, config => config.RawItemOptions));
         this.RegisterRepository(new ConfigurationTypeRepository<IncreasableItemOption>(
-            this._parent, this.LoggerFactory,
-            config => config.RawItemOptions.SelectMany(o => o.RawPossibleOptions).Concat(config.RawItemSetGroups.SelectMany(g => g.RawOptions)).Distinct().ToList()));
+            this._parent,
+            this.LoggerFactory,
+            config => config.RawItemOptions.SelectMany(o => o.RawPossibleOptions).Distinct().ToList()));
         this.RegisterRepository(new ConfigurationTypeRepository<AttributeDefinition>(this._parent, this.LoggerFactory, config => config.RawAttributes));
         this.RegisterRepository(new ConfigurationTypeRepository<DropItemGroup>(this._parent, this.LoggerFactory, config => config.RawDropItemGroups));
         this.RegisterRepository(new ConfigurationTypeRepository<CharacterClass>(this._parent, this.LoggerFactory, config => config.RawCharacterClasses));