ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - 66a2d6c441ac

Parent rev.

Child rev.

[Not reviewed]

default

0 2 0

Jason Maltzen (jmaltzen) - 7 years ago 2018-05-21 20:05:00
jason.maltzen@unsanctioned.net

Add a debug log to paint recipe generation

2 files changed with 35 insertions and 24 deletions:

RecipeGenerator.cs

UI/RecipeGeneratorView.cs

0 comments (0 inline, 0 general)

RecipeGenerator.cs

➞

Show inline comments

@@ ... / @@ -574,58 +574,59 @@ namespace DesertPaintLab @@
                 //{
                 //    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;
                             log?.WriteLine("New recipe (cost {0}): {1}", recipe.Cost, recipe);
                             if (NewRecipe != null)
+                            {
                                 NewRecipeEventArgs args = new NewRecipeEventArgs(colorName, recipe);
                                 NewRecipe(this, args);
+                            }
+                        }
                         else
+                        {
                             Console.WriteLine("Ignoring recipe - existing cost is cheaper.");
+                        }
                         //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);
+                }
                 //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)
+                {
@@ ... / @@ -708,25 +709,25 @@ namespace DesertPaintLab @@
             // Try next quantity
             uint newQuantity;
             uint quantityLimit = ((uint)node.ReagentCount <= FullQuantityDepth) ? ((uint)node.ReagentCount * FullQuantity) : node.MaxConcentration;
             do {
                 newQuantity = node.CurrentTargetQuantity + 1;
                 //Console.WriteLine("Try quantity {0}", newQuantity);
                 if (newQuantity <= quantityLimit)
+                {
                     node.InitForQuantity(newQuantity);
                     if (node.CurrentTargetQuantity <= node.UsedQuantity)
+                    {
                         if (log != null) { lock(log) { log.WriteLine("Update quantity to {0}", node.CurrentTargetQuantity); } }
+                        //if (log != null) { lock(log) { log.WriteLine("Update quantity to {0}", node.CurrentTargetQuantity); } }
                         return true;
+                    }
+                }
             } while (newQuantity < quantityLimit);
             bool ok = NextReagentSetBreadthFirst(node, node.MinReagents, node.MaxReagents);
             return ok;
+        }
         private bool NextReagentSetBreadthFirst(RecipeSearchNode node, uint minReagents, uint maxReagents)
+        {
             // search all variants at this depth of recipe
@@ ... / @@ -757,86 +758,86 @@ namespace DesertPaintLab @@
                                     node.ReplaceLastReagent(nextReagent);
                                     break;
+                                }
                                 else
+                                {
                                     // shouldn't happen
                                     //Console.WriteLine("No available reagents at depth {0}!", node.ReagentCount);
                                     node.RemoveLastReagent();
                                     if (node.ReagentCount == minReagents)
+                                    {
                                         // just popped the last reagent at the top level
                                         ++currentDepth;
                                         if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1}", currentDepth, node.MaxReagents); } }
+                                        //if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1}", currentDepth, node.MaxReagents); } }
+                                    }
+                                }
+                            }
                             else
+                            {
                                 //Console.WriteLine("Pop last reagent");
                                 node.RemoveLastReagent();
                                 if (node.ReagentCount == minReagents)
+                                {
                                     // just popped the last reagent at the top level
                                     ++currentDepth;
                                     if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [pop last reagent at top level]", currentDepth, node.MaxReagents); } }
+                                    //if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [pop last reagent at top level]", currentDepth, node.MaxReagents); } }
+                                }
+                            }
+                        }
                         // fill in the nodes up to the current depth
                         if (node.ReagentCount >= minReagents && currentDepth <= maxReagents)
+                        {
                             recipeFound = true;
                             while (node.ReagentCount < currentDepth)
+                            {
                                 if (! node.AddNextReagent())
+                                {
                                     if (log != null) { lock(log) { log.WriteLine("Failed to reagent {0}/{1}", node.ReagentCount+1, currentDepth); } }
+                                    //if (log != null) { lock(log) { log.WriteLine("Failed to add reagent {0}/{1}", node.ReagentCount+1, currentDepth); } }
                                     recipeFound = false;
+                                }
+                            }
+                        }
+                    }
                     //Console.WriteLine("Catalysts: {0} Reagents: {1} Min: {2}", node.CatalystCount, node.ReagentCount, node.MinReagents);
                 } while ((node.CatalystCount >= node.ReagentCount) && (node.ReagentCount >= minReagents)); // make sure to skip all-catalyst combinations
                 if (recipeFound)
+                {
                     break;
+                }
                 else
+                {
                     ++currentDepth;
                     if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [no recipe]", currentDepth, node.MaxReagents); } }
+                    //if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [no recipe]", currentDepth, node.MaxReagents); } }
+                }
             } while (currentDepth <= maxReagents);
             if (recipeFound)
+            {
                 node.InitForQuantity(node.MinConcentration+node.CatalystCount); // minimum quantity for this recipe
                 if (node.TestRecipe == null)
+                {
                     node.TestRecipe = new PaintRecipe();
                     node.TestRecipe.Reactions = reactions;
+                }
                 node.TestRecipe.Clear();
                 for (int i = 0; i < node.ReagentCount; ++i)
+                {
                     node.TestRecipe.AddReagent(node.Reagent(i).Name, node.CurrentWeights[i]);
+                }
                 if (log != null) {
                     string combo = "";
                     foreach (PaintRecipe.RecipeIngredient ingr in node.TestRecipe.Ingredients)
+                    {
                         combo += " " + ingr.name;
+                    }
                     lock(log) { log.WriteLine("New ingredients: " + combo); }
                     //string combo = "";
                     //foreach (PaintRecipe.RecipeIngredient ingr in node.TestRecipe.Ingredients)
                     //{
                     //    combo += " " + ingr.name;
                     //}
                     //lock(log) { log.WriteLine("New ingredients: " + combo); }
+                }
+            }
             return recipeFound;
+        }
         private void TestCurrentRecipe(RecipeSearchNode node)
+        {
             if (node.TestRecipe == null)
+            {
                 node.TestRecipe = new PaintRecipe();
                 node.TestRecipe.Reactions = reactions;
@@ ... / @@ -848,25 +849,25 @@ namespace DesertPaintLab @@
+            }
             AddCheapestRecipe(node.TestRecipe);
             //if (log != null) { lock(log) { log.WriteLine("Tested recipe: {0}", node.TestRecipe); } }
+        }
         private bool NextRecipe(RecipeSearchNode node)
+        {
             // check for the next recipe
             uint remainingWeight = node.CurrentTargetQuantity - node.CatalystCount;
             if (remainingWeight < MinConcentration)
+            {
                 // not possible to make a valid recipe
                 Console.WriteLine("Insufficient remaining weight");
+                //Console.WriteLine("Insufficient remaining weight");
                 return false;
+            }
             //uint remainingReagents = (uint)node.Reagents.Count - node.CatalystCount;
             uint depth = (uint)node.ReagentCount;
             uint weightToConsume = 0;
             uint spaceBelow = 0;
             int reagentsBelow = 0;
             for (int i = (int)depth-1 ; i >= 0; --i)
+            {
                 uint currentWeight = node.CurrentWeights[i];

UI/RecipeGeneratorView.cs

➞

Show inline comments

@@ ... / @@ -232,24 +232,34 @@ namespace DesertPaintLab @@
             fullQuantitySpinButton.Adjustment.Upper = 30;
             if (generator == null)
+            {
                 generator = new RecipeGenerator(profile.Reactions);
                 int threads;
                 DesertPaintLab.AppSettings.Get("GeneratorThreads", out threads);
                 if (threads <= 0) { threads = 15; }
                 generator.MaxThreads = (uint)threads;
                 generator.Progress += OnProgress;
                 generator.Finished += OnFinished;
                 generator.NewRecipe += OnNewRecipe;
                 bool enableDebugMenu = false;
                 DesertPaintLab.AppSettings.Get("EnableDebugMenu", out enableDebugMenu);
                 bool logGenerator = false;
                 DesertPaintLab.AppSettings.Get("GeneratorLog", out logGenerator);
                 if (enableDebugMenu && logGenerator)
+                {
                     string logDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
                     generator.Log = System.IO.Path.Combine(logDir, "dpl_generator.txt");
+                }
+            }
             generator.InitRecipes(profile.Recipes);
             string stateFile = System.IO.Path.Combine(profile.Directory, PAINT_STATE_FILE);
             if (System.IO.File.Exists(stateFile))
+            {
                 generator.LoadState(stateFile);
                 if (generator.CanResume)
+                {
                     beginButton.Label = "Restart";
                     stopResumeButton.Label = "Resume";
                     stopResumeButton.Sensitive = true;

0 comments (0 inline, 0 general)