Fixes + New options

* Fixes champions not being found when loading

+ Options for trait optimization

Author: dragitz

TFT Comp Creator 2/Form1.Designer.cs

@@ -108,7 +108,9 @@ public Form1()
                     include_spatula,
                     bronze_traits,
                     carryCheck,
-                    carryCheck_unspecified
+                    carryCheck_unspecified,
+                    mustMaxOutTraitLevel,
+                    mustMaxOutTraitLevelCurrent
 
                 );
 
@@ -252,6 +254,8 @@ public void Creation()
                 List<string> tempIncludeTrait = include_trait.Items.Cast<string>().ToList();
                 List<string> tempIncludeSpatula = include_spatula.Items.Cast<string>().ToList();
 
+                trait_snake = default_trait.Items[k].ToString();
+
                 if (ForceStop)
                 {
                     CreateButton.Enabled = false;
@@ -282,7 +286,7 @@ public void Creation()
 
                     Print(String.Join("-", tempIncludeTrait));
 
-                    trait_snake = default_trait.Items[k].ToString();
+                    
                     int bp_total = Master["TraitList"][trait_snake]["Breakpoints"].Count;
                     int biggest_bp = Master["TraitList"][trait_snake]["Breakpoints"][bp_total - 1];
                     int emblems_required = biggest_bp - Master["TraitChampions"][trait_snake].Count;
@@ -386,13 +390,50 @@ public void Creation()
 
 
 
-                ConcurrentDictionary<List<string>, int> parallel_results = FindCombinations2(size, nodes, excluded_comp_champions, tempIncludeTrait, tempIncludeSpatula);
+                ConcurrentDictionary<List<string>, int> parallel_results = FindCombinations2(size, nodes, excluded_comp_champions, tempIncludeTrait, tempIncludeSpatula, trait_snake);
+
+                ConcurrentDictionary<List<string>, int> parallel_results_best = new ConcurrentDictionary<List<string>, int>();
+                if (mustMaxOutTraitLevelCurrent.Checked)
+                {
+                    foreach (List<string> compParallel in parallel_results.Keys)
+                    {
+                        JObject JTraits = constructJTraits(compParallel);
+                        if (!JTraits.ContainsKey(trait_snake)) { continue; } // Ignore if trait isn't present
+
+                        int maxTotalChamps = Master["TraitChampions"][trait_snake].Count;
+                        JArray breakpoints = Master["TraitList"][trait_snake]["Breakpoints"] as JArray;
+
+                        // Get the highest breakpoint that can be reached without emblems
+                        int maxValidBP = breakpoints.Where(bp => (int)bp <= maxTotalChamps).DefaultIfEmpty(0).Max(bp => (int)bp);
+
+                        int result = (int)JTraits[trait_snake];
+
+                        // If the highest breakpoint is unreachable without emblems, check previous valid BP
+                        if (maxValidBP < breakpoints.Max(bp => (int)bp))  // There's a higher BP that we can't reach
+                        {
+                            if (result == maxValidBP)
+                                parallel_results_best[compParallel] = parallel_results[compParallel];
+                        }
+                        else
+                        {
+                            if (result == maxValidBP)  // No need for `-1`, just compare with maxValidBP
+                                parallel_results_best[compParallel] = parallel_results[compParallel];
+                        }
+                    }
+
+                }
+                else
+                {
+                    parallel_results_best = parallel_results;
+                }
+
+                
 
                 // Filter, sort, and take the top 10
-                var top10 = parallel_results
+                var top10 = parallel_results_best
                     .Where(entry => entry.Value > Pet_SynergyBest)
                     .OrderByDescending(entry => entry.Value)
-                    .Take(10);
+                    .Take(20);
 
                 foreach (var obj in top10)
                 {
@@ -599,7 +640,9 @@ private void applySet_Click(object sender, EventArgs e)
                                 include_spatula,
                                 bronze_traits,
                                 carryCheck,
-                                carryCheck_unspecified
+                                carryCheck_unspecified,
+                                mustMaxOutTraitLevel,
+                                mustMaxOutTraitLevelCurrent
 
                             );
 

TFT Comp Creator 2/Form1.cs

@@ -31,6 +31,8 @@ public class Scoring
         private static CheckBox bronze_traits = new CheckBox();
         private static CheckBox carryCheck = new CheckBox();
         private static CheckBox carryCheck_unspecified = new CheckBox();
+        private static CheckBox mustMaxOutTraitLevel = new CheckBox();
+        private static CheckBox mustMaxOutTraitLevelCurrent = new CheckBox();
 
 
         public static ListBox include_spatula = new ListBox();
@@ -59,7 +61,9 @@ public static void SetFromScoring(
             ListBox include_spatula_,
             CheckBox bronze_traits_,
             CheckBox carryCheck_,
-            CheckBox carryCheck_unspecified_
+            CheckBox carryCheck_unspecified_,
+            CheckBox mustMaxOutTraitLevel_,
+            CheckBox mustMaxOutTraitLevelCurrent_
             )
         {
             Master = M;
@@ -88,6 +92,8 @@ CheckBox carryCheck_unspecified_
             carryCheck = carryCheck_;
             carryCheck_unspecified = carryCheck_unspecified_;
 
+            mustMaxOutTraitLevel = mustMaxOutTraitLevel_;
+            mustMaxOutTraitLevelCurrent = mustMaxOutTraitLevelCurrent_;
         }
 
         /// <summary>
@@ -335,19 +341,23 @@ public static bool CheckCompValidity(List<string> comp, List<string> excluded_co
             if (include_champion.Items.Count > 0 && carryCheck.Checked)
             {
                 List<string> carry = new List<string>();
-                foreach(string champion in  include_champion.Items)
+                foreach (string champion in include_champion.Items)
                 {
                     carry.Add(champion);
                 }
                 if (!CarryWorth3(JTraits, carry)) { return false; }
+
+                // 
+
+
             }
 
-            if(carryCheck_unspecified.Checked)
+            if (carryCheck_unspecified.Checked)
             {
-                if(!isCarryPresent(JTraits, comp))
+                if (!isCarryPresent(JTraits, comp))
                     return false;
             }
-            
+
             // Only comps with at least one trait that reaches BP 3 (gold) are considered valid.
             // Note: traits that only have 2 BP (therefore gold at 2) are ignored
             if (goldTrait.Checked)
@@ -403,12 +413,25 @@ public static bool CheckCompValidity(List<string> comp, List<string> excluded_co
             }
 
 
-
             // Included / Excluded trait check
             foreach (string Trait in include_trait.Items)
             {
                 if (!isTraitActive(JTraits, Trait))
                     return false;
+
+                if (mustMaxOutTraitLevel.Checked)
+                {
+                    // compute max potential without a spatula
+                    List<string> wantedTraitList = new List<string>();
+
+                    foreach (dynamic item in include_trait.Items)
+                    {
+                        wantedTraitList.Add(item.ToString());
+                    }
+                    if (!isTraitMaxedOutNoSpatula(JTraits, wantedTraitList))
+                        return false;
+                    //int amount = JTraitsMaster["TraitChampions"]
+                }
             }
 
             foreach (string Trait in exclude_trait.Items)
@@ -427,9 +450,9 @@ public static bool CheckCompValidity(List<string> comp, List<string> excluded_co
                 }
             }
 
-            
 
-       
+
+
 
             // Ensure specified emblems are used
             foreach (string Trait in include_spatula.Items)
@@ -450,7 +473,7 @@ public static bool CheckCompValidity(List<string> comp, List<string> excluded_co
                 if (bronze_traits.Checked)
                 {
                     int BP = CheckBreakPointAmount(JTraits, Trait);
-                    if(BP > 1) { return false; }
+                    if (BP > 1) { return false; }
                 }
 
                 if (isTraitActive(JTraits, Trait))

TFT Comp Creator 2/Scoring.cs

@@ -206,7 +206,6 @@ public static dynamic FirstRun(int setData_ID)
 
 
 
-
                 // Create population of champions
                 i = 0;
                 foreach (dynamic items in ChampionList)
@@ -215,17 +214,18 @@ public static dynamic FirstRun(int setData_ID)
 
                     string ChampionName = (string)JDownload["setData"][setData_ID]["champions"][i]["name"];
 
-                    if(ChampionName == null) { continue; }
+                    if (ChampionName == null) { i++; continue; }
 
                     ChampionName = ChampionName.Replace(" & Willump", "");
                     ChampionName = ChampionName.Replace("'", "");
 
                     string apiName = (string)JDownload["setData"][setData_ID]["champions"][i]["apiName"];
-
+                    
 
                     // Ignore duplicates, unless the same champion is considered different (compare its traits first)
                     if (Master["Champions"].ContainsKey(ChampionName))
                     {
+                        
 
                         JArray LoggedChampionTraits = Master["Champions"][ChampionName]["Traits"];
                         var PotentialNew = JDownload["setData"][setData_ID]["champions"][i]["traits"];
@@ -353,7 +353,10 @@ public static dynamic FirstRun(int setData_ID)
                     foreach (JToken token in champions) // Iterate over the array
                     {
                         string ChampName = (string)token["display_name"];
-                        if(ChampName == null) { continue; }
+
+
+
+                        if (ChampName == null) { continue; }
 
                         ChampName = ChampName.Replace("'", "");
 

TFT Comp Creator 2/Setup.cs

@@ -208,6 +208,7 @@ public static List<string> GetTraitsFromChampion(string champion)
             return traits;
         }
 
+
         public static bool isGoldTraitPresent(JObject JTraits)
         {
             foreach (var item in JTraits.Properties())
@@ -242,6 +243,71 @@ public static int CheckBreakPointAmount(JObject JTraits, string Trait)
             return BP;
         }
 
+        public static JObject constructJTraits(List<string> comp)
+        {
+            JObject JTraits = new JObject();
+            List<string> TraitsInComp = new List<string>();
+
+            foreach (string champion in comp)
+            {
+                // Add the trait to the list
+                dynamic Traits = Master["Champions"][champion]["Traits"];
+                foreach (string Trait in Traits)
+                {
+                    if (TraitsInComp.Contains(Trait))
+                        continue;
+
+                    TraitsInComp.Add(Trait);
+                    JProperty item_properties = new JProperty(Trait, 0);
+                    JTraits.Add(item_properties);
+                }
+
+                // Populate JTraits
+                int ChampionTraitsAmount = (int)Master["Champions"][champion]["Traits"].Count;
+
+                dynamic TraitsArray = Master["Champions"][champion]["Traits"];
+
+                for (int k = 0; k < ChampionTraitsAmount; k++)
+                {
+                    string CurrentTrait = (string)TraitsArray[k];
+
+                    if (TraitsInComp.Contains(CurrentTrait))
+                    {
+                        JTraits[CurrentTrait] = (int)JTraits[CurrentTrait] + 1;
+                    }
+                }
+            }
+            return JTraits;
+        }
+        public static bool isTraitMaxedOutNoSpatula(JObject JTraits, List<string> wantedTraitList)
+        {
+            foreach (string trait in wantedTraitList)
+            {
+                JArray breakpoints = Master["TraitList"][trait]["Breakpoints"] as JArray;
+                int maxTotalChamps = Master["TraitChampions"][trait].Count;
+
+                // Get the highest achievable breakpoint
+                int maxValidBP = breakpoints.Where(bp => (int)bp <= maxTotalChamps).DefaultIfEmpty(0).Max(bp => (int)bp);
+
+                if (!JTraits.ContainsKey(trait)) return false; // Trait not present at all
+
+                int result = (int)JTraits[trait];
+
+                // If the highest breakpoint is unreachable without emblems, check the previous one
+                if (maxValidBP < breakpoints.Max(bp => (int)bp))  // If there's a higher BP that we can't reach
+                {
+                    if (result != maxValidBP)
+                        return false;
+                }
+                else
+                {
+                    if (result != maxValidBP)  // Don't subtract 1, use the highest valid BP
+                        return false;
+                }
+            }
+            return true;
+        }
+
         // (test function) ensure champions with 3 or more traits have all of them active
         // note: doesn't actually produce better comps, just weird ones, but cool function to have just in case
         public static bool CarryWorth(JObject JTraits, List<string> comp)
@@ -561,7 +627,7 @@ public static List<string> GetTopTraits(List<string> championList, int depthLeve
          */
 
 
-        public static ConcurrentDictionary<List<string>, int> FindCombinations2(int CompSize, List<string> items, List<string> excluded_comp_champions, List<string> tempIncludeTrait, List<string> tempIncludeSpatula)
+        public static ConcurrentDictionary<List<string>, int> FindCombinations2(int CompSize, List<string> items, List<string> excluded_comp_champions, List<string> tempIncludeTrait, List<string> tempIncludeSpatula, string trait_snake)
         {
             var combinations = GetCombs(items.Count(), CompSize);