ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - 2c3944282ed8

Parent rev.

Child rev.

[Not reviewed]

default

0 2 0

Jason Maltzen (jmaltzen) - 9 years ago 2016-01-23 20:18:05
jason.maltzen@unsanctioned.net

Fixes for starting with a min reagent count > 1

2 files changed with 84 insertions and 28 deletions:

RecipeGenerator.cs

RecipeSearchNode.cs

0 comments (0 inline, 0 general)

RecipeGenerator.cs

➞

Show inline comments

@@ ... / @@ -222,39 +222,56 @@ namespace DesertPaintLab @@
+                    }
                     ++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.MaxQuantity = maxQuantity;
                     initialNode.MinReagents = minReagents;
                     initialNode.MaxReagents = maxReagents;
                     searchQueue.Enqueue(initialNode);
                     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: MaxQuantity={0} MinReagents={1} MaxReagents={2} FullQuantity={3} FullQuantityDepth={4}", MaxQuantity, MinReagents, MaxReagents, FullQuantity, FullQuantityDepth);
+            }
             // start worker threads to do the actual work
             ResumeRecipeGeneration();
+        }
         public void ResumeRecipeGeneration()
+        {
@@ ... / @@ -289,57 +306,60 @@ namespace DesertPaintLab @@
                 generatorThreads.Add(thr);
+            }
             foreach (Thread thr in generatorThreads)
+            {
                 thr.Start();
+            }
+        }
         public bool SaveState(string file)
+        {
             if (running)
+            {
                 // can't save state while running
                 return false;
+            }
-            using (StreamWriter writer = new StreamWriter(file, false))
+            lock(workerLock)
+            {
                 writer.WriteLine("MinReagents: {0}", MinReagents);
                 writer.WriteLine("MaxReagents: {0}", MaxReagents);
                 writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);
                 writer.WriteLine("FullQuantity: {0}", FullQuantity);
                 writer.WriteLine("TotalReagents: {0}", totalReagents);
                 writer.WriteLine("RecipeCount: {0}", recipeCount);
                 writer.WriteLine("SearchType: {0}", Mode.ToString());
                 foreach (KeyValuePair<string, PaintRecipe> pair in recipes)
                 using (StreamWriter writer = new StreamWriter(file, false))
+                {
                     PaintRecipe recipe = pair.Value;
                     string colorName = Palette.FindNearest(recipe.ReactedColor);
                     writer.WriteLine("BeginRecipe: {0}", colorName);
                     foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)
                     writer.WriteLine("MinReagents: {0}", MinReagents);
                     writer.WriteLine("MaxReagents: {0}", MaxReagents);
                     writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);
                     writer.WriteLine("FullQuantity: {0}", FullQuantity);
                     writer.WriteLine("TotalReagents: {0}", totalReagents);
                     writer.WriteLine("RecipeCount: {0}", recipeCount);
                     writer.WriteLine("SearchType: {0}", Mode.ToString());
                     foreach (KeyValuePair<string, PaintRecipe> pair in recipes)
+                    {
                         writer.WriteLine("Ingredient: {0}={1}", ingredient.name, ingredient.quantity);
                         PaintRecipe recipe = pair.Value;
                         string colorName = Palette.FindNearest(recipe.ReactedColor);
                         writer.WriteLine("BeginRecipe: {0}", colorName);
                         foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)
+                        {
                             writer.WriteLine("Ingredient: {0}={1}", ingredient.name, ingredient.quantity);
+                        }
                         writer.WriteLine("EndRecipe: {0}", colorName);
+                    }
                     writer.WriteLine("EndRecipe: {0}", colorName);
                     writer.WriteLine("SearchNodes: {0}", searchQueue.Count);
                     foreach (RecipeSearchNode node in searchQueue)
+                    {
                         node.SaveState(writer);
+                   }
+                }
                 writer.WriteLine("SearchNodes: {0}", searchQueue.Count);
                 foreach (RecipeSearchNode node in searchQueue)
+                {
                     node.SaveState(writer);
+               }
+            }
             return true;
+        }
         static Regex keyValueRegex = new Regex(@"(?<key>\w+)\:\s*(?<value>.+)\s*");
         static Regex ingredientRegex = new Regex(@"(?<ingredient>(\w+\s)*\w+)\s*=\s*(?<quantity>\d)\s*");
         public bool LoadState(string file)
+        {
             // cannot be running, and reactions must be set
             if (running)
+            {
                 return false;
+            }
             InitSortedReagents();
             bool success = true;
@@ ... / @@ -671,111 +691,117 @@ namespace DesertPaintLab @@
             uint newQuantity;
             uint quantityLimit = ((uint)node.ReagentCount <= FullQuantityDepth) ? ((uint)node.ReagentCount * FullQuantity) : node.MaxQuantity;
             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); } }
                         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
             // increase recipe depth
             // next reagent in last position
             // if at end, pop reagent
             //Console.WriteLine("Finding new recipe after quantity {0}/{1} used {2}", newQuantity, node.MaxQuantity, node.UsedQuantity);
             node.InitForQuantity(10+node.CatalystCount); // reset quantity
             int currentDepth = node.ReagentCount;
             bool recipeFound = false;
             uint nextReagent;
             do {
                 //Console.WriteLine("Current depth: {0}/{1}", currentDepth, node.MaxReagents);
                 do {
                     recipeFound = false;
                     // back out until we find a node that can be incremented
-                    if (currentDepth > node.MinReagents)
+                    if (currentDepth > minReagents)
+                    {
-                        while (node.ReagentCount > node.MinReagents)
+                        while (node.ReagentCount > minReagents)
+                        {
                             if (node.LastReagent < (totalReagents - 1))
+                            {
                                 nextReagent = node.NextFreeReagent(node.LastReagent);
                                 if (nextReagent < totalReagents)
+                                {
                                     //Console.WriteLine("Replace last reagent with {0}", nextReagent);
                                     node.ReplaceLastReagent(nextReagent);
                                     break;
+                                }
                                 else
+                                {
                                     // shouldn't happen
                                     //Console.WriteLine("No available reagents at depth {0}!", node.ReagentCount);
                                     node.RemoveLastReagent();
-                                    if (node.ReagentCount == node.MinReagents)
+                                    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); } }
+                                    }
+                                }
+                            }
                             else
+                            {
                                 //Console.WriteLine("Pop last reagent");
                                 node.RemoveLastReagent();
-                                if (node.ReagentCount == node.MinReagents)
+                                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); } }
+                                }
+                            }
+                        }
                         // fill in the nodes up to the current depth
-                        if (node.ReagentCount >= node.MinReagents)
+                        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); } }
                                     recipeFound = false;
+                                }
+                            }
+                        }
+                    }
                     //Console.WriteLine("Catalysts: {0} Reagents: {1} Min: {2}", node.CatalystCount, node.ReagentCount, node.MinReagents);
-                } while ((node.CatalystCount >= node.ReagentCount) && (node.ReagentCount >= node.MinReagents)); // make sure to skip all-catalyst combinations
+                } 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); } }
+                }
-            } while (currentDepth <= node.MaxReagents);
+            } while (currentDepth <= maxReagents);
             if (recipeFound)
+            {
                 node.InitForQuantity(10+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)

RecipeSearchNode.cs

➞

Show inline comments

@@ ... / @@ -81,32 +81,62 @@ namespace DesertPaintLab @@
             set
+            {
                 maxReagents = value;
                 currentWeights = new uint[maxReagents];
+            }
+        }
         uint[] currentWeights;
         public uint[] CurrentWeights
+        {
             get
+            {
                 return currentWeights;
+            }
+        }
         public RecipeSearchNode(RecipeSearchNode other)
+        {
             this.costSortedReagents = new List<Reagent>(other.costSortedReagents);
             this.reagents = new uint[costSortedReagents.Count];
             INVALID_REAGENT = (uint)costSortedReagents.Count;
             for (int i = 0; i < costSortedReagents.Count; ++i)
+            {
                 this.reagents[i] = other.reagents[i];
+            }
             reagentInUse = new bool[costSortedReagents.Count];
             for (uint i = 0; i < costSortedReagents.Count; ++i)
+            {
                 reagentInUse[i] = other.reagentInUse[i];
+            }
             nextReagentPos = other.nextReagentPos;
             CurrentTargetQuantity = other.CurrentTargetQuantity;
             MaxQuantity = other.MaxQuantity;
             UsedQuantity = other.UsedQuantity;
             CatalystCount = other.CatalystCount;
             FullQuantityDepth = other.FullQuantityDepth;
             FullQuantity = other.FullQuantity;
             MinReagents = other.MinReagents;
             MaxReagents = other.MaxReagents;
             for (int i = 0; i < MaxReagents; ++i)
+            {
                 currentWeights[i] = other.currentWeights[i];
+            }
+        }
         public RecipeSearchNode(List<Reagent> costSortedReagents, uint[] reagents)
+        {
             this.costSortedReagents = new List<Reagent>(costSortedReagents);
             this.reagents = new uint[costSortedReagents.Count];
             INVALID_REAGENT = (uint)costSortedReagents.Count;
             nextReagentPos = reagents.Length;
             for (int i = this.reagents.Length-1; i >= this.reagents.Length; --i)
+            {
                 reagents[i] = INVALID_REAGENT;
+            }
             for (int i = reagents.Length-1; i >= 0; --i)
+            {
                 this.reagents[i] = reagents[i];
                 if (reagents[i] == INVALID_REAGENT)
+                {
                     nextReagentPos = i;

0 comments (0 inline, 0 general)