[Add] Universal modifier system, shop, inventory & persistence

Replace hardcoded BonusForOnes/MultiplierForSixes with data-driven
modifier system supporting 2 scopes (SelectedCategory, AnyCategoryClosed),
4 effect types, durability modes (Permanent, LimitedUses), and
configurable targets via ScriptableObject (ModifierData).

- Modifier domain: ModifierEnums, ModifierTarget, ModifierData,
  ModifierRuntime, ModifierEffect (dict-based strategy), ModifierPipeline
  (4-pass: cat-additive → cat-multiplicative → final-additive → final-multiplicative)
- ScoringSystem: replaced old modifier list with ModifierPipeline integration,
  added OnCategoryConfirmed event
- Shop MVC: ShopCatalog (SO), ShopModel, ShopView, ShopItemView, ShopController
- Inventory MVC: InventoryModel (activate/deactivate/sell/durability),
  InventoryView, InventorySlotView, InventoryController
- CurrencyBank: editor-adjustable balance with events
- Persistence: SaveData + SaveSystem (Newtonsoft JSON + PlayerPrefs)
- Editor: ModifierAssetCreator menu item to generate 6 example modifiers + catalog
- Tests: 6 test classes covering effects, pipeline, scoring, shop, inventory, save
- GameController: wired shop/inventory/save lifecycle
- GameInfoView: added currency display, shop/inventory toggle buttons

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Assets/Scripts/Modifiers/BonusForOnes.cs

@@ -1,18 +0,0 @@
-using UnityEngine;
-
-[CreateAssetMenu(fileName = "BonusForOnes", menuName = "YachtDice/Modifiers/Bonus For Ones")]
-public sealed class BonusForOnes : ScoreModifier
-{
-    [SerializeField] private int bonusPerOne = 10;
-
-    public override ModifierPhase Phase => ModifierPhase.Additive;
-
-    public override void Apply(ref ScoreResult result)
-    {
-        int count = 0;
-        for (int i = 0; i < result.DiceValues.Length; i++)
-            if (result.DiceValues[i] == 1) count++;
-
-        result.FlatBonus += bonusPerOne * count;
-    }
-}

Assets/Scripts/Modifiers/ModifierData.cs

@@ -0,0 +1,88 @@
+using UnityEngine;
+
+[CreateAssetMenu(fileName = "NewModifier", menuName = "YachtDice/Modifier Data")]
+public sealed class ModifierData : ScriptableObject
+{
+    [SerializeField] private string id;
+    [SerializeField] private string displayName;
+    [SerializeField] [TextArea] private string description;
+    [SerializeField] private ModifierRarity rarity;
+    [SerializeField] private int shopPrice;
+    [SerializeField] private int sellPrice;
+    [SerializeField] private Sprite icon;
+
+    [Header("Effect")]
+    [SerializeField] private ModifierScope scope;
+    [SerializeField] private ModifierEffectType effectType;
+    [SerializeField] private ModifierTarget target;
+    [SerializeField] private float effectValue;
+
+    [Header("Durability")]
+    [SerializeField] private ModifierDurability durability;
+    [SerializeField] private int maxUses;
+
+    public string Id => id;
+    public string DisplayName => displayName;
+    public string Description => description;
+    public ModifierRarity Rarity => rarity;
+    public int ShopPrice => shopPrice;
+    public int SellPrice => sellPrice;
+    public Sprite Icon => icon;
+    public ModifierScope Scope => scope;
+    public ModifierEffectType EffectType => effectType;
+    public ModifierTarget Target => target;
+    public float EffectValue => effectValue;
+    public ModifierDurability Durability => durability;
+    public int MaxUses => maxUses;
+
+    public bool IsAdditive =>
+        effectType == ModifierEffectType.AddPerDieValue ||
+        effectType == ModifierEffectType.AddFlatToFinalScore;
+
+    public bool IsMultiplicative =>
+        effectType == ModifierEffectType.MultiplyPerDieValue ||
+        effectType == ModifierEffectType.MultiplyFinalScore;
+
+    public bool IsCategoryLevel =>
+        effectType == ModifierEffectType.AddPerDieValue ||
+        effectType == ModifierEffectType.MultiplyPerDieValue;
+
+    public bool IsFinalScoreLevel =>
+        effectType == ModifierEffectType.AddFlatToFinalScore ||
+        effectType == ModifierEffectType.MultiplyFinalScore;
+
+#if UNITY_EDITOR
+    public static ModifierData CreateForTest(
+        string id,
+        ModifierScope scope,
+        ModifierEffectType effectType,
+        float effectValue,
+        int dieValue = 0,
+        YachtCategory targetCategory = YachtCategory.Ones,
+        bool hasCategoryFilter = false,
+        ModifierDurability durability = ModifierDurability.Permanent,
+        int maxUses = 0,
+        int shopPrice = 100,
+        int sellPrice = 50)
+    {
+        var data = CreateInstance<ModifierData>();
+        data.id = id;
+        data.displayName = id;
+        data.description = id;
+        data.scope = scope;
+        data.effectType = effectType;
+        data.effectValue = effectValue;
+        data.target = new ModifierTarget
+        {
+            DieValue = dieValue,
+            TargetCategory = targetCategory,
+            HasCategoryFilter = hasCategoryFilter
+        };
+        data.durability = durability;
+        data.maxUses = maxUses;
+        data.shopPrice = shopPrice;
+        data.sellPrice = sellPrice;
+        return data;
+    }
+#endif
+}

Assets/Scripts/Modifiers/ModifierEffect.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+
+public delegate void ModifierHandler(ModifierData data, ref ScoreResult result);
+
+public static class ModifierEffect
+{
+    private static readonly Dictionary<ModifierEffectType, ModifierHandler> Handlers = new()
+    {
+        { ModifierEffectType.AddPerDieValue, ApplyAddPerDieValue },
+        { ModifierEffectType.AddFlatToFinalScore, ApplyAddFlat },
+        { ModifierEffectType.MultiplyPerDieValue, ApplyMultiplyPerDieValue },
+        { ModifierEffectType.MultiplyFinalScore, ApplyMultiplyFinal }
+    };
+
+    public static void Apply(ModifierData data, ref ScoreResult result)
+    {
+        if (Handlers.TryGetValue(data.EffectType, out var handler))
+            handler(data, ref result);
+    }
+
+    private static void ApplyAddPerDieValue(ModifierData data, ref ScoreResult result)
+    {
+        int targetValue = data.Target.DieValue;
+        int count = 0;
+
+        for (int i = 0; i < result.DiceValues.Length; i++)
+        {
+            if (targetValue == 0 || result.DiceValues[i] == targetValue)
+                count++;
+        }
+
+        result.FlatBonus += (int)(data.EffectValue * count);
+    }
+
+    private static void ApplyAddFlat(ModifierData data, ref ScoreResult result)
+    {
+        result.FlatBonus += (int)data.EffectValue;
+    }
+
+    private static void ApplyMultiplyPerDieValue(ModifierData data, ref ScoreResult result)
+    {
+        int targetValue = data.Target.DieValue;
+
+        for (int i = 0; i < result.DiceValues.Length; i++)
+        {
+            if (targetValue == 0 || result.DiceValues[i] == targetValue)
+                result.Multiplier *= data.EffectValue;
+        }
+    }
+
+    private static void ApplyMultiplyFinal(ModifierData data, ref ScoreResult result)
+    {
+        result.Multiplier *= data.EffectValue;
+    }
+}

Assets/Scripts/Modifiers/ModifierEnums.cs

@@ -0,0 +1,27 @@
+public enum ModifierScope
+{
+    SelectedCategory,
+    AnyCategoryClosed
+}
+
+public enum ModifierEffectType
+{
+    AddPerDieValue,
+    AddFlatToFinalScore,
+    MultiplyPerDieValue,
+    MultiplyFinalScore
+}
+
+public enum ModifierDurability
+{
+    Permanent,
+    LimitedUses
+}
+
+public enum ModifierRarity
+{
+    Common,
+    Uncommon,
+    Rare,
+    Epic
+}

Assets/Scripts/Modifiers/ModifierPipeline.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+
+public static class ModifierPipeline
+{
+    // Application order (explicit):
+    //   1. Category-level additive   (AddPerDieValue)
+    //   2. Category-level multiplicative (MultiplyPerDieValue)
+    //   3. Final-score additive      (AddFlatToFinalScore)
+    //   4. Final-score multiplicative (MultiplyFinalScore)
+
+    public static void Apply(
+        IReadOnlyList<ModifierData> activeModifiers,
+        ref ScoreResult result,
+        ModifierScope currentScope)
+    {
+        if (activeModifiers == null) return;
+
+        // Pass 1: Category-level additive
+        for (int i = 0; i < activeModifiers.Count; i++)
+        {
+            var mod = activeModifiers[i];
+            if (!ShouldApply(mod, ref result, currentScope)) continue;
+            if (mod.IsCategoryLevel && mod.IsAdditive)
+                ModifierEffect.Apply(mod, ref result);
+        }
+
+        // Pass 2: Category-level multiplicative
+        for (int i = 0; i < activeModifiers.Count; i++)
+        {
+            var mod = activeModifiers[i];
+            if (!ShouldApply(mod, ref result, currentScope)) continue;
+            if (mod.IsCategoryLevel && mod.IsMultiplicative)
+                ModifierEffect.Apply(mod, ref result);
+        }
+
+        // Pass 3: Final-score additive
+        for (int i = 0; i < activeModifiers.Count; i++)
+        {
+            var mod = activeModifiers[i];
+            if (!ShouldApply(mod, ref result, currentScope)) continue;
+            if (mod.IsFinalScoreLevel && mod.IsAdditive)
+                ModifierEffect.Apply(mod, ref result);
+        }
+
+        // Pass 4: Final-score multiplicative
+        for (int i = 0; i < activeModifiers.Count; i++)
+        {
+            var mod = activeModifiers[i];
+            if (!ShouldApply(mod, ref result, currentScope)) continue;
+            if (mod.IsFinalScoreLevel && mod.IsMultiplicative)
+                ModifierEffect.Apply(mod, ref result);
+        }
+    }
+
+    private static bool ShouldApply(ModifierData mod, ref ScoreResult result, ModifierScope currentScope)
+    {
+        if (mod == null) return false;
+        if (mod.Scope != currentScope) return false;
+        if (mod.Target.HasCategoryFilter && mod.Target.TargetCategory != result.Category) return false;
+        return true;
+    }
+}

Assets/Scripts/Modifiers/ModifierRuntime.cs

@@ -0,0 +1,34 @@
+using System;
+
+[Serializable]
+public sealed class ModifierRuntime
+{
+    public string ModifierId;
+    public bool IsActive;
+    public int RemainingUses;
+
+    [NonSerialized] public ModifierData Data;
+
+    public bool IsExpired => Data != null &&
+                             Data.Durability == ModifierDurability.LimitedUses &&
+                             RemainingUses <= 0;
+
+    public void ConsumeUse()
+    {
+        if (Data == null) return;
+        if (Data.Durability != ModifierDurability.LimitedUses) return;
+
+        RemainingUses--;
+    }
+
+    public static ModifierRuntime Create(ModifierData data)
+    {
+        return new ModifierRuntime
+        {
+            ModifierId = data.Id,
+            IsActive = false,
+            RemainingUses = data.Durability == ModifierDurability.LimitedUses ? data.MaxUses : -1,
+            Data = data
+        };
+    }
+}

Assets/Scripts/Modifiers/ModifierTarget.cs

@@ -0,0 +1,16 @@
+using System;
+using UnityEngine;
+
+[Serializable]
+public struct ModifierTarget
+{
+    [Tooltip("Die face value (1-6). 0 = any/all dice.")]
+    [Range(0, 6)]
+    public int DieValue;
+
+    [Tooltip("Category this modifier targets.")]
+    public YachtCategory TargetCategory;
+
+    [Tooltip("If true, TargetCategory is used as a filter.")]
+    public bool HasCategoryFilter;
+}

Assets/Scripts/Modifiers/MultiplierForSixes.cs

@@ -1,16 +0,0 @@
-using UnityEngine;
-
-[CreateAssetMenu(fileName = "MultiplierForSixes", menuName = "YachtDice/Modifiers/Multiplier For Sixes")]
-public sealed class MultiplierForSixes : ScoreModifier
-{
-    [SerializeField] private float multiplierPerSix = 6f;
-
-    public override ModifierPhase Phase => ModifierPhase.Multiplicative;
-
-    public override void Apply(ref ScoreResult result)
-    {
-        for (int i = 0; i < result.DiceValues.Length; i++)
-            if (result.DiceValues[i] == 6)
-                result.Multiplier *= multiplierPerSix;
-    }
-}

Assets/Scripts/Modifiers/ScoreModifier.cs

@@ -1,19 +0,0 @@
-using UnityEngine;
-
-public abstract class ScoreModifier : ScriptableObject
-{
-    public enum ModifierPhase
-    {
-        Additive,
-        Multiplicative
-    }
-
-    [SerializeField] private string displayName;
-    [SerializeField] [TextArea] private string description;
-
-    public string DisplayName => displayName;
-    public string Description => description;
-
-    public abstract ModifierPhase Phase { get; }
-    public abstract void Apply(ref ScoreResult result);
-}