ATITD-Tools/Desert-Paint-Lab Changeset

Changeset - 0b17df70395d

Parent rev.

Child rev.

[Not reviewed]

Merge default

0 1 0

Jason Maltzen (jmaltzen) - 7 years ago 2018-05-18 01:25:48
jason.maltzen@unsanctioned.net

Merge

1 file changed with 57 insertions and 8 deletions:

PlayerProfile.cs

0 comments (0 inline, 0 general)

PlayerProfile.cs

➞

Show inline comments

@@ ... / @@ -319,277 +319,326 @@ namespace DesertPaintLab @@
+			{
 				// If there is an ingredients file, move it in.
 				System.IO.File.Copy(
 				    System.IO.Path.Combine(importDir, "ingredients.txt"),
 				    System.IO.Path.Combine(directory, "ingredients.txt"),
 				    true);
+			}
 			catch (Exception)
+			{
 				// If there is no ingredients file, we don't really care.
+			}
+		}
         public void Import(string file)
+        {
             ZipFile.ExtractToDirectory(file, directory);
+        }
 		public void Export(string file)
+		{
             ZipFile.CreateFromDirectory(directory, file);
+		}
 		public bool Load()
+		{
 			string line;
             settings.Reset();
             settings.Load(settingsFile);
 			reactions.Clear();
             if (File.Exists(reagentFile))
+            {
     			ReagentManager.LoadProfileReagents(reagentFile);
+            }
             else
+            {
                 LastError = "Failed to find profile reagents file.";
                 return false;
+            }
 			ReagentManager.InitializeReactions(ref reactions);
             if (!File.Exists(reactFile))
+            {
                 LastError = "Failed to find profile reactions file.";
                 return false;
+            }
 			using (StreamReader reader = new StreamReader(reactFile))
+			{
 				while ((line = reader.ReadLine()) != null)
+               	{
 					string[] tokens = line.Split(null);
                     Reagent reagent1 = ReagentManager.GetReagent(tokens[0]);
                     Reagent reagent2 = ReagentManager.GetReagent(tokens[1]);
 					reactions.Set(reagent1, reagent2, new Reaction(int.Parse(tokens[2]), int.Parse(tokens[3]), int.Parse(tokens[4])));
+				}
+			}
             return true;
+		}
 		public void Save()
+		{
             settings.Save(settingsFile);
 			Reaction reaction;
 			using (StreamWriter writer = new StreamWriter(reactFile, false))
+			{
                 foreach (string reagentName1 in ReagentManager.Names)
+                {
                     // TODO: could be more efficient by only iterating over the names after reagent1
                     foreach (string reagentName2 in ReagentManager.Names)
+                    {
                         if (reagentName1.Equals(reagentName2))
+                        {
                             continue;
+                        }
                         Reagent reagent1 = ReagentManager.GetReagent(reagentName1);
                         Reagent reagent2 = ReagentManager.GetReagent(reagentName2);
                         reaction = reactions.Find(reagent1, reagent2);
     					if (reaction != null)
+    					{
                                 writer.WriteLine(reagent1.PracticalPaintName + " " + reagent2.PracticalPaintName + " " +
     							reaction.Red + " " + reaction.Green + " " + reaction.Blue);
+    					}
+    				}
+    			}
+            }
+		}
         private void LoadRecipes(SortedDictionary<string, PaintRecipe> recipeDict, string filename, uint concentration)
+        {
             foreach (PaintRecipe recipe in recipeDict.Values)
+            {
                 recipe.Clear();
+            }
             string recipeFile = System.IO.Path.Combine(directory, filename);
             string line;
             Match match;
             bool inRecipe = false;
             PaintRecipe testRecipe = new PaintRecipe();
             testRecipe.Reactions = reactions;
             string currentRecipeColor = null;
             if (File.Exists(recipeFile))
+            {
                 using (StreamReader reader = new StreamReader(recipeFile))
+                {
                     while ((line = reader.ReadLine()) != null)
+                    {
                         match = recipeHeaderRegex.Match(line);
                         if (match.Success)
+                        {
                             if (testRecipe != null && currentRecipeColor != null)
+                            {
                                 if (testRecipe.IsValidForConcentration(concentration))
+                                {
                                     recipeDict[currentRecipeColor].CopyFrom(testRecipe);
+                                }
+                            }
                             testRecipe.Clear();
                             currentRecipeColor = match.Groups["colorname"].Value;
                             inRecipe = true;
+                        }
                         else if (inRecipe)
+                        {
                             match = recipeIngredientRegex.Match(line);
                             if (match.Success)
+                            {
                                 string ingredient = match.Groups["ingredient"].Value;
                                 uint quantity = uint.Parse(match.Groups["quantity"].Value);
                                 testRecipe.AddReagent(ingredient, quantity);
+                            }
+                        }
+                    }
                     if (inRecipe)
+                    {
                         if (testRecipe.IsValidForConcentration(concentration))
+                        {
                             recipeDict[currentRecipeColor].CopyFrom(testRecipe);
+                        }
+                    }
+                }
+            }
+        }
         private void SaveRecipes(SortedDictionary<string, PaintRecipe> recipeDict, string filename)
+        {
             if (recipeDict != null)
+            {
                 string recipeFile = System.IO.Path.Combine(directory, filename);
                 using (StreamWriter writer = new StreamWriter(recipeFile, false))
+                {
                     foreach (KeyValuePair<string, PaintRecipe> pair in recipeDict)
+                    {
                         writer.WriteLine("--- Recipe: {0}", pair.Key);
                         foreach (PaintRecipe.RecipeIngredient ingredient in pair.Value.Ingredients)
+                        {
                             writer.WriteLine("{0,-14} | {1}", ingredient.name, ingredient.quantity);
+                        }
+                    }
+                }
+            }
+        }
         public void LoadRecipes()
+        {
             LoadRecipes(this.recipes, "dp_recipes.txt", PaintRecipe.PAINT_RECIPE_MIN_CONCENTRATION);
             LoadRecipes(this.ribbonRecipes, "dp_ribbons.txt", PaintRecipe.RIBBON_RECIPE_MIN_CONCENTRATION);
+        }
         public void SaveRecipes()
+        {
             SaveRecipes(this.recipes, "dp_recipes.txt");
             SaveRecipes(this.ribbonRecipes, "dp_ribbons.txt");
+        }
         public void ExportWikiRecipes(string file)
+        {
             StreamWriter writer = new StreamWriter(file);
             ExportWikiFormat(writer, this.recipes);
+        }
         public void ExportWikiRibbons(string file)
+        {
             StreamWriter writer = new StreamWriter(file);
             ExportWikiFormat(writer, this.ribbonRecipes);
+        }
         public void ExportWikiRecipes(TextWriter writer)
+        {
             ExportWikiFormat(writer, this.recipes);
+        }
         public void ExportWikiRibbons(TextWriter writer)
+        {
             ExportWikiFormat(writer, this.ribbonRecipes);
+        }
         static public PaintColor RgbToHsv(PaintColor color)
+        {
             float h = 0;
             float s = 0;
             float r = color.Red / 255.0f;
             float g = color.Green / 255.0f;
             float b = color.Blue / 255.0f;
             float cmax = Math.Max(Math.Max(r, g), b);
             float cmin = Math.Min(Math.Min(r, g), b);
             float cd = cmax - cmin;
             if (cd == 0)
+            {
                 h = 0;
+            }
             else if (cmax == r)
+            {
                 h = (((g - b) / cd) % 6) / 6f;
+            }
             else if (cmax == g)
+            {
                 h = (((b - r) / cd) + 2) / 6f;
+            }
             else
+            {
                 h = (((r - g) / cd) + 4) / 6f;
+            }
             if (cmax == 0)
+            {
                 s = 0;
+            }
             else
+            {
                 s = cd / cmax;
+            }
             if (h < 0)
+            {
                 h = 1 + h;
+            }
             if (h >= 1)
+            {
                 h = 0;
+            }
             return new PaintColor((byte)(h * 255), (byte)(s * 255), (byte)(cmax * 255));
+        }
         public void ExportWikiFormat(TextWriter writer, SortedDictionary<string, PaintRecipe> recipeDict)
+        {
             PaintRecipe recipe;
             List<KeyValuePair<string, string>> missing = new List<KeyValuePair<string, string>>();
             using (writer)
+            {
                 writer.WriteLine("{| class='wikitable sortable' border=\"1\" style=\"background-color:#DEB887;\"");
                 writer.WriteLine("! Color !! Recipe !! Missing Reactions? || Verified");
                 foreach (PaintColor color in Palette.Colors)
+                {
                     writer.WriteLine("|-");
                     string colorLine = "| ";
                     colorLine += "style=\"font-weight: bold; background-color: #" + color.Red.ToString("X2") + color.Green.ToString("X2") + color.Blue.ToString("X2") + ";";
                     float rPortion = color.Red / 255.0f;
                     float gPortion = color.Green / 255.0f;
                     float bPortion = color.Blue / 255.0f;
                     float maxColor = Math.Max(rPortion, Math.Max(gPortion, bPortion));
                     float minColor = Math.Min(rPortion, Math.Min(gPortion, bPortion));
                     float luminance = (maxColor - minColor) * 0.5f;
                     if (luminance < 0.5f)
                     PaintColor hsvColor = RgbToHsv(color);
                     if (hsvColor.Blue < 200) // value
+                    {
                         // dark color gets light text
                         colorLine += " color: #FFFFFF;";
+                    }
                     else
+                    {
                         colorLine += "color: #000000;";
+                    }
                     colorLine += "\" | " + color.Name + " || ";
                     if (recipeDict.TryGetValue(color.Name, out recipe))
+                    {
                         foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)
+                        {
                             colorLine += " " + ingredient.ToString();
+                        }
+                    }
                     else
+                    {
                         // no recipe
+                    }
                     colorLine += " || ";
                     if (recipe.CheckMissingReactions(ref missing) == true)
+                    {
                         colorLine += "Y";
+                    }
                     else
+                    {
                         colorLine += "N";
+                    }
                     colorLine += " || N";
                     writer.WriteLine(colorLine);
+                }
                 writer.WriteLine("|}");
+            }
+        }
 		public Reaction FindReaction(Reagent reagent1, Reagent reagent2)
+		{
             return reactions.Find(reagent1, reagent2);
+		}
 		public void SetReaction(Reagent reagent1, Reagent reagent2, Reaction reaction)
+		{
             reactions.Set(reagent1, reagent2, reaction);
+		}
         public void ClearReaction(Reagent reagent1, Reagent reagent2)
+        {
             reactions.Remove(reagent1, reagent2);
+        }
         public void SetRecipe(PaintRecipe recipe)
+        {
             string colorName = Palette.FindNearest(recipe.ReactedColor);
             recipes[colorName].CopyFrom(recipe);
+        }
         public void SetRibbonRecipe(PaintRecipe recipe)
+        {
             string colorName = Palette.FindNearest(recipe.ReactedColor);
             ribbonRecipes[colorName].CopyFrom(recipe);
+        }
+	}
+}

0 comments (0 inline, 0 general)