[Add] Master Category

2026-03-06 23:29:46 +07:00
parent 9580d76a53
commit 73b941d5eb
42 changed files with 817 additions and 21 deletions
@@ -12,9 +12,13 @@ namespace YachtDice.Categories
    public class CategoryCatalog : ScriptableObject
    {
        [SerializeField] private List<CategoryDefinition> categories = new();
+        [SerializeField] private int upperBonusThreshold = 63;
+        [SerializeField] private int upperBonusValue = 35;

        public IReadOnlyList<CategoryDefinition> All => categories;
        public int Count => categories.Count;
+        public int UpperBonusThreshold => upperBonusThreshold;
+        public int UpperBonusValue => upperBonusValue;

        public CategoryDefinition FindById(string id)
        {
@@ -38,10 +42,12 @@ namespace YachtDice.Categories
        }

 #if UNITY_EDITOR
-        public static CategoryCatalog CreateForTest(List<CategoryDefinition> defs)
+        public static CategoryCatalog CreateForTest(List<CategoryDefinition> defs, int upperBonusThreshold = 63, int upperBonusValue = 35)
        {
            var catalog = CreateInstance<CategoryCatalog>();
            catalog.categories = defs ?? new List<CategoryDefinition>();
+            catalog.upperBonusThreshold = upperBonusThreshold;
+            catalog.upperBonusValue = upperBonusValue;
            return catalog;
        }
 #endif
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using UnityEngine;
+using YachtDice.Dice;
+
+namespace YachtDice.Categories
+{
+    [CreateAssetMenu(fileName = "MasterGroupedSetsCategory", menuName = "YachtDice/Categories/Master/Grouped Sets")]
+    public class MasterGroupedSetsCategory : CategoryDefinition
+    {
+        [Header("Scoring")]
+        [Tooltip("How many equal dice each group must contain.")]
+        [SerializeField, Min(1)] private int groupSize = 2;
+
+        [Tooltip("How many groups are required.")]
+        [SerializeField, Min(1)] private int requiredGroups = 3;
+
+        [Tooltip("Flat bonus added when the grouped pattern is valid.")]
+        [SerializeField] private int flatBonus;
+
+        public override int Calculate(IReadOnlyList<IDice> dice)
+        {
+            var values = DiceCheckUtility.ExtractValues(dice);
+            if (!DiceCheckUtility.TryGetGroupedSetSum(values, groupSize, requiredGroups, out var groupedSum))
+                return 0;
+
+            return groupedSum + flatBonus;
+        }
+
+#if UNITY_EDITOR
+        public static MasterGroupedSetsCategory CreateForTest(
+            string id,
+            string displayName,
+            int groupSize,
+            int requiredGroups,
+            int flatBonus = 0)
+        {
+            var so = CreateInstance<MasterGroupedSetsCategory>();
+            so.SetTestData(id, displayName);
+            so.groupSize = groupSize;
+            so.requiredGroups = requiredGroups;
+            so.flatBonus = flatBonus;
+            return so;
+        }
+#endif
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8f1f7c8d8f3a4a34bb5327f9fd0dc003
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using UnityEngine;
+using YachtDice.Dice;
+
+namespace YachtDice.Categories
+{
+    [CreateAssetMenu(fileName = "MasterKindCategory", menuName = "YachtDice/Categories/Master/N Of A Kind")]
+    public class MasterKindCategory : CategoryDefinition
+    {
+        [Header("Scoring")]
+        [Tooltip("How many matching dice are required.")]
+        [SerializeField, Min(1)] private int requiredCount = 4;
+
+        [Tooltip("Additional score equals matched value multiplied by this number.")]
+        [SerializeField] private int valueBonusMultiplier = 1;
+
+        [Tooltip("Extra flat bonus added when the category is valid.")]
+        [SerializeField] private int flatBonus;
+
+        public override int Calculate(IReadOnlyList<IDice> dice)
+        {
+            var values = DiceCheckUtility.ExtractValues(dice);
+            if (!DiceCheckUtility.TryGetBestValueWithAtLeastCount(values, requiredCount, out var matchedValue))
+                return 0;
+
+            return (matchedValue * requiredCount) + (matchedValue * valueBonusMultiplier) + flatBonus;
+        }
+
+#if UNITY_EDITOR
+        public static MasterKindCategory CreateForTest(
+            string id,
+            string displayName,
+            int requiredCount,
+            int valueBonusMultiplier,
+            int flatBonus = 0)
+        {
+            var so = CreateInstance<MasterKindCategory>();
+            so.SetTestData(id, displayName);
+            so.requiredCount = requiredCount;
+            so.valueBonusMultiplier = valueBonusMultiplier;
+            so.flatBonus = flatBonus;
+            return so;
+        }
+#endif
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8f1f7c8d8f3a4a34bb5327f9fd0dc004
@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using UnityEngine;
+using YachtDice.Dice;
+
+namespace YachtDice.Categories
+{
+    [CreateAssetMenu(fileName = "MasterStraightCategory", menuName = "YachtDice/Categories/Master/Straight")]
+    public class MasterStraightCategory : CategoryDefinition
+    {
+        [Header("Scoring")]
+        [Tooltip("Flat bonus added to the dice sum when the straight is valid.")]
+        [SerializeField] private int flatBonus;
+
+        public override int Calculate(IReadOnlyList<IDice> dice)
+        {
+            var values = DiceCheckUtility.ExtractValues(dice);
+            if (!DiceCheckUtility.IsExactStraightOneToSix(values))
+                return 0;
+
+            return DiceCheckUtility.Sum(values) + flatBonus;
+        }
+
+#if UNITY_EDITOR
+        public static MasterStraightCategory CreateForTest(string id, string displayName, int flatBonus = 0)
+        {
+            var so = CreateInstance<MasterStraightCategory>();
+            so.SetTestData(id, displayName);
+            so.flatBonus = flatBonus;
+            return so;
+        }
+#endif
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8f1f7c8d8f3a4a34bb5327f9fd0dc002
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using UnityEngine;
+using YachtDice.Dice;
+
+namespace YachtDice.Categories
+{
+    [CreateAssetMenu(fileName = "MasterValueCategory", menuName = "YachtDice/Categories/Master/Value")]
+    public class MasterValueCategory : CategoryDefinition
+    {
+        [field: Header("Scoring")]
+        [field: Tooltip("Dice face value to collect.")]
+        [field: SerializeField, Range(1, 6)] public int TargetValue { get; private set; } = 1;
+
+        [field: Tooltip("Flat bonus added when at least one matching die is present.")]
+        [field: SerializeField] public int CategoryBonus { get; private set; }
+
+        public override int Calculate(IReadOnlyList<IDice> dice)
+        {
+            var values = DiceCheckUtility.ExtractValues(dice);
+            var sum = DiceCheckUtility.SumOfValue(values, TargetValue);
+            return sum > 0 ? sum + CategoryBonus : 0;
+        }
+
+#if UNITY_EDITOR
+        public static MasterValueCategory CreateForTest(string id, string displayName, int targetValue, int categoryBonus = 0)
+        {
+            var so = CreateInstance<MasterValueCategory>();
+            so.SetTestData(id, displayName, upperSection: true);
+            so.TargetValue = targetValue;
+            so.CategoryBonus = categoryBonus;
+            return so;
+        }
+#endif
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8f1f7c8d8f3a4a34bb5327f9fd0dc001
@@ -102,5 +102,83 @@ namespace YachtDice.Categories
            
            return false;
        }
+
+        public static int[] BuildCounts(int[] values)
+        {
+            var counts = new int[7];
+
+            if (values == null)
+                return counts;
+
+            for (var i = 0; i < values.Length; i++)
+            {
+                var value = values[i];
+                if (value >= 1 && value <= 6)
+                    counts[value]++;
+            }
+
+            return counts;
+        }
+
+        public static bool TryGetBestValueWithAtLeastCount(int[] values, int requiredCount, out int matchedValue)
+        {
+            var counts = BuildCounts(values);
+
+            for (var value = 6; value >= 1; value--)
+            {
+                if (counts[value] >= requiredCount)
+                {
+                    matchedValue = value;
+                    return true;
+                }
+            }
+
+            matchedValue = 0;
+            return false;
+        }
+
+        public static bool TryGetGroupedSetSum(int[] values, int groupSize, int requiredGroups, out int groupedSum)
+        {
+            if (groupSize <= 0 || requiredGroups <= 0)
+            {
+                groupedSum = 0;
+                return false;
+            }
+
+            var counts = BuildCounts(values);
+            var foundGroups = 0;
+            groupedSum = 0;
+
+            for (var value = 6; value >= 1; value--)
+            {
+                if (counts[value] < groupSize)
+                    continue;
+
+                foundGroups++;
+                groupedSum += value * groupSize;
+
+                if (foundGroups >= requiredGroups)
+                    return true;
+            }
+
+            groupedSum = 0;
+            return false;
+        }
+
+        public static bool IsExactStraightOneToSix(int[] values)
+        {
+            if (values == null || values.Length != 6)
+                return false;
+
+            var counts = BuildCounts(values);
+
+            for (var value = 1; value <= 6; value++)
+            {
+                if (counts[value] != 1)
+                    return false;
+            }
+
+            return true;
+        }
    }
 }