[Fix] Code visual

Assets/Scripts/Tests/Editor/InventoryModelTests.cs

@@ -5,157 +5,156 @@ using YachtDice.Modifiers;
 
 namespace YachtDice.Tests
 {
-
-public sealed class InventoryModelTests
-{
-    private InventoryModel inventory;
-
-    [SetUp]
-    public void SetUp()
+    public class InventoryModelTests
     {
-        inventory = new InventoryModel(3);
-    }
+        private InventoryModel inventory;
 
-    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++)
+        [SetUp]
+        public void SetUp()
         {
-            inventory.AddModifier(CreateTestData($"m{i}"));
-            inventory.TryActivate(inventory.OwnedModifiers[i]);
+            inventory = new InventoryModel(3);
         }
 
-        inventory.AddModifier(CreateTestData("extra"));
-        var extra = inventory.OwnedModifiers[3];
-        bool result = inventory.TryActivate(extra);
+        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);
+        }
 
-        Assert.IsFalse(result);
-        Assert.IsFalse(extra.IsActive);
-        Assert.AreEqual(3, inventory.ActiveCount);
-    }
+        [Test]
+        public void AddModifier_IncreasesCount()
+        {
+            inventory.AddModifier(CreateTestData());
 
-    [Test]
-    public void Deactivate_FreesSlot()
-    {
-        inventory.AddModifier(CreateTestData());
-        var mod = inventory.OwnedModifiers[0];
-        inventory.TryActivate(mod);
+            Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+        }
 
-        inventory.Deactivate(mod);
+        [Test]
+        public void TryActivate_SucceedsWithinSlotLimit()
+        {
+            inventory.AddModifier(CreateTestData("a"));
+            var mod = inventory.OwnedModifiers[0];
 
-        Assert.IsFalse(mod.IsActive);
-        Assert.AreEqual(0, inventory.ActiveCount);
-    }
+            bool result = inventory.TryActivate(mod);
 
-    [Test]
-    public void RemoveModifier_DeactivatesAndRemoves()
-    {
-        inventory.AddModifier(CreateTestData());
-        var mod = inventory.OwnedModifiers[0];
-        inventory.TryActivate(mod);
+            Assert.IsTrue(result);
+            Assert.IsTrue(mod.IsActive);
+            Assert.AreEqual(1, inventory.ActiveCount);
+        }
 
-        inventory.RemoveModifier(mod);
+        [Test]
+        public void TryActivate_FailsWhenSlotsFull()
+        {
+            for (int i = 0; i < 3; i++)
+            {
+                inventory.AddModifier(CreateTestData($"m{i}"));
+                inventory.TryActivate(inventory.OwnedModifiers[i]);
+            }
 
-        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
-        Assert.AreEqual(0, inventory.ActiveCount);
-    }
+            inventory.AddModifier(CreateTestData("extra"));
+            var extra = inventory.OwnedModifiers[3];
+            bool result = inventory.TryActivate(extra);
 
-    [Test]
-    public void ConsumeUseOnActive_DecrementsUses()
-    {
-        inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 3));
-        var mod = inventory.OwnedModifiers[0];
-        inventory.TryActivate(mod);
+            Assert.IsFalse(result);
+            Assert.IsFalse(extra.IsActive);
+            Assert.AreEqual(3, inventory.ActiveCount);
+        }
 
-        inventory.ConsumeUseOnActive();
+        [Test]
+        public void Deactivate_FreesSlot()
+        {
+            inventory.AddModifier(CreateTestData());
+            var mod = inventory.OwnedModifiers[0];
+            inventory.TryActivate(mod);
 
-        Assert.AreEqual(2, mod.RemainingUses);
-    }
+            inventory.Deactivate(mod);
 
-    [Test]
-    public void ConsumeUseOnActive_RemovesExpired()
-    {
-        inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 1));
-        var mod = inventory.OwnedModifiers[0];
-        inventory.TryActivate(mod);
+            Assert.IsFalse(mod.IsActive);
+            Assert.AreEqual(0, inventory.ActiveCount);
+        }
 
-        inventory.ConsumeUseOnActive();
+        [Test]
+        public void RemoveModifier_DeactivatesAndRemoves()
+        {
+            inventory.AddModifier(CreateTestData());
+            var mod = inventory.OwnedModifiers[0];
+            inventory.TryActivate(mod);
 
-        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
-    }
+            inventory.RemoveModifier(mod);
 
-    [Test]
-    public void ConsumeUseOnActive_IgnoresPermanent()
-    {
-        inventory.AddModifier(CreateTestData("perm", ModifierDurability.Permanent));
-        var mod = inventory.OwnedModifiers[0];
-        inventory.TryActivate(mod);
+            Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+            Assert.AreEqual(0, inventory.ActiveCount);
+        }
 
-        inventory.ConsumeUseOnActive();
+        [Test]
+        public void ConsumeUseOnActive_DecrementsUses()
+        {
+            inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 3));
+            var mod = inventory.OwnedModifiers[0];
+            inventory.TryActivate(mod);
 
-        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
-        Assert.IsTrue(mod.IsActive);
-    }
+            inventory.ConsumeUseOnActive();
 
-    [Test]
-    public void GetActiveModifierData_ReturnsOnlyActive()
-    {
-        inventory.AddModifier(CreateTestData("a"));
-        inventory.AddModifier(CreateTestData("b"));
-        inventory.TryActivate(inventory.OwnedModifiers[0]);
+            Assert.AreEqual(2, mod.RemainingUses);
+        }
 
-        var active = inventory.GetActiveModifierData();
+        [Test]
+        public void ConsumeUseOnActive_RemovesExpired()
+        {
+            inventory.AddModifier(CreateTestData("ltd", ModifierDurability.LimitedUses, 1));
+            var mod = inventory.OwnedModifiers[0];
+            inventory.TryActivate(mod);
 
-        Assert.AreEqual(1, active.Count);
-    }
+            inventory.ConsumeUseOnActive();
 
-    [Test]
-    public void SetMaxActiveSlots_AllowsExpansion()
-    {
-        inventory.SetMaxActiveSlots(10);
+            Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+        }
 
-        Assert.AreEqual(10, inventory.MaxActiveSlots);
-    }
+        [Test]
+        public void ConsumeUseOnActive_IgnoresPermanent()
+        {
+            inventory.AddModifier(CreateTestData("perm", ModifierDurability.Permanent));
+            var mod = inventory.OwnedModifiers[0];
+            inventory.TryActivate(mod);
 
-    [Test]
-    public void OnActiveModifiersChanged_FiredOnActivate()
-    {
-        bool fired = false;
-        inventory.OnActiveModifiersChanged += _ => fired = true;
-        inventory.AddModifier(CreateTestData());
+            inventory.ConsumeUseOnActive();
 
-        inventory.TryActivate(inventory.OwnedModifiers[0]);
+            Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+            Assert.IsTrue(mod.IsActive);
+        }
 
-        Assert.IsTrue(fired);
+        [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);
+        }
     }
 }
-}

Assets/Scripts/Tests/Editor/ModifierEffectTests.cs

@@ -5,91 +5,90 @@ using YachtDice.Scoring;
 
 namespace YachtDice.Tests
 {
-
-public sealed class ModifierEffectTests
-{
-    private static ModifierData CreateData(
-        ModifierEffectType effectType, float effectValue,
-        int dieValue = 0, ModifierScope scope = ModifierScope.SelectedCategory)
+    public class ModifierEffectTests
     {
-        return ModifierData.CreateForTest("test", scope, effectType, effectValue, dieValue);
-    }
+        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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(30, result.FlatBonus);
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(10, result.FlatBonus);
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(0, result.FlatBonus);
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(15, result.FlatBonus);
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(8f, result.Multiplier); // 1 * 2 * 2 * 2 = 8
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(1f, result.Multiplier);
-    }
+            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);
+        [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);
+            ModifierEffect.Apply(data, ref result);
 
-        Assert.AreEqual(1.5f, result.Multiplier, 0.001f);
+            Assert.AreEqual(1.5f, result.Multiplier, 0.001f);
+        }
     }
 }
-}

Assets/Scripts/Tests/Editor/ModifierPipelineTests.cs

@@ -6,137 +6,136 @@ using YachtDice.Scoring;
 
 namespace YachtDice.Tests
 {
-
-public sealed class ModifierPipelineTests
-{
-    [Test]
-    public void Apply_AdditiveBeforeMultiplicative()
+    public class ModifierPipelineTests
     {
-        var addMod = ModifierData.CreateForTest("add", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f);
-        var mulMod = ModifierData.CreateForTest("mul", ModifierScope.SelectedCategory,
-            ModifierEffectType.MultiplyFinalScore, 2f);
+        [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);
+            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);
+            ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
 
-        // (20 + 10) * 2 = 60
-        Assert.AreEqual(60, result.FinalScore);
-    }
+            // (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);
+        [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);
+            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);
+            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);
-    }
+            // 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);
+        [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);
+            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);
+            ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
 
-        Assert.AreEqual(0, result.FlatBonus);
-        Assert.AreEqual(10, result.FinalScore);
-    }
+            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);
+        [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);
+            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);
+            ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
 
-        Assert.AreEqual(0, result.FlatBonus);
-    }
+            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);
+        [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);
+            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);
+            ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
 
-        Assert.AreEqual(15, result.FlatBonus);
-        Assert.AreEqual(40, result.FinalScore);
-    }
+            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);
+        [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);
+            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);
+            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);
-    }
+            // 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);
+        [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.DoesNotThrow(() =>
+                ModifierPipeline.Apply(null, ref result, ModifierScope.SelectedCategory));
 
-        Assert.AreEqual(10, result.FinalScore);
-    }
+            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);
+        [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);
+            ModifierPipeline.Apply(modifiers, ref result, ModifierScope.SelectedCategory);
 
-        Assert.AreEqual(10, result.FinalScore);
+            Assert.AreEqual(10, result.FinalScore);
+        }
     }
 }
-}

Assets/Scripts/Tests/Editor/SaveSystemTests.cs

@@ -5,89 +5,88 @@ using YachtDice.Persistence;
 
 namespace YachtDice.Tests
 {
-
-public sealed class SaveSystemTests
-{
-    [SetUp]
-    public void SetUp()
+    public class SaveSystemTests
     {
-        SaveSystem.Delete();
-    }
-
-    [TearDown]
-    public void TearDown()
-    {
-        SaveSystem.Delete();
-    }
-
-    [Test]
-    public void SaveAndLoad_RoundTrip_PreservesData()
-    {
-        var data = new SaveData
+        [SetUp]
+        public void SetUp()
         {
-            Currency = 999,
-            OwnedModifiers = new List<ModifierSaveEntry>
+            SaveSystem.Delete();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            SaveSystem.Delete();
+        }
+
+        [Test]
+        public void SaveAndLoad_RoundTrip_PreservesData()
+        {
+            var data = new SaveData
             {
-                new() { ModifierId = "mod1", IsActive = true, RemainingUses = 3 },
-                new() { ModifierId = "mod2", IsActive = false, RemainingUses = -1 }
-            }
-        };
+                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();
+            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);
-    }
+            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();
+        [Test]
+        public void Load_MissingKey_ReturnsDefault()
+        {
+            var loaded = SaveSystem.Load();
 
-        Assert.IsNotNull(loaded);
-        Assert.AreEqual(0, loaded.Currency);
-        Assert.AreEqual(0, loaded.OwnedModifiers.Count);
-    }
+            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_ReturnsFalseWhenEmpty()
+        {
+            Assert.IsFalse(SaveSystem.HasSave());
+        }
 
-    [Test]
-    public void HasSave_ReturnsTrueAfterSave()
-    {
-        SaveSystem.Save(new SaveData { Currency = 100 });
+        [Test]
+        public void HasSave_ReturnsTrueAfterSave()
+        {
+            SaveSystem.Save(new SaveData { Currency = 100 });
 
-        Assert.IsTrue(SaveSystem.HasSave());
-    }
+            Assert.IsTrue(SaveSystem.HasSave());
+        }
 
-    [Test]
-    public void Delete_RemovesSaveData()
-    {
-        SaveSystem.Save(new SaveData { Currency = 100 });
-        SaveSystem.Delete();
+        [Test]
+        public void Delete_RemovesSaveData()
+        {
+            SaveSystem.Save(new SaveData { Currency = 100 });
+            SaveSystem.Delete();
 
-        Assert.IsFalse(SaveSystem.HasSave());
-    }
+            Assert.IsFalse(SaveSystem.HasSave());
+        }
 
-    [Test]
-    public void Load_CorruptJson_ReturnsDefault()
-    {
-        PlayerPrefs.SetString("YachtDice_SaveData", "{invalid json!!!");
-        PlayerPrefs.Save();
+        [Test]
+        public void Load_CorruptJson_ReturnsDefault()
+        {
+            PlayerPrefs.SetString("YachtDice_SaveData", "{invalid json!!!");
+            PlayerPrefs.Save();
 
-        var loaded = SaveSystem.Load();
+            var loaded = SaveSystem.Load();
 
-        Assert.IsNotNull(loaded);
-        Assert.AreEqual(0, loaded.Currency);
+            Assert.IsNotNull(loaded);
+            Assert.AreEqual(0, loaded.Currency);
+        }
     }
 }
-}

Assets/Scripts/Tests/Editor/ScoringSystemTests.cs

@@ -6,99 +6,98 @@ using YachtDice.Modifiers;
 
 namespace YachtDice.Tests
 {
-
-public sealed class ScoringSystemTests
-{
-    private ScoringSystem CreateScoringSystem()
+    public class ScoringSystemTests
     {
-        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) =>
+        private ScoringSystem CreateScoringSystem()
         {
-            firedCategory = cat;
-            firedResult = res;
-        };
+            var go = new GameObject("ScoringSystem");
+            return go.AddComponent<ScoringSystem>();
+        }
 
-        system.ScoreCategory(new[] { 1, 1, 1, 1, 1 }, YachtCategory.Ones);
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (var go in Object.FindObjectsByType<ScoringSystem>(FindObjectsSortMode.None))
+                Object.DestroyImmediate(go.gameObject);
+        }
 
-        Assert.AreEqual(YachtCategory.Ones, firedCategory);
-        Assert.AreEqual(5, firedResult.BaseScore);
-    }
+        [Test]
+        public void PreviewScore_AppliesOnlySelectedCategoryModifiers()
+        {
+            var system = CreateScoringSystem();
 
-    [Test]
-    public void ScoreCategory_PreventsDuplicateCategory()
-    {
-        var system = CreateScoringSystem();
-        system.ScoreCategory(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
+            var selectedMod = ModifierData.CreateForTest("sel", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f);
+            var anyCloseMod = ModifierData.CreateForTest("any", ModifierScope.AnyCategoryClosed,
+                ModifierEffectType.AddFlatToFinalScore, 100f);
 
-        Assert.Throws<System.InvalidOperationException>(() =>
-            system.ScoreCategory(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance));
-    }
+            system.SetActiveModifiers(new List<ModifierData> { selectedMod, anyCloseMod });
 
-    [Test]
-    public void ScoreCategory_WithNoModifiers_CalculatesBaseOnly()
-    {
-        var system = CreateScoringSystem();
-        var result = system.ScoreCategory(new[] { 6, 6, 6, 6, 6 }, YachtCategory.Yacht);
+            var result = system.PreviewScore(new[] { 1, 2, 3, 4, 5 }, YachtCategory.Chance);
 
-        Assert.AreEqual(50, result.BaseScore);
-        Assert.AreEqual(0, result.FlatBonus);
-        Assert.AreEqual(1f, result.Multiplier);
-        Assert.AreEqual(50, result.FinalScore);
+            // 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);
+        }
     }
 }
-}

Assets/Scripts/Tests/Editor/ShopModelTests.cs

@@ -7,132 +7,131 @@ using YachtDice.Modifiers;
 
 namespace YachtDice.Tests
 {
-
-public sealed class ShopModelTests
-{
-    private CurrencyBank bank;
-    private InventoryModel inventory;
-    private ShopModel shop;
-
-    [SetUp]
-    public void SetUp()
+    public sealed class ShopModelTests
     {
-        var go = new GameObject("Bank");
-        bank = go.AddComponent<CurrencyBank>();
-        bank.SetBalance(500);
+        private CurrencyBank bank;
+        private InventoryModel inventory;
+        private ShopModel shop;
 
-        inventory = new InventoryModel(5);
-        shop = new ShopModel(bank, inventory);
-    }
+        [SetUp]
+        public void SetUp()
+        {
+            var go = new GameObject("Bank");
+            bank = go.AddComponent<CurrencyBank>();
+            bank.SetBalance(500);
 
-    [TearDown]
-    public void TearDown()
-    {
-        foreach (var go in Object.FindObjectsByType<CurrencyBank>(FindObjectsSortMode.None))
-            Object.DestroyImmediate(go.gameObject);
-    }
+            inventory = new InventoryModel(5);
+            shop = new ShopModel(bank, inventory);
+        }
 
-    [Test]
-    public void TryPurchase_SucceedsWithSufficientCurrency()
-    {
-        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (var go in Object.FindObjectsByType<CurrencyBank>(FindObjectsSortMode.None))
+                Object.DestroyImmediate(go.gameObject);
+        }
 
-        bool result = shop.TryPurchase(mod);
+        [Test]
+        public void TryPurchase_SucceedsWithSufficientCurrency()
+        {
+            var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
 
-        Assert.IsTrue(result);
-        Assert.AreEqual(400, bank.Balance);
-        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
-    }
+            bool result = shop.TryPurchase(mod);
 
-    [Test]
-    public void TryPurchase_FailsWhenBroke()
-    {
-        bank.SetBalance(10);
-        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+            Assert.IsTrue(result);
+            Assert.AreEqual(400, bank.Balance);
+            Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+        }
 
-        bool result = shop.TryPurchase(mod);
+        [Test]
+        public void TryPurchase_FailsWhenBroke()
+        {
+            bank.SetBalance(10);
+            var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
 
-        Assert.IsFalse(result);
-        Assert.AreEqual(10, bank.Balance);
-        Assert.AreEqual(0, inventory.OwnedModifiers.Count);
-    }
+            bool result = shop.TryPurchase(mod);
 
-    [Test]
-    public void TryPurchase_PermanentCannotBeBoughtTwice()
-    {
-        var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f,
-            durability: ModifierDurability.Permanent, shopPrice: 100);
+            Assert.IsFalse(result);
+            Assert.AreEqual(10, bank.Balance);
+            Assert.AreEqual(0, inventory.OwnedModifiers.Count);
+        }
 
-        shop.TryPurchase(mod);
-        bool secondResult = shop.TryPurchase(mod);
+        [Test]
+        public void TryPurchase_PermanentCannotBeBoughtTwice()
+        {
+            var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f,
+                durability: ModifierDurability.Permanent, shopPrice: 100);
 
-        Assert.IsFalse(secondResult);
-        Assert.AreEqual(400, bank.Balance);
-        Assert.AreEqual(1, inventory.OwnedModifiers.Count);
-    }
+            shop.TryPurchase(mod);
+            bool secondResult = shop.TryPurchase(mod);
 
-    [Test]
-    public void TryPurchase_LimitedCanBeReBought()
-    {
-        var mod = ModifierData.CreateForTest("limited", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f,
-            durability: ModifierDurability.LimitedUses, maxUses: 3, shopPrice: 100);
+            Assert.IsFalse(secondResult);
+            Assert.AreEqual(400, bank.Balance);
+            Assert.AreEqual(1, inventory.OwnedModifiers.Count);
+        }
 
-        shop.TryPurchase(mod);
-        bool secondResult = shop.TryPurchase(mod);
+        [Test]
+        public void TryPurchase_LimitedCanBeReBought()
+        {
+            var mod = ModifierData.CreateForTest("limited", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f,
+                durability: ModifierDurability.LimitedUses, maxUses: 3, shopPrice: 100);
 
-        Assert.IsTrue(secondResult);
-        Assert.AreEqual(300, bank.Balance);
-        Assert.AreEqual(2, inventory.OwnedModifiers.Count);
-    }
+            shop.TryPurchase(mod);
+            bool secondResult = shop.TryPurchase(mod);
 
-    [Test]
-    public void TryPurchase_FiresPurchaseEvent()
-    {
-        ModifierData purchased = null;
-        shop.OnItemPurchased += data => purchased = data;
+            Assert.IsTrue(secondResult);
+            Assert.AreEqual(300, bank.Balance);
+            Assert.AreEqual(2, inventory.OwnedModifiers.Count);
+        }
 
-        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+        [Test]
+        public void TryPurchase_FiresPurchaseEvent()
+        {
+            ModifierData purchased = null;
+            shop.OnItemPurchased += data => purchased = data;
 
-        shop.TryPurchase(mod);
+            var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
 
-        Assert.IsNotNull(purchased);
-        Assert.AreEqual("test", purchased.Id);
-    }
+            shop.TryPurchase(mod);
 
-    [Test]
-    public void GetItemState_Available_WhenCanAfford()
-    {
-        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+            Assert.IsNotNull(purchased);
+            Assert.AreEqual("test", purchased.Id);
+        }
 
-        Assert.AreEqual(ShopItemState.Available, shop.GetItemState(mod));
-    }
+        [Test]
+        public void GetItemState_Available_WhenCanAfford()
+        {
+            var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
 
-    [Test]
-    public void GetItemState_TooExpensive_WhenCannotAfford()
-    {
-        bank.SetBalance(10);
-        var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
+            Assert.AreEqual(ShopItemState.Available, shop.GetItemState(mod));
+        }
 
-        Assert.AreEqual(ShopItemState.TooExpensive, shop.GetItemState(mod));
-    }
+        [Test]
+        public void GetItemState_TooExpensive_WhenCannotAfford()
+        {
+            bank.SetBalance(10);
+            var mod = ModifierData.CreateForTest("test", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f, shopPrice: 100);
 
-    [Test]
-    public void GetItemState_Owned_WhenPermanentPurchased()
-    {
-        var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
-            ModifierEffectType.AddFlatToFinalScore, 10f,
-            durability: ModifierDurability.Permanent, shopPrice: 100);
+            Assert.AreEqual(ShopItemState.TooExpensive, shop.GetItemState(mod));
+        }
 
-        shop.TryPurchase(mod);
+        [Test]
+        public void GetItemState_Owned_WhenPermanentPurchased()
+        {
+            var mod = ModifierData.CreateForTest("perm", ModifierScope.SelectedCategory,
+                ModifierEffectType.AddFlatToFinalScore, 10f,
+                durability: ModifierDurability.Permanent, shopPrice: 100);
 
-        Assert.AreEqual(ShopItemState.Owned, shop.GetItemState(mod));
+            shop.TryPurchase(mod);
+
+            Assert.AreEqual(ShopItemState.Owned, shop.GetItemState(mod));
+        }
     }
 }
-}