From 693c3459b0913731487a11453153f78e6d4422c8 Mon Sep 17 00:00:00 2001 From: Alex Bahm Date: Tue, 8 Sep 2015 21:23:09 -0700 Subject: [PATCH 1/5] Added a settings page. No more XML editing! I also attempted to clean up a few areas. --- AutoLineColor/AutoLineColor.csproj | 1 + AutoLineColor/AutoLineColorMod.cs | 28 ++++++++-- AutoLineColor/Configuration.cs | 89 +++++++++++++++++++----------- AutoLineColor/Constants.cs | 11 ++++ 4 files changed, 90 insertions(+), 39 deletions(-) create mode 100644 AutoLineColor/Constants.cs diff --git a/AutoLineColor/AutoLineColor.csproj b/AutoLineColor/AutoLineColor.csproj index 46ea447..db3bb91 100644 --- a/AutoLineColor/AutoLineColor.csproj +++ b/AutoLineColor/AutoLineColor.csproj @@ -58,6 +58,7 @@ + diff --git a/AutoLineColor/AutoLineColorMod.cs b/AutoLineColor/AutoLineColorMod.cs index ab04b6f..7c5c5e3 100644 --- a/AutoLineColor/AutoLineColorMod.cs +++ b/AutoLineColor/AutoLineColorMod.cs @@ -1,21 +1,37 @@ using ICities; +using System; +using System.Collections.Generic; namespace AutoLineColor { public class AutoLineColorMod : IUserMod { + private Configuration Config; public string Name { - get { return "Auto Line Color"; } + get { return Constants.ModName; } } public string Description { - get - { - return - "Monitors all transport line looking for lines set to the default color. When found it sets a new color and a line name"; - } + get { return Constants.Description; } + } + + public void OnSettingsUI(UIHelperBase helper) { + Config = Configuration.Instance; + //Generate arrays of colors and naming strategies + String[] ColorStrategies = Enum.GetNames(typeof(ColorStrategy)); + String[] NamingStrategies = Enum.GetNames(typeof(NamingStrategy)); + + UIHelperBase group = helper.AddGroup(Constants.ModName); + group.AddDropdown("Color Strategy", ColorStrategies, (int)Config.ColorStrategy, Config.ColorStrategyChange); + group.AddDropdown("Naming Strategy", NamingStrategies, (int)Config.NamingStrategy, Config.NamingStrategyChange); + group.AddSpace(5); + + group.AddGroup("Advanced Settings"); + group.AddSlider("Max Different Color Picks", 1f, 20f, 1f, (float)Config.MaximunDifferentCollorPickAtempt, Config.MaxDiffColorPickChange); + group.AddSlider("MinColorDifference", 1f, 100f, 5f, (float)Config.MinimumColorDifferencePercentage, Config.MinColorDiffChange); + group.AddButton("Save", Config.Save); } } } \ No newline at end of file diff --git a/AutoLineColor/Configuration.cs b/AutoLineColor/Configuration.cs index 70a1b4d..3de7fa6 100644 --- a/AutoLineColor/Configuration.cs +++ b/AutoLineColor/Configuration.cs @@ -2,7 +2,6 @@ using System.IO; using System.Xml; using System.Xml.Serialization; -using ColossalFramework.IO; namespace AutoLineColor { @@ -14,45 +13,79 @@ public class Configuration public int? MinimumColorDifferencePercentage { get; set; } public int? MaximunDifferentCollorPickAtempt { get; set; } - private const string ConfigFileName = "AutoLineColorSettings.xml"; - private const string ModName = "AutoLineColor"; + private const int DefaultMaxDiffColorPickAttempt = 10; + private const int DefaultMinColorDiffPercent = 5; + + private static Configuration _instance; public static Configuration LoadConfig() { + bool isDirty = false; + Configuration config; try { var serializer = new XmlSerializer(typeof(Configuration)); - Configuration config; + var fullConfigPath = Constants.ConfigFileName; - var fullConfigPath = GetModFileName(ConfigFileName); if (File.Exists(fullConfigPath) == false) { Console.Message("No config file. Building default and writing it to " + fullConfigPath); config = GetDefaultConfig(); - SaveConfig(config); - return config; + isDirty = true; } + else + { + using (var reader = XmlReader.Create(fullConfigPath)) { + config = (Configuration)serializer.Deserialize(reader); + } + //check new configuration properties + if (!config.MaximunDifferentCollorPickAtempt.HasValue || + !config.MinimumColorDifferencePercentage.HasValue) { + + config.MaximunDifferentCollorPickAtempt = config.MaximunDifferentCollorPickAtempt.HasValue ? + config.MaximunDifferentCollorPickAtempt : DefaultMaxDiffColorPickAttempt; + config.MinimumColorDifferencePercentage = config.MinimumColorDifferencePercentage.HasValue ? + config.MinimumColorDifferencePercentage : DefaultMinColorDiffPercent; - using (var reader = XmlReader.Create(fullConfigPath)) - { - config = (Configuration)serializer.Deserialize(reader); + isDirty = true; + } } - //check new configuration properties - if (!config.MaximunDifferentCollorPickAtempt.HasValue || !config.MinimumColorDifferencePercentage.HasValue) - { - var defaultConfig = GetDefaultConfig(); - config.MinimumColorDifferencePercentage = defaultConfig.MinimumColorDifferencePercentage; - config.MaximunDifferentCollorPickAtempt = defaultConfig.MaximunDifferentCollorPickAtempt; - SaveConfig(config); - } - return config; - } catch (Exception ex) { + //Don't save changes if it failed for some reason Console.Error("Error reading configuration settings - " + ex); - return GetDefaultConfig(); + config = GetDefaultConfig(); + } + + if (isDirty) { + config.Save(); + } + + return config; + } + + public void ColorStrategyChange(int Strategy) { + this.ColorStrategy = (ColorStrategy)Strategy; + } + + public void NamingStrategyChange(int Strategy) { + this.NamingStrategy = (NamingStrategy)Strategy; + } + + public void MinColorDiffChange(float MinDiff) { + this.MinimumColorDifferencePercentage = (int)MinDiff; + } + + public void MaxDiffColorPickChange(float MaxColorPicks) { + this.MaximunDifferentCollorPickAtempt = (int)MaxColorPicks; + } + + public void Save() { + var serializer = new XmlSerializer(typeof(Configuration)); + using (var writer = XmlWriter.Create(Constants.ConfigFileName)) { + serializer.Serialize(writer, this); } } @@ -67,20 +100,11 @@ private static Configuration GetDefaultConfig() { ColorStrategy = ColorStrategy.RandomColor, NamingStrategy = NamingStrategy.Districts, - MaximunDifferentCollorPickAtempt = 10, - MinimumColorDifferencePercentage = 5 + MaximunDifferentCollorPickAtempt = DefaultMaxDiffColorPickAttempt, + MinimumColorDifferencePercentage = DefaultMinColorDiffPercent }; } - private static void SaveConfig(Configuration config) - { - var serializer = new XmlSerializer(typeof(Configuration)); - using (var writer = XmlWriter.Create(GetModFileName(ConfigFileName))) - { - serializer.Serialize(writer, config); - } - } - private static Configuration _instance; public static Configuration Instance { get @@ -92,7 +116,6 @@ public static Configuration Instance return _instance; } } - } public enum ColorStrategy diff --git a/AutoLineColor/Constants.cs b/AutoLineColor/Constants.cs new file mode 100644 index 0000000..c467361 --- /dev/null +++ b/AutoLineColor/Constants.cs @@ -0,0 +1,11 @@ +using System; + +namespace AutoLineColor { + public static class Constants { + public const string ConfigFileName = "AutoLineColorSettings.xml"; + public const string ModName = "Auto Line Color"; + public const string Description = + "Monitors all transport line looking for lines set to the default color." + + " When found it sets a new color and a line name"; + } +} From 2038615ae927900aa012999746ee206e91ad11a3 Mon Sep 17 00:00:00 2001 From: Alex Bahm Date: Wed, 9 Sep 2015 23:18:28 -0700 Subject: [PATCH 2/5] Added staged changes, updating changes in the ColorMonitor thread, and improved the logger. Changes in the settings window are no longer directly updated in game. Well, they weren't able to update without a restart until now. This allows changes to be seen in game. The console is now a singleton so it is easier to write to a log file. Which is really nice when something happens during map load and you can't see the console. --- AutoLineColor/AutoLineColorMod.cs | 6 +- AutoLineColor/ColorMonitor.cs | 60 ++++++------ AutoLineColor/Coloring/CategorisedColor.cs | 6 +- .../Coloring/CategorisedColorStrategy.cs | 1 - AutoLineColor/Coloring/RandomColor.cs | 13 +-- AutoLineColor/Coloring/RandomColorStrategy.cs | 2 +- AutoLineColor/Configuration.cs | 91 ++++++++++++++---- AutoLineColor/Console.cs | 94 ++++++++++++++++--- AutoLineColor/Constants.cs | 1 + .../Naming/DistrictNamingStrategy.cs | 3 +- AutoLineColor/Naming/GenericNames.cs | 5 +- AutoLineColor/Naming/NoNamingStrategy.cs | 4 + 12 files changed, 209 insertions(+), 77 deletions(-) diff --git a/AutoLineColor/AutoLineColorMod.cs b/AutoLineColor/AutoLineColorMod.cs index 7c5c5e3..394ce5e 100644 --- a/AutoLineColor/AutoLineColorMod.cs +++ b/AutoLineColor/AutoLineColorMod.cs @@ -7,6 +7,7 @@ namespace AutoLineColor public class AutoLineColorMod : IUserMod { private Configuration Config; + private static Console logger = Console.Instance; public string Name { get { return Constants.ModName; } @@ -22,15 +23,14 @@ public void OnSettingsUI(UIHelperBase helper) { //Generate arrays of colors and naming strategies String[] ColorStrategies = Enum.GetNames(typeof(ColorStrategy)); String[] NamingStrategies = Enum.GetNames(typeof(NamingStrategy)); - UIHelperBase group = helper.AddGroup(Constants.ModName); group.AddDropdown("Color Strategy", ColorStrategies, (int)Config.ColorStrategy, Config.ColorStrategyChange); group.AddDropdown("Naming Strategy", NamingStrategies, (int)Config.NamingStrategy, Config.NamingStrategyChange); group.AddSpace(5); group.AddGroup("Advanced Settings"); - group.AddSlider("Max Different Color Picks", 1f, 20f, 1f, (float)Config.MaximunDifferentCollorPickAtempt, Config.MaxDiffColorPickChange); - group.AddSlider("MinColorDifference", 1f, 100f, 5f, (float)Config.MinimumColorDifferencePercentage, Config.MinColorDiffChange); + group.AddSlider("Max Different Color Picks", 1f, 20f, 1f, (float)Config.MaxDiffColorPickAttempt, Config.MaxDiffColorPickChange); + group.AddSlider("MinColorDifference", 1f, 100f, 5f, (float)Config.MinColorDiffPercentage, Config.MinColorDiffChange); group.AddButton("Save", Config.Save); } } diff --git a/AutoLineColor/ColorMonitor.cs b/AutoLineColor/ColorMonitor.cs index 91ef0d0..409598f 100644 --- a/AutoLineColor/ColorMonitor.cs +++ b/AutoLineColor/ColorMonitor.cs @@ -13,29 +13,30 @@ namespace AutoLineColor { public class ColorMonitor : ThreadingExtensionBase { - private static DateTimeOffset _lastOutputTime = DateTimeOffset.Now.AddSeconds(-100); + private static DateTimeOffset _lastOutputTime = DateTimeOffset.Now; private bool _initialized; private IColorStrategy _colorStrategy; private INamingStrategy _namingStrategy; private List _usedColors; + private Configuration _config; + private static Console logger = Console.Instance; public override void OnCreated(IThreading threading) { - - Console.Message("loading auto color monitor"); - Console.Message("initializing colors"); + logger.Message("loading auto color monitor"); + logger.Message("initializing colors"); RandomColor.Initialize(); CategorisedColor.Initialize(); GenericNames.Initialize(); - Console.Message("loading current config"); - var config = Configuration.LoadConfig(); - _colorStrategy = SetColorStrategy(config.ColorStrategy); - _namingStrategy = SetNamingStrategy(config.NamingStrategy); + logger.Message("loading current config"); + _config = Configuration.Instance; + _colorStrategy = SetColorStrategy(_config.ColorStrategy); + _namingStrategy = SetNamingStrategy(_config.NamingStrategy); _usedColors = new List(); - Console.Message("Found color strategy of " + config.ColorStrategy); - Console.Message("Found naming strategy of " + config.NamingStrategy); + logger.Message("Found color strategy of " + _config.ColorStrategy); + logger.Message("Found naming strategy of " + _config.NamingStrategy); _initialized = true; @@ -45,6 +46,7 @@ public override void OnCreated(IThreading threading) private static INamingStrategy SetNamingStrategy(NamingStrategy namingStrategy) { + logger.Message("Naming Strategy: " + namingStrategy.ToString()); switch (namingStrategy) { case NamingStrategy.None: @@ -54,13 +56,14 @@ private static INamingStrategy SetNamingStrategy(NamingStrategy namingStrategy) case NamingStrategy.London: return new LondonNamingStrategy(); default: - Console.Error("unknown naming strategy"); + logger.Error("unknown naming strategy"); return new NoNamingStrategy(); } } - private static IColorStrategy SetColorStrategy(ColorStrategy colorStrategy) + private IColorStrategy SetColorStrategy(ColorStrategy colorStrategy) { + logger.Message("Color Strategy: " + colorStrategy.ToString()); switch (colorStrategy) { case ColorStrategy.RandomHue: @@ -70,7 +73,7 @@ private static IColorStrategy SetColorStrategy(ColorStrategy colorStrategy) case ColorStrategy.CategorisedColor: return new CategorisedColorStrategy(); default: - Console.Error("unknown color strategy"); + logger.Error("unknown color strategy"); return new RandomHueStrategy(); } } @@ -80,6 +83,14 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) var theTransportManager = Singleton.instance; var lines = theTransportManager.m_lines.m_buffer; + //Digest changes + if (_config.UndigestedChanges == true) { + logger.Message("Applying undigested changes"); + _colorStrategy = SetColorStrategy(_config.ColorStrategy); + _namingStrategy = SetNamingStrategy(_config.NamingStrategy); + _config.UndigestedChanges = false; + } + try { if (_initialized == false) @@ -94,8 +105,7 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) _lastOutputTime = DateTimeOffset.Now; - while (!Monitor.TryEnter(lines, SimulationManager.SYNCHRONIZE_TIMEOUT)) - { } + while (!Monitor.TryEnter(lines, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } _usedColors = lines.Where(l => l.IsActive()).Select(l => l.m_color).ToList(); @@ -103,11 +113,7 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) for (ushort counter = 0; counter < lines.Length - 1; counter++) { var transportLine = lines[counter]; -<<<<<<< Updated upstream -======= - ->>>>>>> Stashed changes if (transportLine.m_flags == TransportLine.Flags.None) continue; @@ -121,25 +127,23 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) var lineName = _namingStrategy.GetName(transportLine); var color = _colorStrategy.GetColor(transportLine, _usedColors); - Console.Message(string.Format("New line found. {0} {1}", lineName, color)); - if (!transportLine.HasCustomColor() || transportLine.m_color.IsDefaultColor()) { // set the color transportLine.m_color = color; transportLine.m_flags |= TransportLine.Flags.CustomColor; - } - else - { - Console.Message(transportLine.m_color.ToString()); + logger.Message(string.Format("Changed line color. '{0}' {1} -> {2}", lineName, transportLine.m_color, color)); } if (string.IsNullOrEmpty(lineName) == false && transportLine.HasCustomName() == false) { logger.Message("New line name time!"); // set the name - Singleton.instance.SetName(new InstanceID { TransportLine = counter }, - lineName); + var line = Singleton.instance; + var instanceID = new InstanceID { TransportLine = counter }; + logger.Message(string.Format("Renamed Line '{0}' -> '{1}'", line.GetName(instanceID), lineName)); + + line.SetName(instanceID, lineName); transportLine.m_flags |= TransportLine.Flags.CustomName; } @@ -148,7 +152,7 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) } catch (Exception ex) { - Console.Message(ex.ToString(), PluginManager.MessageType.Message); + logger.Error(ex.ToString()); } finally { diff --git a/AutoLineColor/Coloring/CategorisedColor.cs b/AutoLineColor/Coloring/CategorisedColor.cs index 2279155..d530c52 100644 --- a/AutoLineColor/Coloring/CategorisedColor.cs +++ b/AutoLineColor/Coloring/CategorisedColor.cs @@ -53,7 +53,7 @@ class CategorisedColor private const string DefaultPaleColors = "#bccaff, #ffbcbc, #bcffd2, #d6bcff, #fffbbc, #bcddff, #ffbcc6, #bcf7bd, #c2bcff, #ffe4bc, #bcf3ff, #ffbce0, #c7ffbc, #bcbcff, #ffc1bc, #bcffe8, #f5bcff, #daffbc, #a6baff, #ffa6a6, #a6ffc4, #cba6ff, #fffaa6, #a6d3ff, #ffa6b5, #a6f5a8, #afa6ff, #ffdda6, #a6efff, #ffa6d7, #b6ffa6, #a6a7ff, #ffaea6, #a6ffe1, #f3a6ff, #d0ffa6, #7f9eff, #ff7f7f, #7fffae, #b77fff, #fff97f, #7fc3ff, #ff7f97, #7ff282, #8d7fff, #ffd17f, #7feaff, #ff7fc9, #97ff7f, #7f80ff, #ff8c7f, #7fffd7, #ef7fff, #bfff7f"; private const string DefaultDarkColors = "#7f2200, #007f64, #75007f, #527f00, #00377f, #7f0100, #007f45, #4c007f, #7f7b00, #00567f, #7f002f, #007710, #24007f, #7f6000, #00727f, #7f005a, #307f00, #000a7f"; - + private static Console logger = Console.Instance; private static List _bright_colors; private static List _pale_colors; private static List _dark_colors; @@ -80,13 +80,13 @@ private static List BuildColorList(string defaultColorList, string file } else { - Console.Message("No colors found, writing default values to " + fullPath); + logger.Message("No colors found, writing default values to " + fullPath); File.WriteAllText(fullPath, unparsedColors); } } catch (Exception ex) { - Console.Error("error reading colors from disk " + ex); + logger.Error("error reading colors from disk " + ex); } // split on new lines, commas and semi-colons diff --git a/AutoLineColor/Coloring/CategorisedColorStrategy.cs b/AutoLineColor/Coloring/CategorisedColorStrategy.cs index c51770c..7f6b963 100644 --- a/AutoLineColor/Coloring/CategorisedColorStrategy.cs +++ b/AutoLineColor/Coloring/CategorisedColorStrategy.cs @@ -19,7 +19,6 @@ public Color32 GetColor(TransportLine transportLine) } } - public Color32 GetColor(TransportLine transportLine, System.Collections.Generic.List usedColors) { switch (transportLine.Info.m_transportType) diff --git a/AutoLineColor/Coloring/RandomColor.cs b/AutoLineColor/Coloring/RandomColor.cs index 1d7922d..c1b2af4 100644 --- a/AutoLineColor/Coloring/RandomColor.cs +++ b/AutoLineColor/Coloring/RandomColor.cs @@ -17,6 +17,7 @@ class RandomColor private const string DefaultGreenColors = "#6af500, #54b807, #7ad633, #8df53d, #467a1f, #66a832, #629939, #527a33, #87c756, #b6f587, #75995a, #a9d687, #97b87f, #738a62, #349912, #54d629, #3d8a24, #56b835, #83f55d, #87e667, #70b858, #629950, #8ed676, #7fb86c, #567a49, #b8f5a4, #087a00, #13a808, #2f7a2a, #45a83e, #427a3e, #a0f59a, #9cd698, #0be625, #3ed650, #4ef562, #6bd678, #7ff58d, #65b86f, #57995f, #79b880, #547a59, #06b83b, #048a2c, #2ab855, #28994a, #49e678, #2f8a4a, #367a4a, #74d691, #89f5a9, #5d996f, #93e6ac, #7fb890, #98d6ab"; private const string DefaultOrangeColors = "#a80000, #c70202, #e51515, #991212, #c71c1c, #e52c2c, #b82727, #992525, #f52f02, #b82504, #991f03, #e5411c, #99311a, #b84025, #f55d3b, #d65133, #b84402, #f55e07, #d65911, #99400c, #c7632a, #a85525, #f57d38, #e58005, #c76f04, #a86718, #f5992a, #c7812c, #996423, #997000, #b88806, #f5bc20, #d6a51e, #a88628, #d6c400, #a89c16, #f5e322, #c7ba2c"; + private static Console logger = Console.Instance; private static Dictionary _colors; public static void Initialize() @@ -49,13 +50,13 @@ private static Color32[] BuildColorList(string defaultColorList, string fileName } else { - Console.Message("No colors found, writing default values to " + fullPath); + logger.Message("No colors found, writing default values to " + fullPath); File.WriteAllText(fullPath, unparsedColors); } } catch (Exception ex) { - Console.Error("error reading colors from disk " + ex); + logger.Error("error reading colors from disk " + ex); } // split on new lines, commas and semi-colons @@ -117,7 +118,7 @@ public static Color32 GetColor(ColorFamily colorFamily, List usedColors color = GetColor(colorFamily); difference = CompareColorWithUsedColors(usedColors, color); - } while (difference < Configuration.Instance.MinimumColorDifferencePercentage && (atempts < Configuration.Instance.MaximunDifferentCollorPickAtempt)); + } while (difference < Configuration.Instance.MinColorDiffPercentage && (atempts < Configuration.Instance.MaxDiffColorPickAttempt)); if (difference <= 0) { @@ -130,7 +131,7 @@ public static Color32 GetColor(ColorFamily colorFamily, List usedColors { color = colorItem; differentColorFound = true; - Console.Message(string.Format("Color not repeated: {0} Color2: {2} Diference: {1}", color, CompareColorWithUsedColors(usedColors, color), usedColor)); + logger.Message(string.Format("Color not repeated: {0} Color2: {2} Diference: {1}", color, CompareColorWithUsedColors(usedColors, color), usedColor)); break; } } @@ -140,7 +141,7 @@ public static Color32 GetColor(ColorFamily colorFamily, List usedColors } - Console.Message(string.Format("Diference: {0} Atempts: {1}", difference, atempts)); + logger.Message(string.Format("Diference: {0} Atempts: {1}", difference, atempts)); return color; } @@ -176,7 +177,7 @@ public static double CompareColors(Color32 color1, Color32 color2) var p = d / Math.Sqrt((255) ^ 2 + (255) ^ 2 + (255) ^ 2 ); if (Math.Abs(p) <= 0) - Console.Message(string.Format("Color1: {1} Color2: {2} D: {0}", d, color1, color2)); + logger.Message(string.Format("Color1: {1} Color2: {2} D: {0}", d, color1, color2)); return p * 100; } } diff --git a/AutoLineColor/Coloring/RandomColorStrategy.cs b/AutoLineColor/Coloring/RandomColorStrategy.cs index 286f239..5e8d57e 100644 --- a/AutoLineColor/Coloring/RandomColorStrategy.cs +++ b/AutoLineColor/Coloring/RandomColorStrategy.cs @@ -9,7 +9,7 @@ public Color32 GetColor(TransportLine transportLine) { return RandomColor.GetColor(ColorFamily.Any); } - + public Color32 GetColor(TransportLine transportLine, System.Collections.Generic.List usedColors) { return RandomColor.GetColor(ColorFamily.Any, usedColors); diff --git a/AutoLineColor/Configuration.cs b/AutoLineColor/Configuration.cs index 3de7fa6..7b78f74 100644 --- a/AutoLineColor/Configuration.cs +++ b/AutoLineColor/Configuration.cs @@ -10,13 +10,22 @@ public class Configuration { public ColorStrategy ColorStrategy { get; set; } public NamingStrategy NamingStrategy { get; set; } - public int? MinimumColorDifferencePercentage { get; set; } - public int? MaximunDifferentCollorPickAtempt { get; set; } + public int? MinColorDiffPercentage { get; set; } + public int? MaxDiffColorPickAttempt { get; set; } + public volatile bool UndigestedChanges; + + //Staged changes. These are not applied until 'Save' is clicked + private ColorStrategy? StagedColorStrategy { get; set; } + private NamingStrategy? StagedNamingStrategy { get; set; } + private int? StagedMinColorDiffPercentage { get; set; } + private int? StagedMaxDiffColorPickAttempt { get; set; } + private const int DefaultMaxDiffColorPickAttempt = 10; private const int DefaultMinColorDiffPercent = 5; private static Configuration _instance; + private static Console logger = Console.Instance; public static Configuration LoadConfig() { @@ -29,24 +38,26 @@ public static Configuration LoadConfig() if (File.Exists(fullConfigPath) == false) { - Console.Message("No config file. Building default and writing it to " + fullConfigPath); + logger.Message("No config file. Building default and writing it to " + fullConfigPath); config = GetDefaultConfig(); isDirty = true; } else { + logger.Message("Config file exists. Using it"); using (var reader = XmlReader.Create(fullConfigPath)) { config = (Configuration)serializer.Deserialize(reader); } //check new configuration properties - if (!config.MaximunDifferentCollorPickAtempt.HasValue || - !config.MinimumColorDifferencePercentage.HasValue) { - - config.MaximunDifferentCollorPickAtempt = config.MaximunDifferentCollorPickAtempt.HasValue ? - config.MaximunDifferentCollorPickAtempt : DefaultMaxDiffColorPickAttempt; - config.MinimumColorDifferencePercentage = config.MinimumColorDifferencePercentage.HasValue ? - config.MinimumColorDifferencePercentage : DefaultMinColorDiffPercent; + if (!config.MaxDiffColorPickAttempt.HasValue || + !config.MinColorDiffPercentage.HasValue) { + + config.UndigestedChanges = false; + config.MaxDiffColorPickAttempt = config.MaxDiffColorPickAttempt.HasValue ? + config.MaxDiffColorPickAttempt : DefaultMaxDiffColorPickAttempt; + config.MinColorDiffPercentage = config.MinColorDiffPercentage.HasValue ? + config.MinColorDiffPercentage : DefaultMinColorDiffPercent; isDirty = true; } @@ -55,7 +66,7 @@ public static Configuration LoadConfig() catch (Exception ex) { //Don't save changes if it failed for some reason - Console.Error("Error reading configuration settings - " + ex); + logger.Error("Error reading configuration settings - " + ex); config = GetDefaultConfig(); } @@ -67,23 +78,68 @@ public static Configuration LoadConfig() } public void ColorStrategyChange(int Strategy) { - this.ColorStrategy = (ColorStrategy)Strategy; + this.StagedColorStrategy = (ColorStrategy)Strategy; } public void NamingStrategyChange(int Strategy) { - this.NamingStrategy = (NamingStrategy)Strategy; + this.StagedNamingStrategy = (NamingStrategy)Strategy; } public void MinColorDiffChange(float MinDiff) { - this.MinimumColorDifferencePercentage = (int)MinDiff; + this.StagedMinColorDiffPercentage = (int)MinDiff; } public void MaxDiffColorPickChange(float MaxColorPicks) { - this.MaximunDifferentCollorPickAtempt = (int)MaxColorPicks; + this.StagedMaxDiffColorPickAttempt = (int)MaxColorPicks; } public void Save() { var serializer = new XmlSerializer(typeof(Configuration)); + + logger.Message("Saving changes to config file"); + + //If any changes have occured, apply them, otherwise keep the current value + this.ColorStrategy = this.StagedColorStrategy.HasValue + ? this.StagedColorStrategy.Value + : this.ColorStrategy; + this.NamingStrategy = this.StagedNamingStrategy.HasValue + ? this.StagedNamingStrategy.Value + : this.NamingStrategy; + this.MaxDiffColorPickAttempt = + this.StagedMaxDiffColorPickAttempt.HasValue + ? this.StagedMaxDiffColorPickAttempt.Value + : this.MaxDiffColorPickAttempt; + this.MinColorDiffPercentage = + this.StagedMinColorDiffPercentage.HasValue + ? this.StagedMinColorDiffPercentage.Value + : this.MinColorDiffPercentage; + + //clear changes and log + if (this.StagedColorStrategy.HasValue) { + logger.Message("ColorStrategy changed to " + this.StagedColorStrategy.Value.ToString()); + this.StagedColorStrategy = null; + } + + if (this.StagedNamingStrategy.HasValue) { + logger.Message("NamingStrategy changed to " + this.StagedNamingStrategy.Value.ToString()); + this.StagedNamingStrategy = null; + } + + if (this.StagedMaxDiffColorPickAttempt.HasValue) { + logger.Message("MaxDiffColorPickAttempt changed to " + this.StagedMaxDiffColorPickAttempt.Value.ToString()); + this.StagedMaxDiffColorPickAttempt = null; + } + + if (this.StagedMinColorDiffPercentage.HasValue) { + logger.Message("MinColorDiffPercentage changed to " + this.StagedMinColorDiffPercentage.Value.ToString()); + this.StagedMinColorDiffPercentage = null; + } + + //How we let the ColorMonitor thread know to update the strategies + logger.Message("Marking undigested changes"); + this.UndigestedChanges = true; + + //Save to disk using (var writer = XmlWriter.Create(Constants.ConfigFileName)) { serializer.Serialize(writer, this); } @@ -100,8 +156,9 @@ private static Configuration GetDefaultConfig() { ColorStrategy = ColorStrategy.RandomColor, NamingStrategy = NamingStrategy.Districts, - MaximunDifferentCollorPickAtempt = DefaultMaxDiffColorPickAttempt, - MinimumColorDifferencePercentage = DefaultMinColorDiffPercent + MaxDiffColorPickAttempt = DefaultMaxDiffColorPickAttempt, + MinColorDiffPercentage = DefaultMinColorDiffPercent, + UndigestedChanges = false }; } diff --git a/AutoLineColor/Console.cs b/AutoLineColor/Console.cs index 9e38bd3..e69ef51 100644 --- a/AutoLineColor/Console.cs +++ b/AutoLineColor/Console.cs @@ -4,39 +4,103 @@ using System.IO; using System.Linq; using System.Text; +using UnityEngine; namespace AutoLineColor { - public static class Console + public class Console { #if DEBUG - private static bool debug = true; + private bool debug = true; #else - private static bool debug = false; + private bool debug = false; #endif + private static Console _instance; - public static void Message(string p, PluginManager.MessageType messageType) + private StreamWriter log; + private bool log_opened; + + private Console() { + try { + log = new StreamWriter(new FileStream(Constants.LogFileName, FileMode.Append | FileMode.Create, FileAccess.Write, FileShare.ReadWrite)); + } catch (Exception e) { + WriteMessage("Could not open log file", PluginManager.MessageType.Warning); + } + log_opened = true; + } + + public static Console Instance { - if (!debug) - return; + get + { + if (_instance == null) + { + _instance = new Console(); + } + return _instance; + } + } - DebugOutputPanel.AddMessage(messageType, p); + private static string FormatMessage(string msg, PluginManager.MessageType Type) + { + string formatted; + try { + formatted = string.Format("{0}({1}) {2}", "[AutoLineColor]", Type.ToString(), msg); + } catch (Exception e) { + DebugOutputPanel.AddMessage(PluginManager.MessageType.Error, e.ToString()); + formatted = msg; + } + return formatted; } - public static void Message(string p) + public void Message(string p, PluginManager.MessageType messageType) { - if (!debug) - return; + this.WriteMessage(p, messageType); + } + + public void Message(string p) + { + this.WriteMessage(p, PluginManager.MessageType.Message); + } - DebugOutputPanel.AddMessage(PluginManager.MessageType.Message, p); + public void Warning(string p) { + this.WriteMessage(p, PluginManager.MessageType.Warning); } - internal static void Error(string p) + public void Error(string p) { - if (!debug) - return; + this.WriteMessage(p, PluginManager.MessageType.Error); + } - DebugOutputPanel.AddMessage(PluginManager.MessageType.Error, p); + private void WriteMessage(string p, PluginManager.MessageType Type) { + if(!this.debug) + { + return; + } + string msg = FormatMessage(p, Type); + DebugOutputPanel.AddMessage(Type, msg); + if (log_opened) { + log.WriteLine(msg); + log.Flush(); + } + + //Unity engine logger + switch(Type) + { + case PluginManager.MessageType.Error: + Debug.LogError(msg); + break; + case PluginManager.MessageType.Message: + Debug.Log(msg); + break; + case PluginManager.MessageType.Warning: + Debug.LogWarning(msg); + break; + default: + Debug.Log(msg); + break; + } + } } } diff --git a/AutoLineColor/Constants.cs b/AutoLineColor/Constants.cs index c467361..b90767a 100644 --- a/AutoLineColor/Constants.cs +++ b/AutoLineColor/Constants.cs @@ -3,6 +3,7 @@ namespace AutoLineColor { public static class Constants { public const string ConfigFileName = "AutoLineColorSettings.xml"; + public const string LogFileName = "AutoLineColorSettings.log"; public const string ModName = "Auto Line Color"; public const string Description = "Monitors all transport line looking for lines set to the default color." + diff --git a/AutoLineColor/Naming/DistrictNamingStrategy.cs b/AutoLineColor/Naming/DistrictNamingStrategy.cs index f7d07aa..e9a5857 100644 --- a/AutoLineColor/Naming/DistrictNamingStrategy.cs +++ b/AutoLineColor/Naming/DistrictNamingStrategy.cs @@ -8,6 +8,7 @@ namespace AutoLineColor.Naming { internal class DistrictNamingStrategy : INamingStrategy { + private static Console logger = Console.Instance; public string GetName(TransportLine transportLine) { int stopCount; @@ -99,7 +100,7 @@ private string BuildRandomName(ushort lineNumber, TransportInfo.TransportType tr catch (Exception ex) { // if we get an exception we'll just drop back to Line number and color name - Console.Message(ex.ToString(), PluginManager.MessageType.Message); + logger.Error(ex.ToString()); } return string.Format("#{0} Line", lineNumber); diff --git a/AutoLineColor/Naming/GenericNames.cs b/AutoLineColor/Naming/GenericNames.cs index cb42743..0dc6969 100644 --- a/AutoLineColor/Naming/GenericNames.cs +++ b/AutoLineColor/Naming/GenericNames.cs @@ -17,6 +17,7 @@ public class GenericNames "November,Oscar,Papa,Quebec,Romeo,Sierra,Tango,Uniform,Victor,Whiskey,Yankee,Zulu," + "Adams,Boston,Chicago,Denver,Easy,Frank,George,Henry,Ida,John,King,Lincoln,Mary," + "New,Ocean,Peter,Queen,Roger,Sugar,Thomas,Union,Victor,William,Young,Zero"; + private static Console logger = Console.Instance; public static void Initialize() { @@ -31,13 +32,13 @@ public static void Initialize() } else { - Console.Message("No names found, writing default values to " + fullPath); + logger.Message("No names found, writing default values to " + fullPath); File.WriteAllText(fullPath, unparsedNames); } } catch (Exception ex) { - Console.Error("error reading names from disk " + ex); + logger.Error("error reading names from disk " + ex); } // split on new lines, commas and semi-colons diff --git a/AutoLineColor/Naming/NoNamingStrategy.cs b/AutoLineColor/Naming/NoNamingStrategy.cs index 9e5548d..d011156 100644 --- a/AutoLineColor/Naming/NoNamingStrategy.cs +++ b/AutoLineColor/Naming/NoNamingStrategy.cs @@ -6,5 +6,9 @@ public string GetName(TransportLine transportLine) { return null; } + + public NamingStrategy GetStrategy() { + return NamingStrategy.None; + } } } \ No newline at end of file From f154cf32ac71fcb7ad6b61242cb2c107c8ecd24f Mon Sep 17 00:00:00 2001 From: Alex Bahm Date: Thu, 10 Sep 2015 07:43:13 -0700 Subject: [PATCH 3/5] Style and debug. Cleaned up some code and added a way to enable debug from the settings panel. That is off by default. --- AutoLineColor/AutoLineColorMod.cs | 5 ++- AutoLineColor/Configuration.cs | 44 +++++++++++++++++-------- AutoLineColor/Console.cs | 53 +++++++++++++++++++++++-------- 3 files changed, 73 insertions(+), 29 deletions(-) diff --git a/AutoLineColor/AutoLineColorMod.cs b/AutoLineColor/AutoLineColorMod.cs index 394ce5e..72630c1 100644 --- a/AutoLineColor/AutoLineColorMod.cs +++ b/AutoLineColor/AutoLineColorMod.cs @@ -18,8 +18,10 @@ public string Description get { return Constants.Description; } } - public void OnSettingsUI(UIHelperBase helper) { + public void OnSettingsUI(UIHelperBase helper) + { Config = Configuration.Instance; + Config.FlushStagedChanges(); //make sure no prior changes are still around //Generate arrays of colors and naming strategies String[] ColorStrategies = Enum.GetNames(typeof(ColorStrategy)); String[] NamingStrategies = Enum.GetNames(typeof(NamingStrategy)); @@ -31,6 +33,7 @@ public void OnSettingsUI(UIHelperBase helper) { group.AddGroup("Advanced Settings"); group.AddSlider("Max Different Color Picks", 1f, 20f, 1f, (float)Config.MaxDiffColorPickAttempt, Config.MaxDiffColorPickChange); group.AddSlider("MinColorDifference", 1f, 100f, 5f, (float)Config.MinColorDiffPercentage, Config.MinColorDiffChange); + group.AddCheckbox("Debug", logger.debug, logger.SetDebug); group.AddButton("Save", Config.Save); } } diff --git a/AutoLineColor/Configuration.cs b/AutoLineColor/Configuration.cs index 7b78f74..9f13ff0 100644 --- a/AutoLineColor/Configuration.cs +++ b/AutoLineColor/Configuration.cs @@ -70,30 +70,44 @@ public static Configuration LoadConfig() config = GetDefaultConfig(); } - if (isDirty) { + if (isDirty) + { config.Save(); } return config; } - public void ColorStrategyChange(int Strategy) { + public void ColorStrategyChange(int Strategy) + { this.StagedColorStrategy = (ColorStrategy)Strategy; } - public void NamingStrategyChange(int Strategy) { + public void NamingStrategyChange(int Strategy) + { this.StagedNamingStrategy = (NamingStrategy)Strategy; } - public void MinColorDiffChange(float MinDiff) { + public void MinColorDiffChange(float MinDiff) + { this.StagedMinColorDiffPercentage = (int)MinDiff; } - public void MaxDiffColorPickChange(float MaxColorPicks) { + public void MaxDiffColorPickChange(float MaxColorPicks) + { this.StagedMaxDiffColorPickAttempt = (int)MaxColorPicks; } - public void Save() { + public void FlushStagedChanges() + { + StagedColorStrategy = null; + StagedNamingStrategy = null; + StagedMaxDiffColorPickAttempt = null; + StagedMinColorDiffPercentage = null; + } + + public void Save() + { var serializer = new XmlSerializer(typeof(Configuration)); logger.Message("Saving changes to config file"); @@ -115,26 +129,28 @@ public void Save() { : this.MinColorDiffPercentage; //clear changes and log - if (this.StagedColorStrategy.HasValue) { + if (this.StagedColorStrategy.HasValue) + { logger.Message("ColorStrategy changed to " + this.StagedColorStrategy.Value.ToString()); - this.StagedColorStrategy = null; } - if (this.StagedNamingStrategy.HasValue) { + if (this.StagedNamingStrategy.HasValue) + { logger.Message("NamingStrategy changed to " + this.StagedNamingStrategy.Value.ToString()); - this.StagedNamingStrategy = null; } - if (this.StagedMaxDiffColorPickAttempt.HasValue) { + if (this.StagedMaxDiffColorPickAttempt.HasValue) + { logger.Message("MaxDiffColorPickAttempt changed to " + this.StagedMaxDiffColorPickAttempt.Value.ToString()); - this.StagedMaxDiffColorPickAttempt = null; } - if (this.StagedMinColorDiffPercentage.HasValue) { + if (this.StagedMinColorDiffPercentage.HasValue) + { logger.Message("MinColorDiffPercentage changed to " + this.StagedMinColorDiffPercentage.Value.ToString()); - this.StagedMinColorDiffPercentage = null; } + FlushStagedChanges(); + //How we let the ColorMonitor thread know to update the strategies logger.Message("Marking undigested changes"); this.UndigestedChanges = true; diff --git a/AutoLineColor/Console.cs b/AutoLineColor/Console.cs index e69ef51..836777f 100644 --- a/AutoLineColor/Console.cs +++ b/AutoLineColor/Console.cs @@ -10,22 +10,26 @@ namespace AutoLineColor { public class Console { -#if DEBUG - private bool debug = true; -#else - private bool debug = false; -#endif private static Console _instance; + private bool _debug = false; private StreamWriter log; private bool log_opened; - private Console() { - try { + private Console() + { +#if DEBUG + _debug = true; +#endif + try + { log = new StreamWriter(new FileStream(Constants.LogFileName, FileMode.Append | FileMode.Create, FileAccess.Write, FileShare.ReadWrite)); - } catch (Exception e) { + } + catch (Exception e) + { WriteMessage("Could not open log file", PluginManager.MessageType.Warning); } + log_opened = true; } @@ -41,18 +45,39 @@ public static Console Instance } } + public bool debug + { + get + { + return _debug; + } + } + private static string FormatMessage(string msg, PluginManager.MessageType Type) { string formatted; - try { + try + { formatted = string.Format("{0}({1}) {2}", "[AutoLineColor]", Type.ToString(), msg); - } catch (Exception e) { + } + catch (Exception e) + { DebugOutputPanel.AddMessage(PluginManager.MessageType.Error, e.ToString()); formatted = msg; } return formatted; } + public void ToggleDebug() + { + _debug = !_debug; + } + + public void SetDebug(bool should_debug) + { + _debug = should_debug; + } + public void Message(string p, PluginManager.MessageType messageType) { this.WriteMessage(p, messageType); @@ -72,8 +97,9 @@ public void Error(string p) this.WriteMessage(p, PluginManager.MessageType.Error); } - private void WriteMessage(string p, PluginManager.MessageType Type) { - if(!this.debug) + private void WriteMessage(string p, PluginManager.MessageType Type) + { + if(!this._debug) { return; } @@ -83,7 +109,7 @@ private void WriteMessage(string p, PluginManager.MessageType Type) { log.WriteLine(msg); log.Flush(); } - + //Unity engine logger switch(Type) { @@ -100,7 +126,6 @@ private void WriteMessage(string p, PluginManager.MessageType Type) { Debug.Log(msg); break; } - } } } From f6e62120a5c6986986a92253d0217f4a522906ac Mon Sep 17 00:00:00 2001 From: Alex Bahm Date: Thu, 24 Sep 2015 23:21:02 -0700 Subject: [PATCH 4/5] Logging, cleanup, and after dark Added some more logging to the color manager, cleaned up some of the code. I tweaked the main loop so we don't have to loop through every line if we are not using it. And tried to do some after dark fixes, but had no luck what so ever. --- AutoLineColor/ColorMonitor.cs | 88 +++++++++++++++++++---------------- 1 file changed, 48 insertions(+), 40 deletions(-) diff --git a/AutoLineColor/ColorMonitor.cs b/AutoLineColor/ColorMonitor.cs index 409598f..fa6e7ca 100644 --- a/AutoLineColor/ColorMonitor.cs +++ b/AutoLineColor/ColorMonitor.cs @@ -13,7 +13,7 @@ namespace AutoLineColor { public class ColorMonitor : ThreadingExtensionBase { - private static DateTimeOffset _lastOutputTime = DateTimeOffset.Now; + private static DateTimeOffset _nextUpdateTime = DateTimeOffset.Now; private bool _initialized; private IColorStrategy _colorStrategy; private INamingStrategy _namingStrategy; @@ -23,13 +23,14 @@ public class ColorMonitor : ThreadingExtensionBase public override void OnCreated(IThreading threading) { - logger.Message("loading auto color monitor"); - logger.Message("initializing colors"); + logger.Message("==============================="); + logger.Message("Initializing auto color monitor"); + logger.Message("Initializing colors"); RandomColor.Initialize(); CategorisedColor.Initialize(); GenericNames.Initialize(); - logger.Message("loading current config"); + logger.Message("Loading current config"); _config = Configuration.Instance; _colorStrategy = SetColorStrategy(_config.ColorStrategy); _namingStrategy = SetNamingStrategy(_config.NamingStrategy); @@ -79,11 +80,7 @@ private IColorStrategy SetColorStrategy(ColorStrategy colorStrategy) } public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) - { - var theTransportManager = Singleton.instance; - var lines = theTransportManager.m_lines.m_buffer; - - //Digest changes + { //Digest changes if (_config.UndigestedChanges == true) { logger.Message("Applying undigested changes"); _colorStrategy = SetColorStrategy(_config.ColorStrategy); @@ -91,63 +88,63 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) _config.UndigestedChanges = false; } - try - { - if (_initialized == false) - return; - - - // try and limit how often we are scanning for lines. this ain't that important - if (_lastOutputTime.AddMilliseconds(1000) >= DateTimeOffset.Now) - return; + if (_initialized == false) + return; + // try and limit how often we are scanning for lines. this ain't that important + if (_nextUpdateTime >= DateTimeOffset.Now) + return; + var theTransportManager = Singleton.instance; + var lines = theTransportManager.m_lines.m_buffer; - _lastOutputTime = DateTimeOffset.Now; + try + { + _nextUpdateTime = DateTimeOffset.Now.AddSeconds(5); while (!Monitor.TryEnter(lines, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } - _usedColors = lines.Where(l => l.IsActive()).Select(l => l.m_color).ToList(); - for (ushort counter = 0; counter < lines.Length - 1; counter++) + for (ushort i = 0; i < theTransportManager.m_lineCount - 1; i++) { - var transportLine = lines[counter]; + var transportLine = lines[i]; + logger.Message(string.Format("Working on line {0}", i)); if (transportLine.m_flags == TransportLine.Flags.None) continue; + if (!transportLine.Complete) + continue; // only worry about fully created lines if (!transportLine.IsActive() || transportLine.HasCustomName() || !transportLine.m_color.IsDefaultColor()) continue; - logger.Message("work to be done!"); - - var lineName = _namingStrategy.GetName(transportLine); - var color = _colorStrategy.GetColor(transportLine, _usedColors); + var instanceID = new InstanceID { TransportLine = i }; + var lineStingleton = Singleton.instance; + var lineName = lineStingleton.GetName(instanceID); if (!transportLine.HasCustomColor() || transportLine.m_color.IsDefaultColor()) { - // set the color - transportLine.m_color = color; - transportLine.m_flags |= TransportLine.Flags.CustomColor; + var color = _colorStrategy.GetColor(transportLine, _usedColors); + + logger.Message(string.Format("About to change line color")); + transportLine.ChangeColor(color); logger.Message(string.Format("Changed line color. '{0}' {1} -> {2}", lineName, transportLine.m_color, color)); } - if (string.IsNullOrEmpty(lineName) == false && transportLine.HasCustomName() == false) + if (string.IsNullOrEmpty(lineName) == false && + transportLine.HasCustomName() == false) { - logger.Message("New line name time!"); - // set the name - var line = Singleton.instance; - var instanceID = new InstanceID { TransportLine = counter }; - logger.Message(string.Format("Renamed Line '{0}' -> '{1}'", line.GetName(instanceID), lineName)); - - line.SetName(instanceID, lineName); - transportLine.m_flags |= TransportLine.Flags.CustomName; + var newName = _namingStrategy.GetName(transportLine); + + logger.Message(string.Format("About to rename line")); + transportLine.Rename(lineStingleton, instanceID, newName); + logger.Message(string.Format("Renamed Line '{0}' -> '{1}'", lineName, newName)); } - lines[counter] = transportLine; + lines[i] = transportLine; } } catch (Exception ex) @@ -184,7 +181,7 @@ public static bool IsColorEqual(this Color32 color1, Color32 color2) public static bool IsActive(this TransportLine transportLine) { - if ((transportLine.m_flags & (TransportLine.Flags.Complete | TransportLine.Flags.Created | TransportLine.Flags.Hidden)) == 0) + if ((transportLine.m_flags & (TransportLine.Flags.Created | TransportLine.Flags.Hidden)) == 0) return false; // stations are marked with this flag @@ -194,6 +191,17 @@ public static bool IsActive(this TransportLine transportLine) return true; } + public static void ChangeColor(this TransportLine transportLine, Color32 color) { + transportLine.m_color = color; + transportLine.m_flags |= TransportLine.Flags.CustomColor; + } + + public static void Rename(this TransportLine transportLine, InstanceManager singleton, InstanceID id, string newName) { + // set the name + singleton.SetName(id, newName); + transportLine.m_flags |= TransportLine.Flags.CustomName; + } + public static bool HasCustomColor(this TransportLine transportLine) { return (transportLine.m_flags & TransportLine.Flags.CustomColor) == TransportLine.Flags.CustomColor; From 625fb0a00cc0eea02a1d016f7a09e94408984532 Mon Sep 17 00:00:00 2001 From: Alex Bahm Date: Fri, 25 Sep 2015 20:47:15 -0700 Subject: [PATCH 5/5] Got colors to save, not names. Managed to get colors to update, but no matter what I tried, I couldn't get naming to work. --- AutoLineColor/ColorMonitor.cs | 53 ++++++++++++++++------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/AutoLineColor/ColorMonitor.cs b/AutoLineColor/ColorMonitor.cs index fa6e7ca..5b9281b 100644 --- a/AutoLineColor/ColorMonitor.cs +++ b/AutoLineColor/ColorMonitor.cs @@ -100,16 +100,13 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) try { - _nextUpdateTime = DateTimeOffset.Now.AddSeconds(5); - - while (!Monitor.TryEnter(lines, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } - + _nextUpdateTime = DateTimeOffset.Now.AddSeconds(10); _usedColors = lines.Where(l => l.IsActive()).Select(l => l.m_color).ToList(); - for (ushort i = 0; i < theTransportManager.m_lineCount - 1; i++) + for (ushort i = 0; i < theTransportManager.m_lines.m_buffer.Length - 1; i++) { var transportLine = lines[i]; - logger.Message(string.Format("Working on line {0}", i)); + //logger.Message(string.Format("Starting on line {0}", i)); if (transportLine.m_flags == TransportLine.Flags.None) continue; @@ -121,29 +118,38 @@ public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) if (!transportLine.IsActive() || transportLine.HasCustomName() || !transportLine.m_color.IsDefaultColor()) continue; - var instanceID = new InstanceID { TransportLine = i }; - var lineStingleton = Singleton.instance; - var lineName = lineStingleton.GetName(instanceID); + logger.Message(string.Format("Working on line {0}", i)); + + var instanceID = new InstanceID(); + var lineName = theTransportManager.GetLineName(i); + var newName = _namingStrategy.GetName(transportLine); if (!transportLine.HasCustomColor() || transportLine.m_color.IsDefaultColor()) { var color = _colorStrategy.GetColor(transportLine, _usedColors); - logger.Message(string.Format("About to change line color")); - transportLine.ChangeColor(color); - logger.Message(string.Format("Changed line color. '{0}' {1} -> {2}", lineName, transportLine.m_color, color)); + logger.Message(string.Format("About to change line color to {0}", color)); + transportLine.m_color = color; + transportLine.m_flags |= TransportLine.Flags.CustomColor; + theTransportManager.SetLineColor(i, color); + + logger.Message(string.Format("Changed line color. '{0}' {1} -> {2}", lineName, theTransportManager.GetLineColor(i), color)); } - if (string.IsNullOrEmpty(lineName) == false && - transportLine.HasCustomName() == false) - { - var newName = _namingStrategy.GetName(transportLine); + if (string.IsNullOrEmpty(newName) == false && + transportLine.HasCustomName() == false) { + logger.Message(string.Format("About to rename line to {0}", newName)); + + transportLine.m_flags |= TransportLine.Flags.CustomName; + theTransportManager.SetLineName(i, newName); - logger.Message(string.Format("About to rename line")); - transportLine.Rename(lineStingleton, instanceID, newName); logger.Message(string.Format("Renamed Line '{0}' -> '{1}'", lineName, newName)); } + logger.Message(string.Format("Line is now {0} and {1}", + theTransportManager.GetLineName(i), + theTransportManager.GetLineColor(i))); + lines[i] = transportLine; } } @@ -191,17 +197,6 @@ public static bool IsActive(this TransportLine transportLine) return true; } - public static void ChangeColor(this TransportLine transportLine, Color32 color) { - transportLine.m_color = color; - transportLine.m_flags |= TransportLine.Flags.CustomColor; - } - - public static void Rename(this TransportLine transportLine, InstanceManager singleton, InstanceID id, string newName) { - // set the name - singleton.SetName(id, newName); - transportLine.m_flags |= TransportLine.Flags.CustomName; - } - public static bool HasCustomColor(this TransportLine transportLine) { return (transportLine.m_flags & TransportLine.Flags.CustomColor) == TransportLine.Flags.CustomColor;