[Fix] Refactor project

Assets/Scripts/Categories/Definition/CategoryCatalog.cs

@@ -18,17 +18,18 @@ namespace YachtDice.Categories
 
         public CategoryDefinition FindById(string id)
         {
-            for (int i = 0; i < categories.Count; i++)
+            foreach (var t in categories)
             {
-                if (categories[i] != null && categories[i].Id == id)
-                    return categories[i];
+                if (t != null && t.Id == id)
+                    return t;
             }
+
             return null;
         }
 
         public int IndexOf(CategoryDefinition def)
         {
-            for (int i = 0; i < categories.Count; i++)
+            for (var i = 0; i < categories.Count; i++)
             {
                 if (categories[i] == def)
                     return i;

Assets/Scripts/Categories/Definition/SumAllCategory.cs

@@ -12,9 +12,11 @@ namespace YachtDice.Categories
     {
         public override int Calculate(IReadOnlyList<IDice> dice)
         {
-            int sum = 0;
-            for (int i = 0; i < dice.Count; i++)
-                sum += dice[i].Value;
+            var sum = 0;
+            
+            foreach (var t in dice)
+                sum += t.Value;
+
             return sum;
         }
 

Assets/Scripts/Categories/Definition/SumOfValueCategory.cs

@@ -17,9 +17,11 @@ namespace YachtDice.Categories
 
         public override int Calculate(IReadOnlyList<IDice> dice)
         {
-            int sum = 0;
-            for (int i = 0; i < dice.Count; i++)
-                if (dice[i].Value == TargetValue) sum += TargetValue;
+            var sum = 0;
+            
+            foreach (var t in dice)
+                if (t.Value == TargetValue) sum += TargetValue;
+
             return sum;
         }
 

Assets/Scripts/Categories/DiceCheckUtility.cs

@@ -10,68 +10,96 @@ namespace YachtDice.Categories
     /// </summary>
     public static class DiceCheckUtility
     {
-        /// <summary>Извлекает массив значений из абстрактных дайсов.</summary>
+        /// <summary>
+        /// Извлекает массив значений из абстрактных дайсов.
+        /// </summary>
         public static int[] ExtractValues(IReadOnlyList<IDice> dice)
         {
-            int[] values = new int[dice.Count];
+            var values = new int[dice.Count];
             for (int i = 0; i < dice.Count; i++)
                 values[i] = dice[i].Value;
             return values;
         }
 
-        /// <summary>Сумма дайсов, показывающих конкретное значение.</summary>
+        /// <summary>
+        /// Сумма дайсов, показывающих конкретное значение.
+        /// </summary>
         public static int SumOfValue(int[] values, int target)
         {
-            int sum = 0;
-            for (int i = 0; i < values.Length; i++)
-                if (values[i] == target) sum += target;
+            var sum = 0;
+            foreach (var t in values)
+                if (t == target) sum += target;
+
             return sum;
         }
 
-        /// <summary>Сумма всех дайсов.</summary>
+        /// <summary>
+        /// Сумма всех дайсов.
+        /// </summary>
         public static int Sum(int[] values)
         {
-            int sum = 0;
-            for (int i = 0; i < values.Length; i++) sum += values[i];
+            var sum = 0;
+            foreach (var t in values)
+                sum += t;
+
             return sum;
         }
 
-        /// <summary>Есть ли N или более одинаковых значений.</summary>
+        /// <summary>
+        /// Есть ли N или более одинаковых значений.
+        /// </summary>
         public static bool NOfAKind(int[] values, int n)
         {
-            int[] counts = new int[7];
-            for (int i = 0; i < values.Length; i++) counts[values[i]]++;
+            var counts = new int[7];
+            
+            foreach (var t in values)
+                counts[t]++;
+
             for (int v = 1; v <= 6; v++)
                 if (counts[v] >= n) return true;
+            
             return false;
         }
 
-        /// <summary>Проверяет фулл-хаус (3 + 2 одинаковых).</summary>
+        /// <summary>
+        /// Проверяет фулл-хаус (3 + 2 одинаковых).
+        /// </summary>
         public static bool IsFullHouse(int[] values)
         {
-            int[] counts = new int[7];
-            for (int i = 0; i < values.Length; i++) counts[values[i]]++;
+            var counts = new int[7];
+            
+            foreach (var v in values)
+                counts[v]++;
+
             bool hasTwo = false, hasThree = false;
-            for (int v = 1; v <= 6; v++)
+            
+            for (var i = 1; i <= 6; i++)
             {
-                if (counts[v] == 2) hasTwo = true;
-                if (counts[v] == 3) hasThree = true;
+                if (counts[i] == 2) hasTwo = true;
+                if (counts[i] == 3) hasThree = true;
             }
+            
             return hasTwo && hasThree;
         }
 
-        /// <summary>Есть ли последовательность заданной длины.</summary>
+        /// <summary>
+        /// Есть ли последовательность заданной длины.
+        /// </summary>
         public static bool HasStraightRun(int[] values, int runLength)
         {
-            bool[] present = new bool[7];
-            for (int i = 0; i < values.Length; i++) present[values[i]] = true;
+            var present = new bool[7];
+            
+            foreach (var t in values)
+                present[t] = true;
 
-            int consecutive = 0;
-            for (int v = 1; v <= 6; v++)
+            var consecutive = 0;
+            
+            for (var v = 1; v <= 6; v++)
             {
                 consecutive = present[v] ? consecutive + 1 : 0;
                 if (consecutive >= runLength) return true;
             }
+            
             return false;
         }
     }