ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - 3463e3d12e78

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Jason Maltzen (jmaltzen) - 6 years ago 2018-05-18 18:07:15
jason.maltzen@unsanctioned.net

Fix a bug where recipe generation could use up to 1 more than MaxConcentration

1 file changed with 17 insertions and 8 deletions:

RecipeGenerator.cs

0 comments (0 inline, 0 general)

RecipeGenerator.cs

➞

Show inline comments

@@ ... / @@ -64,256 +64,264 @@ namespace DesertPaintLab @@
         public SearchType Mode { get; set; }
         public uint MinConcentration { get; private set; } // minimum paint concentration
         public uint MaxConcentration { get; private set; } // maximum paint concentration
         public uint MaxReagents { get; private set; } // maximum number of reagents to use in the recipe
         public uint MinReagents { get; private set; } // minimum number of reagents to use in the recipe
         public uint FullQuantityDepth { get; private set; } // at or equal this number of reagents, ignore ingredient settings for max quantity
         public uint FullQuantity { get; private set; }  // The max number of a reagent to use at full quantity
         public uint MaxThreads { get; set; }
         ReactionSet reactions;
         bool running = false;
         int runningThreads = 0;
         SortedDictionary<string, uint> recipeCosts = new SortedDictionary<string, uint>();
         SortedDictionary<string, PaintRecipe> recipes = new SortedDictionary<string, PaintRecipe>();
         uint totalReagents;
         List<Reagent> costSortedReagents = new List<Reagent>();
         ConcurrentQueue<RecipeSearchNode> searchQueue = new ConcurrentQueue<RecipeSearchNode>();
         ulong recipeCount = 0;
         List<Thread> generatorThreads = new List<Thread>();
         Object workerLock = new Object();
         bool requestCancel = false;
         StreamWriter log;
         // events
         public event EventHandler Finished;
         public event EventHandler Progress;
         public event EventHandler<NewRecipeEventArgs> NewRecipe;
         public RecipeGenerator(ReactionSet reactions)
+        {
             Mode = SearchType.BREADTH_FIRST;
             this.reactions = reactions;
             foreach (PaintColor color in Palette.Colors)
+            {
                 recipes.Add(color.Name, new PaintRecipe());
                 recipeCosts.Add(color.Name, uint.MaxValue);
+            }
             MinReagents = 1;
             MaxReagents = 5;
             MinConcentration = 10;
             MaxConcentration = 20;
+        }
         public SortedDictionary<string, PaintRecipe> Recipes
+        {
             get
+            {
                 return recipes;
+            }
+        }
         public ulong RecipeCount
+        {
             get
+            {
                 return recipeCount;
+            }
+        }
         public bool CanResume
+        {
             get
+            {
                 return (!running && (searchQueue.Count > 0));
+            }
+        }
         public string Log
+        {
             set
+            {
                 if (value != null)
+                {
                     log = new StreamWriter(value);
+                }
                 else
+                {
                     log = null;
+                }
+            }
+        }
         private class ReagentCostSort : IComparer<Reagent>
+        {
             public int Compare(Reagent reagent1, Reagent reagent2)
+            {
                 return (int)reagent1.Cost - (int)reagent2.Cost;
+            }
+        }
         public void InitRecipes(SortedDictionary<string, PaintRecipe> initialRecipes)
+        {
             if (running)
+            {
                 return;
+            }
             recipeCosts.Clear();
             recipes.Clear();
             foreach (PaintRecipe recipe in initialRecipes.Values)
+            {
                 //PaintRecipe recipeCopy = new PaintRecipe(recipe);
                 AddCheapestRecipe(recipe);
+            }
+        }
         private void InitSortedReagents()
+        {
             costSortedReagents.Clear();
             foreach (string name in ReagentManager.Names)
+            {
                 Reagent reagent = ReagentManager.GetReagent(name);
                 costSortedReagents.Add(reagent);
+            }
             costSortedReagents.Sort(new ReagentCostSort());
+        }
         // Generate paint recipes.
         // minConcentration - the minimum permitted concentration in a recipe (10 for paint, 50 for ribbons)
         // maxConcentration - the maximum concentrataion for a recipe
         // minReagents - the minimum number of ingredients in a recipe
         // maxReagents - the maximum number of ingredients allowed in a recipe
         // fullQuantityDepth - at this depth of ingredient or below, allow up to fullQuantity of any reagent
         // fullQuantity - the maximum amount of any reagent to permit up to the full quantity depth. After that, reagents are limited by the
         //                per-reagent value
         public void BeginRecipeGeneration(uint minConcentration, uint maxConcentration, uint minReagents, uint maxReagents, uint fullQuantityDepth, uint fullQuantity)
+        {
             if (running)
+            {
                 // Already running - don't start again
                 return;
+            }
             this.MinConcentration = minConcentration;
             this.MaxConcentration = maxConcentration;
             this.MinReagents = minReagents;
             this.MaxReagents = maxReagents;
             this.FullQuantity = fullQuantity;
             this.FullQuantityDepth = fullQuantityDepth;
             // first, sort reagents by cost.
             InitSortedReagents();
             totalReagents = (uint)costSortedReagents.Count;
             // Pre-populate recipes list with:
             // 1) 1-ingredient recipes @ min concentration for all enabled ingredients with a count >= min concentration
             // 2) any previously-generated recipes
             int enabledReagentCount = 0;
             PaintRecipe recipe = new PaintRecipe();
             recipe.Reactions = reactions;
             foreach (Reagent reagent in costSortedReagents)
+            {
                 if (reagent.Enabled)
+                {
                     if (!reagent.IsCatalyst && ((reagent.RecipeMax >= minConcentration) || ((FullQuantityDepth > 0) && (FullQuantity >= minConcentration))))
+                    {
                         recipe.Clear();
                         recipe.AddReagent(reagent.Name, minConcentration);
                         AddCheapestRecipe(recipe);
+                    }
                     ++enabledReagentCount;
+                }
+            }
             this.MaxReagents = (uint)Math.Min(enabledReagentCount, this.MaxReagents);
             this.MinReagents = (uint)Math.Min(this.MinReagents, this.MaxReagents);
             while (!searchQueue.IsEmpty)
+            {
                 RecipeSearchNode node;
                 searchQueue.TryDequeue(out node);
+            }
             for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+            {
                 if (costSortedReagents[(int)reagentIdx].Enabled)
+                {
                     // queue up all combinations of MinReagents
                     RecipeSearchNode initialNode = new RecipeSearchNode(costSortedReagents, reagentIdx);
                     initialNode.FullQuantity = FullQuantity;
                     initialNode.FullQuantityDepth = FullQuantityDepth;
                     initialNode.MinConcentration = minConcentration;
                     initialNode.MaxConcentration = maxConcentration;
                     initialNode.MinReagents = minReagents;
                     initialNode.MaxReagents = maxReagents;
                     if (MinReagents > 1)
+                    {
                         while (NextReagentSetBreadthFirst(initialNode, 1, minReagents) == true)
+                        {
                             if (initialNode.ReagentCount == minReagents)
+                            {
                                 //Console.WriteLine("Initial node at size {0}/{1} with recipe: {2}", initialNode.ReagentCount, minReagents, initialNode.TestRecipe.ToString());
                                 RecipeSearchNode searchNode = new RecipeSearchNode(initialNode);
                                 searchQueue.Enqueue(searchNode);
+                            }
+                        }
+                    }
                     else
+                    {
                         searchQueue.Enqueue(initialNode);
+                    }
+                }
+            }
             recipeCount = 0;
             if (log != null)
+            {
                 log.WriteLine("Begin recipe generation: MaxConcentration={0} MinReagents={1} MaxReagents={2} FullQuantity={3} FullQuantityDepth={4}", MaxConcentration, MinReagents, MaxReagents, FullQuantity, FullQuantityDepth);
+            }
             // start worker threads to do the actual work
             ResumeRecipeGeneration();
+        }
         public void ResumeRecipeGeneration()
+        {
             if (running)
+            {
                 // Already running - don't start again
                 return;
+            }
             running = true;
             requestCancel = false;
             if (log != null)
+            {
                 log.WriteLine("Resuming recipe generation: pre-threads={0} reagent count={1} search queue={2}", runningThreads, costSortedReagents.Count, searchQueue.Count);
+            }
             runningThreads = 0; // presumably!
             int threadCount = Math.Min(Math.Min(costSortedReagents.Count, searchQueue.Count), (int)MaxThreads);
             if (threadCount == 0)
+            {
                 if (Finished != null)
+                {
                     Finished(this, null);
+                }
+            }
             generatorThreads.Clear();
             System.Console.WriteLine("Starting {0} generator threads.", threadCount);
             for (int i = 0; i < threadCount; ++i)
+            {
                 Thread thr = new Thread(new ThreadStart(this.Generate));
                 thr.Priority = ThreadPriority.BelowNormal;
                 generatorThreads.Add(thr);
+            }
             foreach (Thread thr in generatorThreads)
+            {
                 thr.Start();
+            }
+        }
@@ ... / @@ -367,286 +375,287 @@ namespace DesertPaintLab @@
                 return false;
+            }
             InitSortedReagents();
             bool success = true;
             PaintRecipe currentRecipe = null;
             Match match;
             string line;
             using (StreamReader reader = new StreamReader(file, false))
+            {
                 while (success && ((line = reader.ReadLine()) != null))
+                {
                     match = keyValueRegex.Match(line);
                     if (match.Success)
+                    {
                         string value = match.Groups["value"].Value;
                         switch(match.Groups["key"].Value)
+                        {
                             case "MinReagents":
                                 MinReagents = uint.Parse(value);
                                 MaxReagents = (uint)Math.Max(this.MinReagents, this.MaxReagents);
                                 break;
                             case "MaxReagents":
                                 MaxReagents = uint.Parse(value);
                                 MinReagents = (uint)Math.Min(this.MinReagents, this.MaxReagents);
                                 break;
                             case "FullQuantityDepth":
                                 FullQuantityDepth = uint.Parse(value);
                                 break;
                             case "FullQuantity":
                                 FullQuantity = uint.Parse(value);
                                 break;
                             case "TotalReagents":
                                 totalReagents = uint.Parse(value);
                                 break;
                             case "RecipeCount":
                                 if (!ulong.TryParse(value, out recipeCount))
+                                {
                                     // must have rolled to negative - try as an int and convert
                                     int recipeCountInt = int.Parse(value);
                                     recipeCount = (ulong)((long)recipeCountInt & 0x00000000ffffffffL);
+                                }
                                 break;
                             case "BeginRecipe":
                                 currentRecipe = new PaintRecipe();
                                 currentRecipe.Reactions = reactions;
                                 break;
                             case "EndRecipe":
                                 if (currentRecipe != null)
+                                {
                                     PaintColor color = currentRecipe.ReactedColor;
                                     uint cost = currentRecipe.Cost;
                                     recipes[color.Name] = currentRecipe; // replace
                                     recipeCosts[color.Name] = cost;
                                     currentRecipe = null;
+                                }
                                 break;
                             case "Ingredient":
                                 if (currentRecipe != null)
+                                {
                                     Match ingredientMatch = ingredientRegex.Match(match.Groups["value"].Value);
                                     if (ingredientMatch.Success)
+                                    {
                                         uint quantity = uint.Parse(ingredientMatch.Groups["quantity"].Value);
                                         currentRecipe.AddReagent(ingredientMatch.Groups["ingredient"].Value, quantity);
+                                    }
                                     else
+                                    {
                                         success = false;
+                                    }
+                                }
                                 break;
                             case "SearchNodes":
                                 int nodeCount = int.Parse(match.Groups["value"].Value);
                                 for (int i = 0; i < nodeCount; ++i)
+                                {
                                     RecipeSearchNode node = new RecipeSearchNode(costSortedReagents);
                                     node.FullQuantity = FullQuantity;
                                     node.FullQuantityDepth = FullQuantityDepth;
                                     node.MinReagents = MinReagents;
                                     node.MaxReagents = MaxReagents;
                                     node.MaxConcentration = MaxConcentration;
                                     success = success && node.LoadState(reader);
                                     if (success)
+                                    {
                                         searchQueue.Enqueue(node);
+                                    }
+                                }
                                 break;
                             case "SearchType":
                                 Mode = (SearchType)Enum.Parse(typeof(SearchType), match.Groups["value"].Value);
                                 break;
                             default:
                                 success = false;
                                 break;
+                        }
+                    }
                     else
+                    {
                         success = false;
                         break;
+                    }
+                }
                 return success;
+            }
+        }
         private void Generate()
+        {
             RecipeSearchNode node;
             lock(workerLock)
+            {
                 ++runningThreads;
+            }
             bool ok = true;
             do
+            {
                 lock (workerLock)
+                {
                     ok = searchQueue.TryDequeue(out node);
+                }
                 if (ok)
+                {
                     if (Mode == SearchType.DEPTH_FIRST)
+                    {
                         uint targetQuantity = (node.ReagentCount <= FullQuantityDepth) ? ((uint)node.ReagentCount * FullQuantity) : node.MaxConcentration + 1;
                         uint targetQuantity = (node.ReagentCount <= FullQuantityDepth)
                             ? ((uint)node.ReagentCount * FullQuantity)
                             : node.MaxConcentration + 1;
                         do {
                             --targetQuantity;
                             node.InitForQuantity(targetQuantity);
                         } while (targetQuantity > MinConcentration && (node.CurrentTargetQuantity != node.UsedQuantity));
                         while ((ok = IterateDepthFirst(node)) && !requestCancel)
+                        {
                             if (Progress != null)
+                            {
                                 Progress(this, null);
+                            }
+                        }
+                    }
                     else
+                    {
                         // breadth-first search
                         uint targetQuantity = MinConcentration-1;
                         uint quantityLimit = (node.ReagentCount <= FullQuantityDepth) ? (FullQuantity * (uint)node.ReagentCount) : node.MaxConcentration;
                         uint targetQuantity = MinConcentration - 1;
                         uint quantityLimit = (node.ReagentCount <= FullQuantityDepth)
                             ? (FullQuantity * (uint)node.ReagentCount)
                             : node.MaxConcentration;
                         do {
                             ++targetQuantity;
                             node.InitForQuantity(targetQuantity);
-                        } while ((targetQuantity <= quantityLimit) && (node.CurrentTargetQuantity != node.UsedQuantity));
                         } while ((targetQuantity < quantityLimit) && (node.CurrentTargetQuantity != node.UsedQuantity));
                         while ((ok = IterateBreadthFirst(node)) && !requestCancel)
+                        {
                             if (Progress != null)
+                            {
                                 Progress(this, null);
+                            }
                             Progress?.Invoke(this, null);
+                        }
+                    }
                     if (ok)
+                    {
                         // stopped because cancel was requested - requeue the node in its current state for resume
                         searchQueue.Enqueue(node);
+                    }
+                }
             } while (!requestCancel && ok);
             bool done = false;
             lock(workerLock)
+            {
                 --runningThreads;
                 //generatorThreads.Remove(Thread.CurrentThread);
                 done = (runningThreads == 0);
+            }
             if (done)
+            {
                 running = false;
                 requestCancel = false;
                 if (Finished != null)
+                {
                     Finished(this, null);
+                }
+            }
+        }
         // Add the cheapest recipe to the recipe list
         // returns the discarded recipe from the pair (or null if no original recipe to replace)
         private void AddCheapestRecipe(PaintRecipe recipe)
+        {
             if (recipe.IsValidForConcentration(MinConcentration))
+            {
                 recipe.Reactions = reactions;
                 string colorName = Palette.FindNearest(recipe.ReactedColor);
                 //System.Console.WriteLine("Recipe: {0} {1}:", colorName, recipe.Cost);
                 //foreach (PaintRecipe.RecipeIngredient ingr in recipe.Ingredients)
                 //{
                 //    System.Console.WriteLine("    -> {0} {1}", ingr.quantity, ingr.name);
                 //}
                 uint cost;
                 lock (workerLock)
+                {
                     if (recipeCosts.TryGetValue(colorName, out cost))
+                    {
                         if (cost > recipe.Cost)
+                        {
                             recipes[colorName].CopyFrom(recipe);
                             recipeCosts[colorName] = recipe.Cost;
                             if (NewRecipe != null)
+                            {
                                 NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);
                                 NewRecipe(this, args);
+                            }
+                        }
                         else
+                        {
                             Console.WriteLine("Ignoring recipe - existing cost is cheaper.");
+                        }
+                    }
                     else
+                    {
                         // This would be an error!
                         recipeCosts.Add(colorName, recipe.Cost);
                         recipes.Add(colorName, new PaintRecipe(recipe));
                         if (NewRecipe != null)
+                        {
                             NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);
                             NewRecipe(this, args);
+                        }
+                    }
+                }
+            }
             else
+            {
                 string msg = String.Format("Recipe is invalid ({0} ingredients)\n", recipe.Ingredients.Count);
                 foreach (PaintRecipe.RecipeIngredient ingr in recipe.Ingredients)
+                {
                     msg += String.Format("    -> {0} {1}", ingr.quantity, ingr.name);
+                }
                 lock (workerLock) {
                     Console.WriteLine(msg);
+                }
+            }
+        }
         private bool IterateDepthFirst(RecipeSearchNode node)
+        {
             TestCurrentRecipe(node);
             // pick recipe quantities at current recipe ingredients/size
             if (NextRecipe(node))
+            {
                 lock(workerLock)
+                {
                     ++recipeCount;
+                }
                 //System.Console.WriteLine("Found next recipe at size {0} qty {1}", node.Reagents.Count, node.CurrentTargetQuantity);
                 return true;
+            }
             if (NextRecipeSize(node))
+            {
                 //System.Console.WriteLine("Found next recipe size {0}", node.CurrentTargetQuantity);
                 return true;
+            }
             // Search for next ingredient combo - all quantity combos for previous were searched
             //System.Console.WriteLine("Finding next ingredient combo");
             do
+            {
                 if (!node.AddNextReagent())
+                {
                     while ((node.ReagentCount > node.MinReagents) && (node.LastReagent == (totalReagents-1)))
+                    {
                         node.RemoveLastReagent();
+                    }
                     if (node.ReagentCount == node.MinReagents)
+                    {
                         // done
                         return false;
+                    }
                     uint nextReagent = node.NextFreeReagent(node.LastReagent);
                     while ((node.ReagentCount > node.MinReagents) && (nextReagent >= totalReagents))
+                    {

0 comments (0 inline, 0 general)