ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - 339712c9aa0a

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Jason Maltzen (jmaltzen) - 9 years ago 2015-12-26 04:08:57
jason.maltzen@unsanctioned.net

Fix up a crash that can happen one resume if ingredients are disabled between recipe generation runs.

1 file changed with 14 insertions and 11 deletions:

RecipeGenerator.cs

0 comments (0 inline, 0 general)

RecipeGenerator.cs

➞

Show inline comments

@@ ... / @@ -57,731 +57,734 @@ namespace DesertPaintLab @@
     public class RecipeGenerator
+    {
         protected class SearchNode
+        {
             //int initialReagentCount;
             uint[] reagents;
             public uint[] Reagents
+            {
                 get
+                {
                     return reagents;
+                }
+            }
             uint INVALID_REAGENT;
             int nextReagentPos;
             public int ReagentCount
+            {
                 get
+                {
                     return nextReagentPos;
+                }
+            }
             bool[] reagentInUse;
             List<Reagent> costSortedReagents;
             PaintRecipe testRecipe = null;
             public PaintRecipe TestRecipe
+            {
                 get
+                {
                     return testRecipe;
+                }
                 set
+                {
                     testRecipe = value;
+                }
+            }
             public int InitialCount { get; private set; }
             public uint CurrentTargetQuantity { get; set; }
             public uint MaxQuantity { get; set; }
             public uint UsedQuantity { get; private set; }
             public uint CatalystCount { get; set; }
             uint maxReagents;
             public uint MaxReagents
+            {
                 get
+                {
                     return maxReagents;
+                }
                 set
+                {
                     maxReagents = value;
                     currentWeights = new uint[maxReagents];
+                }
+            }
             uint[] currentWeights;
             public uint[] CurrentWeights
+            {
                 get
+                {
                     return currentWeights;
+                }
+            }
             public SearchNode(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;
+                    }
+                }
                 reagentInUse = new bool[costSortedReagents.Count];
                 for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+                {
                     reagentInUse[reagentIdx] = false;
+                }
                 foreach (uint reagentIdx in this.reagents)
+                {
                     if (reagentIdx != INVALID_REAGENT)
+                    {
                         reagentInUse[reagentIdx] = true;
+                    }
+                }
                 InitialCount = nextReagentPos;
                 MaxReagents = (uint)nextReagentPos; // better set this later!
                 UsedQuantity = 0;
+            }
             // top-level search
             public SearchNode(List<Reagent> costSortedReagents, uint startReagent)
+            {
                 this.costSortedReagents = new List<Reagent>(costSortedReagents);
                 this.reagents = new uint[costSortedReagents.Count];
                 INVALID_REAGENT = (uint)costSortedReagents.Count;
                 nextReagentPos = 0;
                 for (int i = 0; i < reagents.Length; ++i)
+                {
                     this.reagents[i] = INVALID_REAGENT;
+                }
                 reagentInUse = new bool[costSortedReagents.Count];
                 for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+                {
                     reagentInUse[reagentIdx] = false;
+                }
                 this.reagents[nextReagentPos++] = NextFreeReagent(startReagent);
                 InitialCount = 1; // don't iterate up beyond the start reagent
                 MaxReagents = 1;
                 UsedQuantity = 0;
+            }
             public SearchNode(List<Reagent> costSortedReagents)
+            {
                 this.costSortedReagents = costSortedReagents;
                 this.reagents = new uint[costSortedReagents.Count];
                 INVALID_REAGENT = (uint)costSortedReagents.Count;
                 nextReagentPos = 0;
                 for (int i = 0; i < reagents.Length; ++i)
+                {
                     this.reagents[i] = INVALID_REAGENT;
+                }
                 reagentInUse = new bool[costSortedReagents.Count];
                 for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+                {
                     reagentInUse[reagentIdx] = false;
+                }
                 this.reagents[nextReagentPos++] = NextFreeReagent(0);
                 InitialCount = 0;
                 MaxReagents = 1;
                 UsedQuantity = 0;
+            }
             public Reagent Reagent(int idx)
+            {
                 return costSortedReagents[(int)reagents[idx]];
+            }
             public uint LastReagent
+            {
                 get
+                {
                     return reagents[nextReagentPos - 1];
+                }
+            }
             public void RemoveLastReagent()
+            {
                 uint reagentIdx = reagents[nextReagentPos-1];
                 ReleaseReagent(reagentIdx);
                 if (costSortedReagents[(int)reagentIdx].IsCatalyst)
+                {
                     --CatalystCount;
+                }
                 reagents[nextReagentPos-1] = INVALID_REAGENT;
                 --nextReagentPos;
+            }
             public void ReplaceLastReagent(uint reagentIdx)
+            {
                 uint oldReagentIdx = reagents[nextReagentPos-1];
                 ReleaseReagent(oldReagentIdx);
                 reagents[nextReagentPos-1] = reagentIdx;
                 if (costSortedReagents[(int)oldReagentIdx].IsCatalyst)
+                {
                     --CatalystCount;
+                }
                 if (costSortedReagents[(int)reagentIdx].IsCatalyst)
+                {
                     ++CatalystCount;
+                }
+            }
             public uint NextFreeReagent(uint startIdx)
+            {
                 uint idx = startIdx;
                 for (; idx < costSortedReagents.Count; ++idx)
+                {
                     bool inUse = reagentInUse[idx];
                     if (inUse == false)
+                    if ((inUse == false) && (costSortedReagents[(int)idx].Enabled))
+                    {
                         //Console.WriteLine("Found free reagent idx {0}", idx);
                         reagentInUse[idx] = true;
                         return idx;
+                    }
+                }
                 //Console.WriteLine("Failed to find free reagent.");
                 return (uint)costSortedReagents.Count;
+            }
             private void ReleaseReagent(uint reagentIdx)
+            {
                 reagentInUse[reagentIdx] = false;
+            }
             public bool AddNextReagent()
+            {
                 bool ok = (nextReagentPos < MaxReagents);
                 if (ok)
+                {
                     uint nextReagent = NextFreeReagent(0);
                     reagents[nextReagentPos++] = nextReagent;
                     if (costSortedReagents[(int)nextReagent].IsCatalyst)
+                    {
                         ++CatalystCount;
+                    }
                     InitForQuantity(CurrentTargetQuantity);
+                }
                 return ok;
+            }
             public void InitForQuantity(uint quantity)
+            {
                 //System.Console.WriteLine("Target quantity: {0}, reagent count: {1}", quantity, reagents.Count);
                 CurrentTargetQuantity = quantity;
                 if (CurrentTargetQuantity < (10 + CatalystCount))
+                {
                     return;
+                }
                 UsedQuantity = 0;
                 uint remainingReagents = ((uint)nextReagentPos - CatalystCount);
                 uint remainingWeight = CurrentTargetQuantity - CatalystCount;
                 for (int i = 0; i < nextReagentPos; ++i)
+                {
                     Reagent reagent = Reagent(i);
                     if (reagent.IsCatalyst)
+                    {
                         currentWeights[i] = 1;
                         ++UsedQuantity;
+                    }
                     else
+                    {
                         uint weight = (uint)Math.Min(remainingWeight - (remainingReagents-1), reagent.RecipeMax);
                         remainingWeight -= weight;
                         currentWeights[i] = weight;
                         UsedQuantity += weight;
+                    }
                     --remainingReagents;
+                }
+            }
             public void SetWeight(int idx, uint quantity)
+            {
                 UsedQuantity -= currentWeights[idx];
                 currentWeights[idx] = quantity;
                 UsedQuantity += quantity;
+            }
             public void SaveState(StreamWriter writer)
+            {
                 writer.WriteLine("---SearchNode---");
                 writer.WriteLine("MaxReagents: {0}", MaxReagents);
                 writer.WriteLine("Reagents: {0}", nextReagentPos);
                 for (int i = 0; i < nextReagentPos; ++i)
+                {
                     uint idx = reagents[i];
                     uint weight = currentWeights[i];
                     writer.WriteLine("Reagent: {0},{1},{2}", idx, reagentInUse[idx] ? 1 : 0, weight);
+                }
                 // pulled from parent: List<Reagent> costSortedReagents;
                 // new on construct: PaintRecipe testRecipe = null;
                 writer.WriteLine("CurrentTargetQuantity: {0}", CurrentTargetQuantity);
                 writer.WriteLine("MaxQuantity: {0}", MaxQuantity);
                 writer.WriteLine("UsedQuantity: {0}", UsedQuantity);
                 writer.WriteLine("CatalystCount: {0}", CatalystCount);
                 writer.WriteLine("InitialCount: {0}", InitialCount);
                 writer.WriteLine("---EndNode---");
+            }
             static Regex keyValueRegex = new Regex(@"(\w+)\:\s*(.*)\s*$");
             static Regex reagentPartsRegex = new Regex(@"(?<id>\d+),(?<inUse>\d+),(?<weight>\d+)");
             public bool LoadState(StreamReader reader)
+            {
                 string line = reader.ReadLine();
                 if (!line.Equals("---SearchNode---"))
+                {
                     return false;
+                }
                 bool success = true;
                 Match match;
                 while ((line = reader.ReadLine()) != null)
+                {
                     if (line.Equals("---EndNode---"))
+                    {
                         break;
+                    }
                     match = keyValueRegex.Match(line);
                     if (match.Success)
+                    {
                         switch (match.Groups[1].Value)
+                        {
                             case "Reagents":
+                                {
                                     //int reagentCount = int.Parse(match.Groups[2].Value);
                                     for (int i = 0; i < reagents.Length; ++i)
+                                    {
                                         reagents[i] = INVALID_REAGENT;
                                         reagentInUse[i] = false;
+                                    }
                                     nextReagentPos = 0;
+                                }
                                 break;
                             case "Reagent":
+                                {
                                     Match reagentInfo = reagentPartsRegex.Match(match.Groups[2].Value);
                                     if (reagentInfo.Success)
+                                    {
                                         uint reagentId = uint.Parse(reagentInfo.Groups["id"].Value);
                                         int isInUse = int.Parse(reagentInfo.Groups["inUse"].Value);
                                         uint weight = uint.Parse(reagentInfo.Groups["weight"].Value);
                                         reagents[nextReagentPos] = reagentId;
                                         currentWeights[nextReagentPos] = weight;
                                         if (isInUse != 0)
+                                        {
                                             reagentInUse[reagentId] = true;
                                             if (reagentId != INVALID_REAGENT)
+                                            {
                                                 reagentInUse[reagentId] = true;
+                                            }
+                                        }
                                         ++nextReagentPos;
+                                    }
                                     else
+                                    {
                                         success = false;
+                                    }
+                                }
                                 break;
                             case "CurrentTargetQuantity":
+                                {
                                     uint value = uint.Parse(match.Groups[2].Value);
                                     CurrentTargetQuantity = value;
+                                }
                                 break;
                             case "MaxQuantity":
+                                {
                                     uint value = uint.Parse(match.Groups[2].Value);
                                     MaxQuantity = value;
+                                }
                                 break;
                             case "MaxReagents":
+                                {
                                     uint value = uint.Parse(match.Groups[2].Value);
                                     MaxReagents = value;
+                                }
                                 break;
                             case "UsedQuantity":
+                                {
                                     uint value = uint.Parse(match.Groups[2].Value);
                                     UsedQuantity = value;
+                                }
                                 break;
                             case "CatalystCount":
+                                {
                                     uint value = uint.Parse(match.Groups[2].Value);
                                     CatalystCount = value;
+                                }
                                 break;
                             case "InitialCount":
+                                {
                                     int value = int.Parse(match.Groups[2].Value);
                                     InitialCount = value;
+                                }
                                 break;
                             default:
                                 success = false;
                                 break;
+                        }
+                    }
                     else
+                    {
                         success = false;
                         break;
+                    }
+                }
                 return success;
+            }
+        }
         const uint DEFAULT_MAX_QUANTITY = 14; // minimum recipe: 10 base + 4 catalysts
         const uint DEFAULT_MAX_REAGENTS = 5;
         //uint maxQuantity; // maximum number of total ingredients
         uint maxReagents; // maximum number of reagents to use in the recipe
         uint fullQuantityDepth; // at or equal this number of reagents, ignore ingredient settings for max quantity
         uint fullQuantity;  // The max number of a reagent to use at full quantity
         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<SearchNode> searchQueue = new ConcurrentQueue<SearchNode>();
         int recipeCount = 0;
         List<Thread> generatorThreads = new List<Thread>();
         Object workerLock = new Object();
         bool requestCancel = false;
         // events
         public event EventHandler Finished;
         public event EventHandler Progress;
         public event EventHandler<NewRecipeEventArgs> NewRecipe;
         public RecipeGenerator(ReactionSet reactions)
+        {
             this.reactions = reactions;
             foreach (PaintColor color in Palette.Colors)
+            {
                 recipes.Add(color.Name, new PaintRecipe());
                 recipeCosts.Add(color.Name, uint.MaxValue);
+            }
+        }
         public SortedDictionary<string, PaintRecipe> Recipes
+        {
             get
+            {
                 return recipes;
+            }
+        }
         public int RecipeCount
+        {
             get
+            {
                 return recipeCount;
+            }
+        }
         public bool CanResume
+        {
             get
+            {
                 return (!running && (searchQueue.Count > 0));
+            }
+        }
         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;
+            }
             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);
                 if (reagent.Enabled)
+                {
                     costSortedReagents.Add(reagent);
+                }
                 costSortedReagents.Add(reagent);
+            }
             costSortedReagents.Sort(new ReagentCostSort());
+        }
         public void BeginRecipeGeneration(uint maxQuantity, uint maxReagents, uint fullQuantityDepth, uint fullQuantity)
+        {
             if (running)
+            {
                 // Already running - don't start again
                 return;
+            }
             //this.maxQuantity = maxQuantity;
             this.maxReagents = maxReagents;
             this.fullQuantity = fullQuantity;
             this.fullQuantityDepth = fullQuantityDepth;
             // first, sort reagents by cost.
             InitSortedReagents();
             this.maxReagents = (uint)Math.Min(costSortedReagents.Count, this.maxReagents);
             totalReagents = (uint)costSortedReagents.Count;
             // Pre-populate recipes list with:
             // 1) 1-ingredient recipes @ 10db for all enabled ingredients with a count >= 10
             // 2) any previously-generated recipes
             PaintRecipe recipe = new PaintRecipe();
             recipe.Reactions = reactions;
             foreach (Reagent reagent in costSortedReagents)
+            {
                 if (!reagent.IsCatalyst && reagent.RecipeMax >= 10)
+                if (!reagent.IsCatalyst && reagent.RecipeMax >= 10 && reagent.Enabled)
+                {
                     recipe.Clear();
                     recipe.AddReagent(reagent.Name, 10);
                     AddCheapestRecipe(recipe);
+                }
+            }
             while (!searchQueue.IsEmpty)
+            {
                 SearchNode node;
                 searchQueue.TryDequeue(out node);
+            }
             for (uint reagentIdx = 0; reagentIdx < costSortedReagents.Count; ++reagentIdx)
+            {
                 SearchNode initialNode = new SearchNode(costSortedReagents, reagentIdx);
                 initialNode.MaxQuantity = maxQuantity;
                 initialNode.MaxReagents = maxReagents;
                 searchQueue.Enqueue(initialNode);
                 if (costSortedReagents[(int)reagentIdx].Enabled)
+                {
                     SearchNode initialNode = new SearchNode(costSortedReagents, reagentIdx);
                     initialNode.MaxQuantity = maxQuantity;
                     initialNode.MaxReagents = maxReagents;
                     searchQueue.Enqueue(initialNode);
+                }
+            }
             // 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;
             //System.Console.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(costSortedReagents.Count, searchQueue.Count);
             if (threadCount == 0)
+            {
                 if (Finished != null)
+                {
                     Finished(this, null);
+                }
+            }
             generatorThreads.Clear();
             for (int i = 0; i < threadCount; ++i)
+            {
                 Thread thr = new Thread(new ThreadStart(this.Generate));
                 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))
+            {
                 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);
                 foreach (KeyValuePair<string, PaintRecipe> pair in recipes)
+                {
                     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("SearchNodes: {0}", searchQueue.Count);
                 foreach (SearchNode 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;
             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 "MaxReagents":
                                 maxReagents = uint.Parse(value);
                                 break;
                             case "FullQuantityDepth":
                                 fullQuantityDepth = uint.Parse(value);
                                 break;
                             case "FullQuantity":
                                 fullQuantity = uint.Parse(value);
                                 break;
                             case "TotalReagents":
                                 totalReagents = uint.Parse(value);
                                 break;
                             case "RecipeCount":
                                 recipeCount = int.Parse(value);
                                 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)
+                                {
                                     SearchNode node = new SearchNode(costSortedReagents);
                                     success = success && node.LoadState(reader);
                                     if (success)
+                                    {
                                         searchQueue.Enqueue(node);
+                                    }
+                                }
                                 break;
                             default:
                                 success = false;
                                 break;
+                        }
+                    }
                     else
+                    {
                         success = false;
                         break;
+                    }
+                }
                 return success;
+            }
+        }
         private void Generate()
+        {
             SearchNode node;
             lock(workerLock)
+            {
                 ++runningThreads;
+            }
             bool ok = true;
             do
+            {
                 lock (workerLock)
+                {
                     ok = searchQueue.TryDequeue(out node);
+                }
                 if (ok)
+                {
                     uint targetQuantity = node.MaxQuantity + 1;
                     do {

0 comments (0 inline, 0 general)