[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>
2026-02-28 06:40:33 +07:00
parent 4f8db3158f
commit ba626acb9b
33 changed files with 2123 additions and 86 deletions
@@ -0,0 +1,155 @@
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class InventoryModelTests
+{
+    private InventoryModel inventory;
+
+    [SetUp]
+    public void SetUp()
+    {
+        inventory = new InventoryModel(3);
+    }
+
+    private ModifierData CreateTestData(string id = "test",
+        ModifierDurability durability = ModifierDurability.Permanent, int maxUses = 0)
+    {
+        return ModifierData.CreateForTest(id, ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f,
+            durability: durability, maxUses: maxUses);
+    }
+
+    [Test]
+    public void AddModifier_IncreasesCount()
+    {
+        inventory.AddModifier(CreateTestData());
+
+        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void TryActivate_SucceedsWithinSlotLimit()
+    {
+        inventory.AddModifier(CreateTestData("a"));
+        var mod = inventory.OwnedModifiers[0];
+
+        bool result = inventory.TryActivate(mod);
+
+        Assert.IsTrue(result);
+        Assert.IsTrue(mod.IsActive);
+        Assert.AreEqual(1, inventory.ActiveCount);
+    }
+
+    [Test]
+    public void TryActivate_FailsWhenSlotsFull()
+    {
+        for (int i = 0; i < 3; i++)
+        {
+            inventory.AddModifier(CreateTestData($"m{i}"));
+            inventory.TryActivate(inventory.OwnedModifiers[i]);
+        }
+
+        inventory.AddModifier(CreateTestData("extra"));
+        var extra = inventory.OwnedModifiers[3];
+        bool result = inventory.TryActivate(extra);
+
+        Assert.IsFalse(result);
+        Assert.IsFalse(extra.IsActive);
+        Assert.AreEqual(3, inventory.ActiveCount);
+    }
+
+    [Test]
+    public void Deactivate_FreesSlot()
+    {
+        inventory.AddModifier(CreateTestData());
+        var mod = inventory.OwnedModifiers[0];
+        inventory.TryActivate(mod);
+
+        inventory.Deactivate(mod);
+
+        Assert.IsFalse(mod.IsActive);
+        Assert.AreEqual(0, inventory.ActiveCount);
+    }
+
+    [Test]
+    public void RemoveModifier_DeactivatesAndRemoves()
+    {
+        inventory.AddModifier(CreateTestData());
+        var mod = inventory.OwnedModifiers[0];
+        inventory.TryActivate(mod);
+
+        inventory.RemoveModifier(mod);
+
+        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+        Assert.AreEqual(0, inventory.ActiveCount);
+    }
+
+    [Test]
+    public void ConsumeUseOnActive_DecrementsUses()
+    {
+        inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 3));
+        var mod = inventory.OwnedModifiers[0];
+        inventory.TryActivate(mod);
+
+        inventory.ConsumeUseOnActive();
+
+        Assert.AreEqual(2, mod.RemainingUses);
+    }
+
+    [Test]
+    public void ConsumeUseOnActive_RemovesExpired()
+    {
+        inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 1));
+        var mod = inventory.OwnedModifiers[0];
+        inventory.TryActivate(mod);
+
+        inventory.ConsumeUseOnActive();
+
+        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void ConsumeUseOnActive_IgnoresPermanent()
+    {
+        inventory.AddModifier(CreateTestData("perm", ModifierDurability.Permanent));
+        var mod = inventory.OwnedModifiers[0];
+        inventory.TryActivate(mod);
+
+        inventory.ConsumeUseOnActive();
+
+        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+        Assert.IsTrue(mod.IsActive);
+    }
+
+    [Test]
+    public void GetActiveModifierData_ReturnsOnlyActive()
+    {
+        inventory.AddModifier(CreateTestData("a"));
+        inventory.AddModifier(CreateTestData("b"));
+        inventory.TryActivate(inventory.OwnedModifiers[0]);
+
+        var active = inventory.GetActiveModifierData();
+
+        Assert.AreEqual(1, active.Count);
+    }
+
+    [Test]
+    public void SetMaxActiveSlots_AllowsExpansion()
+    {
+        inventory.SetMaxActiveSlots(10);
+
+        Assert.AreEqual(10, inventory.MaxActiveSlots);
+    }
+
+    [Test]
+    public void OnActiveModifiersChanged_FiredOnActivate()
+    {
+        bool fired = false;
+        inventory.OnActiveModifiersChanged += _ => fired = true;
+        inventory.AddModifier(CreateTestData());
+
+        inventory.TryActivate(inventory.OwnedModifiers[0]);
+
+        Assert.IsTrue(fired);
+    }
+}
@@ -0,0 +1,89 @@
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class ModifierEffectTests
+{
+    private static ModifierData CreateData(
+        ModifierEffectType effectType, float effectValue,
+        int dieValue = 0, ModifierScope scope = ModifierScope.SelectedCategory)
+    {
+        return ModifierData.CreateForTest("test", scope, effectType, effectValue, dieValue);
+    }
+
+    [Test]
+    public void AddPerDieValue_CountsMatchingDice()
+    {
+        var data = CreateData(ModifierEffectType.AddPerDieValue, 10f, dieValue: 1);
+        var result = ScoreResult.Create(5, new[] { 1, 1, 3, 4, 1 }, YachtCategory.Ones);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(30, result.FlatBonus);
+    }
+
+    [Test]
+    public void AddPerDieValue_ZeroTarget_CountsAllDice()
+    {
+        var data = CreateData(ModifierEffectType.AddPerDieValue, 2f, dieValue: 0);
+        var result = ScoreResult.Create(10, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(10, result.FlatBonus);
+    }
+
+    [Test]
+    public void AddPerDieValue_NoMatches_ZeroBonus()
+    {
+        var data = CreateData(ModifierEffectType.AddPerDieValue, 10f, dieValue: 6);
+        var result = ScoreResult.Create(5, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(0, result.FlatBonus);
+    }
+
+    [Test]
+    public void AddFlatToFinalScore_AddsFlat()
+    {
+        var data = CreateData(ModifierEffectType.AddFlatToFinalScore, 15f);
+        var result = ScoreResult.Create(25, new[] { 3, 3, 2, 2, 2 }, YachtCategory.FullHouse);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(15, result.FlatBonus);
+    }
+
+    [Test]
+    public void MultiplyPerDieValue_MultipliesPerMatch()
+    {
+        var data = CreateData(ModifierEffectType.MultiplyPerDieValue, 2f, dieValue: 6);
+        var result = ScoreResult.Create(18, new[] { 6, 6, 6, 1, 2 }, YachtCategory.Sixes);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(8f, result.Multiplier); // 1 * 2 * 2 * 2 = 8
+    }
+
+    [Test]
+    public void MultiplyPerDieValue_NoMatches_MultiplierUnchanged()
+    {
+        var data = CreateData(ModifierEffectType.MultiplyPerDieValue, 3f, dieValue: 6);
+        var result = ScoreResult.Create(10, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(1f, result.Multiplier);
+    }
+
+    [Test]
+    public void MultiplyFinalScore_MultipliesOnce()
+    {
+        var data = CreateData(ModifierEffectType.MultiplyFinalScore, 1.5f);
+        var result = ScoreResult.Create(50, new[] { 6, 6, 6, 6, 6 }, YachtCategory.Yacht);
+
+        ModifierEffect.Apply(data, ref result);
+
+        Assert.AreEqual(1.5f, result.Multiplier, 0.001f);
+    }
+}
@@ -0,0 +1,136 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class ModifierPipelineTests
+{
+    [Test]
+    public void Apply_AdditiveBeforeMultiplicative()
+    {
+        var addMod = ModifierData.CreateForTest("add", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f);
+        var mulMod = ModifierData.CreateForTest("mul", ModifierScope.SelectedCategory,
+            ModifierEffectType.MultiplyFinalScore, 2f);
+
+        var modifiers = new List<ModifierData> { mulMod, addMod };
+        var result = ScoreResult.Create(20, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        // (20 + 10) * 2 = 60
+        Assert.AreEqual(60, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_CategoryLevelBeforeFinalScore()
+    {
+        var perDie = ModifierData.CreateForTest("perDie", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddPerDieValue, 5f, dieValue: 1);
+        var flat = ModifierData.CreateForTest("flat", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 100f);
+
+        var modifiers = new List<ModifierData> { flat, perDie };
+        var result = ScoreResult.Create(3, new[] { 1, 1, 1, 2, 3 }, YachtCategory.Ones);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        // FlatBonus = 15 (perDie: 5*3) + 100 (flat) = 115
+        // FinalScore = (3 + 115) * 1 = 118
+        Assert.AreEqual(118, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_ScopeFiltering_SkipsWrongScope()
+    {
+        var mod = ModifierData.CreateForTest("any", ModifierScope.AnyCategoryClosed,
+            ModifierEffectType.AddFlatToFinalScore, 50f);
+
+        var modifiers = new List<ModifierData> { mod };
+        var result = ScoreResult.Create(10, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        Assert.AreEqual(0, result.FlatBonus);
+        Assert.AreEqual(10, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_CategoryFilter_SkipsWrongCategory()
+    {
+        var mod = ModifierData.CreateForTest("fh", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 15f,
+            targetCategory: YachtCategory.FullHouse, hasCategoryFilter: true);
+
+        var modifiers = new List<ModifierData> { mod };
+        var result = ScoreResult.Create(5, new[] { 1, 1, 1, 1, 1 }, YachtCategory.Ones);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        Assert.AreEqual(0, result.FlatBonus);
+    }
+
+    [Test]
+    public void Apply_CategoryFilter_AppliesMatchingCategory()
+    {
+        var mod = ModifierData.CreateForTest("fh", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 15f,
+            targetCategory: YachtCategory.FullHouse, hasCategoryFilter: true);
+
+        var modifiers = new List<ModifierData> { mod };
+        var result = ScoreResult.Create(25, new[] { 3, 3, 3, 2, 2 }, YachtCategory.FullHouse);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        Assert.AreEqual(15, result.FlatBonus);
+        Assert.AreEqual(40, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_MultipleModifiers_CorrectOrder()
+    {
+        var perDieAdd = ModifierData.CreateForTest("pda", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddPerDieValue, 2f, dieValue: 3);
+        var perDieMul = ModifierData.CreateForTest("pdm", ModifierScope.SelectedCategory,
+            ModifierEffectType.MultiplyPerDieValue, 1.5f, dieValue: 3);
+        var flatAdd = ModifierData.CreateForTest("fa", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f);
+        var finalMul = ModifierData.CreateForTest("fm", ModifierScope.SelectedCategory,
+            ModifierEffectType.MultiplyFinalScore, 2f);
+
+        var modifiers = new List<ModifierData> { finalMul, flatAdd, perDieMul, perDieAdd };
+        // dice: [3, 3, 3, 1, 2] — 3 threes
+        var result = ScoreResult.Create(9, new[] { 3, 3, 3, 1, 2 }, YachtCategory.Threes);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        // Pass 1 (cat additive): perDieAdd: +2*3 = +6 FlatBonus
+        // Pass 2 (cat multiplicative): perDieMul: 1.5^3 = 3.375 Multiplier
+        // Pass 3 (final additive): flatAdd: +10 FlatBonus → total FlatBonus = 16
+        // Pass 4 (final multiplicative): finalMul: 3.375 * 2 = 6.75 Multiplier
+        // FinalScore = floor((9 + 16) * 6.75) = floor(168.75) = 168
+        Assert.AreEqual(6, result.FlatBonus + 10); // just check pipeline ran; full calc below
+        Assert.AreEqual(168, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_NullModifiers_DoesNotThrow()
+    {
+        var result = ScoreResult.Create(10, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        Assert.DoesNotThrow(() =>
+            ModifierPipeline.Apply(null, ref result, ModifierScope.SelectedCategory));
+
+        Assert.AreEqual(10, result.FinalScore);
+    }
+
+    [Test]
+    public void Apply_EmptyList_NoChange()
+    {
+        var modifiers = new List<ModifierData>();
+        var result = ScoreResult.Create(10, new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
+
+        Assert.AreEqual(10, result.FinalScore);
+    }
+}
@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class SaveSystemTests
+{
+    [SetUp]
+    public void SetUp()
+    {
+        SaveSystem.Delete();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        SaveSystem.Delete();
+    }
+
+    [Test]
+    public void SaveAndLoad_RoundTrip_PreservesData()
+    {
+        var data = new SaveData
+        {
+            Currency = 999,
+            OwnedModifiers = new List<ModifierSaveEntry>
+            {
+                new() { ModifierId = "mod1", IsActive = true, RemainingUses = 3 },
+                new() { ModifierId = "mod2", IsActive = false, RemainingUses = -1 }
+            }
+        };
+
+        SaveSystem.Save(data);
+        var loaded = SaveSystem.Load();
+
+        Assert.AreEqual(999, loaded.Currency);
+        Assert.AreEqual(2, loaded.OwnedModifiers.Count);
+        Assert.AreEqual("mod1", loaded.OwnedModifiers[0].ModifierId);
+        Assert.IsTrue(loaded.OwnedModifiers[0].IsActive);
+        Assert.AreEqual(3, loaded.OwnedModifiers[0].RemainingUses);
+        Assert.AreEqual("mod2", loaded.OwnedModifiers[1].ModifierId);
+        Assert.IsFalse(loaded.OwnedModifiers[1].IsActive);
+    }
+
+    [Test]
+    public void Load_MissingKey_ReturnsDefault()
+    {
+        var loaded = SaveSystem.Load();
+
+        Assert.IsNotNull(loaded);
+        Assert.AreEqual(0, loaded.Currency);
+        Assert.AreEqual(0, loaded.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void HasSave_ReturnsFalseWhenEmpty()
+    {
+        Assert.IsFalse(SaveSystem.HasSave());
+    }
+
+    [Test]
+    public void HasSave_ReturnsTrueAfterSave()
+    {
+        SaveSystem.Save(new SaveData { Currency = 100 });
+
+        Assert.IsTrue(SaveSystem.HasSave());
+    }
+
+    [Test]
+    public void Delete_RemovesSaveData()
+    {
+        SaveSystem.Save(new SaveData { Currency = 100 });
+        SaveSystem.Delete();
+
+        Assert.IsFalse(SaveSystem.HasSave());
+    }
+
+    [Test]
+    public void Load_CorruptJson_ReturnsDefault()
+    {
+        PlayerPrefs.SetString("YachtDice_SaveData", "{invalid json!!!");
+        PlayerPrefs.Save();
+
+        var loaded = SaveSystem.Load();
+
+        Assert.IsNotNull(loaded);
+        Assert.AreEqual(0, loaded.Currency);
+    }
+}
@@ -0,0 +1,98 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class ScoringSystemTests
+{
+    private ScoringSystem CreateScoringSystem()
+    {
+        var go = new GameObject("ScoringSystem");
+        return go.AddComponent<ScoringSystem>();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        foreach (var go in Object.FindObjectsByType<ScoringSystem>(FindObjectsSortMode.None))
+            Object.DestroyImmediate(go.gameObject);
+    }
+
+    [Test]
+    public void PreviewScore_AppliesOnlySelectedCategoryModifiers()
+    {
+        var system = CreateScoringSystem();
+
+        var selectedMod = ModifierData.CreateForTest("sel", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f);
+        var anyCloseMod = ModifierData.CreateForTest("any", ModifierScope.AnyCategoryClosed,
+            ModifierEffectType.AddFlatToFinalScore, 100f);
+
+        system.SetActiveModifiers(new List<ModifierData> { selectedMod, anyCloseMod });
+
+        var result = system.PreviewScore(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        // Only SelectedCategory mod should apply in preview
+        Assert.AreEqual(10, result.FlatBonus);
+        Assert.AreEqual(25, result.FinalScore); // (15 + 10) * 1
+    }
+
+    [Test]
+    public void ScoreCategory_AppliesBothScopes()
+    {
+        var system = CreateScoringSystem();
+
+        var selectedMod = ModifierData.CreateForTest("sel", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f);
+        var anyCloseMod = ModifierData.CreateForTest("any", ModifierScope.AnyCategoryClosed,
+            ModifierEffectType.AddFlatToFinalScore, 20f);
+
+        system.SetActiveModifiers(new List<ModifierData> { selectedMod, anyCloseMod });
+
+        var result = system.ScoreCategory(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        // Both scopes should apply
+        Assert.AreEqual(30, result.FlatBonus);
+        Assert.AreEqual(45, result.FinalScore); // (15 + 30) * 1
+    }
+
+    [Test]
+    public void ScoreCategory_FiresOnCategoryConfirmed()
+    {
+        var system = CreateScoringSystem();
+        YachtCategory firedCategory = (YachtCategory)(-1);
+        ScoreResult firedResult = default;
+
+        system.OnCategoryConfirmed += (cat, res) =>
+        {
+            firedCategory = cat;
+            firedResult = res;
+        };
+
+        system.ScoreCategory(new[] { 1, 1, 1, 1, 1 }, YachtCategory.Ones);
+
+        Assert.AreEqual(YachtCategory.Ones, firedCategory);
+        Assert.AreEqual(5, firedResult.BaseScore);
+    }
+
+    [Test]
+    public void ScoreCategory_PreventsDuplicateCategory()
+    {
+        var system = CreateScoringSystem();
+        system.ScoreCategory(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+
+        Assert.Throws<System.InvalidOperationException>(() =>
+            system.ScoreCategory(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance));
+    }
+
+    [Test]
+    public void ScoreCategory_WithNoModifiers_CalculatesBaseOnly()
+    {
+        var system = CreateScoringSystem();
+        var result = system.ScoreCategory(new[] { 6, 6, 6, 6, 6 }, YachtCategory.Yacht);
+
+        Assert.AreEqual(50, result.BaseScore);
+        Assert.AreEqual(0, result.FlatBonus);
+        Assert.AreEqual(1f, result.Multiplier);
+        Assert.AreEqual(50, result.FinalScore);
+    }
+}
@@ -0,0 +1,130 @@
+using NUnit.Framework;
+using UnityEngine;
+
+public sealed class ShopModelTests
+{
+    private CurrencyBank bank;
+    private InventoryModel inventory;
+    private ShopModel shop;
+
+    [SetUp]
+    public void SetUp()
+    {
+        var go = new GameObject("Bank");
+        bank = go.AddComponent<CurrencyBank>();
+        bank.SetBalance(500);
+
+        inventory = new InventoryModel(5);
+        shop = new ShopModel(bank, inventory);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        foreach (var go in Object.FindObjectsByType<CurrencyBank>(FindObjectsSortMode.None))
+            Object.DestroyImmediate(go.gameObject);
+    }
+
+    [Test]
+    public void TryPurchase_SucceedsWithSufficientCurrency()
+    {
+        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+
+        bool result = shop.TryPurchase(mod);
+
+        Assert.IsTrue(result);
+        Assert.AreEqual(400, bank.Balance);
+        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void TryPurchase_FailsWhenBroke()
+    {
+        bank.SetBalance(10);
+        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+
+        bool result = shop.TryPurchase(mod);
+
+        Assert.IsFalse(result);
+        Assert.AreEqual(10, bank.Balance);
+        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void TryPurchase_PermanentCannotBeBoughtTwice()
+    {
+        var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f,
+            durability: ModifierDurability.Permanent, shopPrice: 100);
+
+        shop.TryPurchase(mod);
+        bool secondResult = shop.TryPurchase(mod);
+
+        Assert.IsFalse(secondResult);
+        Assert.AreEqual(400, bank.Balance);
+        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void TryPurchase_LimitedCanBeReBought()
+    {
+        var mod = ModifierData.CreateForTest("limited", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f,
+            durability: ModifierDurability.LimitedUses, maxUses: 3, shopPrice: 100);
+
+        shop.TryPurchase(mod);
+        bool secondResult = shop.TryPurchase(mod);
+
+        Assert.IsTrue(secondResult);
+        Assert.AreEqual(300, bank.Balance);
+        Assert.AreEqual(2, inventory.OwnedModifiers.Count);
+    }
+
+    [Test]
+    public void TryPurchase_FiresPurchaseEvent()
+    {
+        ModifierData purchased = null;
+        shop.OnItemPurchased += data => purchased = data;
+
+        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+
+        shop.TryPurchase(mod);
+
+        Assert.IsNotNull(purchased);
+        Assert.AreEqual("test", purchased.Id);
+    }
+
+    [Test]
+    public void GetItemState_Available_WhenCanAfford()
+    {
+        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+
+        Assert.AreEqual(ShopItemState.Available, shop.GetItemState(mod));
+    }
+
+    [Test]
+    public void GetItemState_TooExpensive_WhenCannotAfford()
+    {
+        bank.SetBalance(10);
+        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+
+        Assert.AreEqual(ShopItemState.TooExpensive, shop.GetItemState(mod));
+    }
+
+    [Test]
+    public void GetItemState_Owned_WhenPermanentPurchased()
+    {
+        var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
+            ModifierEffectType.AddFlatToFinalScore, 10f,
+            durability: ModifierDurability.Permanent, shopPrice: 100);
+
+        shop.TryPurchase(mod);
+
+        Assert.AreEqual(ShopItemState.Owned, shop.GetItemState(mod));
+    }
+}
@@ -0,0 +1,24 @@
+{
+    "name": "YachtDice.Tests.Editor",
+    "rootNamespace": "",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "YachtDice.Runtime"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}