From dac15edce5459994702502932bfb9f5e32f081d3 Mon Sep 17 00:00:00 2001 From: atlimit8 Date: Sat, 3 Oct 2015 14:35:52 -0500 Subject: [PATCH] Load rgb[a] hex colors from MiniYaml (+ Lua) --- OpenRA.Game/FieldLoader.cs | 40 ++---- OpenRA.Game/FieldSaver.cs | 15 +- OpenRA.Game/Graphics/HSLColor.cs | 48 ++++++- OpenRA.Game/Map/Map.cs | 52 ++++++- OpenRA.Game/Map/PlayerReference.cs | 4 +- .../Scripting/Global/HSLColorGlobal.cs | 61 +++++++- .../ServerTraits/ColorValidator.cs | 2 +- .../Traits/World/WeatherOverlay.cs | 10 +- .../ExtractTraitDocsCommand.cs | 4 + .../UtilityCommands/UpgradeModCommand.cs | 22 +++ .../UtilityCommands/UpgradeRules.cs | 136 ++++++++++++++++++ 11 files changed, 337 insertions(+), 57 deletions(-) diff --git a/OpenRA.Game/FieldLoader.cs b/OpenRA.Game/FieldLoader.cs index 5957ab158c..94c1431ad7 100644 --- a/OpenRA.Game/FieldLoader.cs +++ b/OpenRA.Game/FieldLoader.cs @@ -212,21 +212,9 @@ namespace OpenRA } else if (fieldType == typeof(Color)) { - if (value != null) - { - var parts = value.Split(','); - if (parts.Length == 3) - return Color.FromArgb( - Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255)); - if (parts.Length == 4) - return Color.FromArgb( - Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[3]).Clamp(0, 255)); - } + Color color; + if (value != null && HSLColor.TryParseRGB(value, out color)) + return color; return InvalidValueAction(value, fieldType, fieldName); } @@ -235,20 +223,11 @@ namespace OpenRA if (value != null) { var parts = value.Split(','); - - if (parts.Length % 4 != 0) - return InvalidValueAction(value, fieldType, fieldName); - - var colors = new Color[parts.Length / 4]; + var colors = new Color[parts.Length]; for (var i = 0; i < colors.Length; i++) - { - colors[i] = Color.FromArgb( - Exts.ParseIntegerInvariant(parts[4 * i]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[4 * i + 1]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[4 * i + 2]).Clamp(0, 255), - Exts.ParseIntegerInvariant(parts[4 * i + 3]).Clamp(0, 255)); - } + if (!HSLColor.TryParseRGB(parts[i], out colors[i])) + return InvalidValueAction(value, fieldType, fieldName); return colors; } @@ -259,9 +238,12 @@ namespace OpenRA { if (value != null) { - var parts = value.Split(','); + Color rgb; + if (HSLColor.TryParseRGB(value, out rgb)) + return new HSLColor(rgb); - // Allow old ColorRamp format to be parsed as HSLColor + // Allow old HSLColor/ColorRamp formats to be parsed as HSLColor + var parts = value.Split(','); if (parts.Length == 3 || parts.Length == 4) return new HSLColor( (byte)Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), diff --git a/OpenRA.Game/FieldSaver.cs b/OpenRA.Game/FieldSaver.cs index 6178228029..102c4fcff0 100644 --- a/OpenRA.Game/FieldSaver.cs +++ b/OpenRA.Game/FieldSaver.cs @@ -16,6 +16,7 @@ using System.Drawing.Imaging; using System.Globalization; using System.Linq; using System.Reflection; +using OpenRA.Graphics; namespace OpenRA { @@ -73,14 +74,16 @@ namespace OpenRA var t = v.GetType(); - // Color.ToString() does the wrong thing; force it to format as an array + // Color.ToString() does the wrong thing; force it to format as rgb[a] hex if (t == typeof(Color)) { - var c = (Color)v; - return "{0},{1},{2},{3}".F(((int)c.A).Clamp(0, 255), - ((int)c.R).Clamp(0, 255), - ((int)c.G).Clamp(0, 255), - ((int)c.B).Clamp(0, 255)); + return HSLColor.ToHexString((Color)v); + } + + // HSLColor.ToString() does the wrong thing; force it to format as rgb[a] hex + if (t == typeof(HSLColor)) + { + return ((HSLColor)v).ToHexString(); } if (t == typeof(ImageFormat)) diff --git a/OpenRA.Game/Graphics/HSLColor.cs b/OpenRA.Game/Graphics/HSLColor.cs index c6fa0d9520..9e9eafe441 100644 --- a/OpenRA.Game/Graphics/HSLColor.cs +++ b/OpenRA.Game/Graphics/HSLColor.cs @@ -9,6 +9,7 @@ #endregion using System.Drawing; +using System.Globalization; using OpenRA.Scripting; namespace OpenRA.Graphics @@ -27,13 +28,17 @@ namespace OpenRA.Graphics return new HSLColor((byte)(255 * h), (byte)(255 * ss), (byte)(255 * ll)); } + public HSLColor(Color color) + { + RGB = color; + H = (byte)((color.GetHue() / 360.0f) * 255); + S = (byte)(color.GetSaturation() * 255); + L = (byte)(color.GetBrightness() * 255); + } + public static HSLColor FromRGB(int r, int g, int b) { - var c = Color.FromArgb(r, g, b); - var h = (byte)((c.GetHue() / 360.0f) * 255); - var s = (byte)(c.GetSaturation() * 255); - var l = (byte)(c.GetBrightness() * 255); - return new HSLColor(h, s, l); + return new HSLColor(Color.FromArgb(r, g, b)); } public static Color RGBFromHSL(float h, float s, float l) @@ -66,6 +71,27 @@ namespace OpenRA.Graphics return Color.FromArgb((int)(rgb[0] * 255), (int)(rgb[1] * 255), (int)(rgb[2] * 255)); } + public static bool TryParseRGB(string value, out Color color) + { + color = new Color(); + value = value.Trim(); + if (value.Length != 6 && value.Length != 8) + return false; + + byte red, green, blue, alpha = 255; + if (!byte.TryParse(value.Substring(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out red) + || !byte.TryParse(value.Substring(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out green) + || !byte.TryParse(value.Substring(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out blue)) + return false; + + if (value.Length == 8 + && !byte.TryParse(value.Substring(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out alpha)) + return false; + + color = Color.FromArgb(alpha, red, green, blue); + return true; + } + public static bool operator ==(HSLColor me, HSLColor other) { return me.H == other.H && me.S == other.S && me.L == other.L; @@ -96,6 +122,18 @@ namespace OpenRA.Graphics return "{0},{1},{2}".F(H, S, L); } + public static string ToHexString(Color color) + { + if (color.A == 255) + return color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2"); + return color.R.ToString("X2") + color.G.ToString("X2") + color.B.ToString("X2") + color.A.ToString("X2"); + } + + public string ToHexString() + { + return ToHexString(RGB); + } + public override int GetHashCode() { return H.GetHashCode() ^ S.GetHashCode() ^ L.GetHashCode(); } public override bool Equals(object obj) diff --git a/OpenRA.Game/Map/Map.cs b/OpenRA.Game/Map/Map.cs index 13822d6a0f..a09c066d9b 100644 --- a/OpenRA.Game/Map/Map.cs +++ b/OpenRA.Game/Map/Map.cs @@ -344,6 +344,54 @@ namespace OpenRA Visibility = MapVisibility.MissionSelector; } + // Format 7 -> 8 replaced normalized HSL triples with rgb(a) hex colors + if (MapFormat < 8) + { + var players = yaml.Nodes.FirstOrDefault(n => n.Key == "Players"); + if (players != null) + { + bool noteHexColors = false; + bool noteColorRamp = false; + foreach (var player in players.Value.Nodes) + { + var colorRampNode = player.Value.Nodes.FirstOrDefault(n => n.Key == "ColorRamp"); + if (colorRampNode != null) + { + Color dummy; + var parts = colorRampNode.Value.Value.Split(','); + if (parts.Length == 3 || parts.Length == 4) + { + // Try to convert old normalized HSL value to a rgb hex color + try + { + HSLColor color = new HSLColor( + (byte)Exts.ParseIntegerInvariant(parts[0].Trim()).Clamp(0, 255), + (byte)Exts.ParseIntegerInvariant(parts[1].Trim()).Clamp(0, 255), + (byte)Exts.ParseIntegerInvariant(parts[2].Trim()).Clamp(0, 255)); + colorRampNode.Value.Value = FieldSaver.FormatValue(color); + noteHexColors = true; + } + catch (Exception) + { + throw new InvalidDataException("Invalid ColorRamp value.\n File: " + path); + } + } + else if (parts.Length != 1 || !HSLColor.TryParseRGB(parts[0], out dummy)) + throw new InvalidDataException("Invalid ColorRamp value.\n File: " + path); + + colorRampNode.Key = "Color"; + noteColorRamp = true; + } + } + + Console.WriteLine("Converted " + path + " to MapFormat 8."); + if (noteHexColors) + Console.WriteLine("ColorRamp is now called Color and uses rgb(a) hex value - rrggbb[aa]."); + else if (noteColorRamp) + Console.WriteLine("ColorRamp is now called Color."); + } + } + SpawnPoints = Exts.Lazy(() => { var spawns = new List(); @@ -389,7 +437,7 @@ namespace OpenRA // The Uid is calculated from the data on-disk, so // format changes must be flushed to disk. // TODO: this isn't very nice - if (MapFormat < 7) + if (MapFormat < 8) Save(path); Uid = ComputeHash(); @@ -537,7 +585,7 @@ namespace OpenRA public void Save(string toPath) { - MapFormat = 7; + MapFormat = 8; var root = new List(); var fields = new[] diff --git a/OpenRA.Game/Map/PlayerReference.cs b/OpenRA.Game/Map/PlayerReference.cs index 9a6b56bce8..50ab16bef2 100644 --- a/OpenRA.Game/Map/PlayerReference.cs +++ b/OpenRA.Game/Map/PlayerReference.cs @@ -28,10 +28,8 @@ namespace OpenRA public bool LockFaction = false; public string Faction; - // ColorRamp naming retained for backward compatibility public bool LockColor = false; - public HSLColor ColorRamp = new HSLColor(0, 0, 238); - public HSLColor Color { get { return ColorRamp; } set { ColorRamp = value; } } + public HSLColor Color = new HSLColor(0, 0, 238); public bool LockSpawn = false; public int Spawn = 0; diff --git a/OpenRA.Mods.Common/Scripting/Global/HSLColorGlobal.cs b/OpenRA.Mods.Common/Scripting/Global/HSLColorGlobal.cs index 3892cc97d6..44794409b4 100644 --- a/OpenRA.Mods.Common/Scripting/Global/HSLColorGlobal.cs +++ b/OpenRA.Mods.Common/Scripting/Global/HSLColorGlobal.cs @@ -9,6 +9,7 @@ #endregion using System.Drawing; +using Eluant; using OpenRA.Graphics; using OpenRA.Scripting; @@ -30,11 +31,59 @@ namespace OpenRA.Mods.Common.Scripting.Global return new HSLColor(h, s, l); } - public HSLColor White { get { return HSLColor.FromRGB(Color.White.R, Color.White.G, Color.White.B); } } - public HSLColor Black { get { return HSLColor.FromRGB(Color.Black.R, Color.Black.G, Color.Black.B); } } - public HSLColor Blue { get { return HSLColor.FromRGB(Color.Blue.R, Color.Blue.G, Color.Blue.B); } } - public HSLColor Red { get { return HSLColor.FromRGB(Color.Red.R, Color.Red.G, Color.Red.B); } } - public HSLColor Yellow { get { return HSLColor.FromRGB(Color.Yellow.R, Color.Yellow.G, Color.Yellow.B); } } - public HSLColor Green { get { return HSLColor.FromRGB(Color.Green.R, Color.Green.G, Color.Green.B); } } + [Desc("Create a new HSL color with the specified red/green/blue/[alpha] values.")] + public HSLColor FromRGB(int red, int green, int blue, int alpha = 255) + { + return new HSLColor( + Color.FromArgb( + alpha.Clamp(0, 255), red.Clamp(0, 255), green.Clamp(0, 255), blue.Clamp(0, 255))); + } + + [Desc("Create a new HSL color with the specified red/green/blue/[alpha] hex string (rrggbb[aa]).")] + public HSLColor FromHex(string value) + { + Color rgb; + if (HSLColor.TryParseRGB(value, out rgb)) + return new HSLColor(rgb); + + throw new LuaException("Invalid rrggbb[aa] hex string."); + } + + public HSLColor Aqua { get { return new HSLColor(Color.Aqua); } } + public HSLColor Black { get { return new HSLColor(Color.Black); } } + public HSLColor Blue { get { return new HSLColor(Color.Blue); } } + public HSLColor Brown { get { return new HSLColor(Color.Brown); } } + public HSLColor Cyan { get { return new HSLColor(Color.Cyan); } } + public HSLColor DarkBlue { get { return new HSLColor(Color.DarkBlue); } } + public HSLColor DarkCyan { get { return new HSLColor(Color.DarkCyan); } } + public HSLColor DarkGray { get { return new HSLColor(Color.DarkGray); } } + public HSLColor DarkGreen { get { return new HSLColor(Color.DarkGreen); } } + public HSLColor DarkOrange { get { return new HSLColor(Color.DarkOrange); } } + public HSLColor DarkRed { get { return new HSLColor(Color.DarkRed); } } + public HSLColor Fuchsia { get { return new HSLColor(Color.Fuchsia); } } + public HSLColor Gold { get { return new HSLColor(Color.Gold); } } + public HSLColor Gray { get { return new HSLColor(Color.Gray); } } + public HSLColor Green { get { return new HSLColor(Color.Green); } } + public HSLColor LawnGreen { get { return new HSLColor(Color.LawnGreen); } } + public HSLColor LightBlue { get { return new HSLColor(Color.LightBlue); } } + public HSLColor LightCyan { get { return new HSLColor(Color.LightCyan); } } + public HSLColor LightGray { get { return new HSLColor(Color.LightGray); } } + public HSLColor LightGreen { get { return new HSLColor(Color.LightGreen); } } + public HSLColor LightYellow { get { return new HSLColor(Color.LightYellow); } } + public HSLColor Lime { get { return new HSLColor(Color.Lime); } } + public HSLColor LimeGreen { get { return new HSLColor(Color.LimeGreen); } } + public HSLColor Magenta { get { return new HSLColor(Color.Magenta); } } + public HSLColor Maroon { get { return new HSLColor(Color.Maroon); } } + public HSLColor Navy { get { return new HSLColor(Color.Navy); } } + public HSLColor Olive { get { return new HSLColor(Color.Olive); } } + public HSLColor Orange { get { return new HSLColor(Color.Orange); } } + public HSLColor OrangeRed { get { return new HSLColor(Color.OrangeRed); } } + public HSLColor Purple { get { return new HSLColor(Color.Purple); } } + public HSLColor Red { get { return new HSLColor(Color.Red); } } + public HSLColor Salmon { get { return new HSLColor(Color.Salmon); } } + public HSLColor SkyBlue { get { return new HSLColor(Color.SkyBlue); } } + public HSLColor Teal { get { return new HSLColor(Color.Teal); } } + public HSLColor Yellow { get { return new HSLColor(Color.Yellow); } } + public HSLColor White { get { return new HSLColor(Color.White); } } } } diff --git a/OpenRA.Mods.Common/ServerTraits/ColorValidator.cs b/OpenRA.Mods.Common/ServerTraits/ColorValidator.cs index ab1a3ae4e2..b7112d856b 100644 --- a/OpenRA.Mods.Common/ServerTraits/ColorValidator.cs +++ b/OpenRA.Mods.Common/ServerTraits/ColorValidator.cs @@ -169,7 +169,7 @@ namespace OpenRA.Mods.Common.Server return false; } - var mapPlayerColors = server.MapPlayers.Players.Values.Select(p => p.ColorRamp.RGB); + var mapPlayerColors = server.MapPlayers.Players.Values.Select(p => p.Color.RGB); if (!ValidateColorAgainstForbidden(askedColor, mapPlayerColors, out forbiddenColor)) { diff --git a/OpenRA.Mods.Common/Traits/World/WeatherOverlay.cs b/OpenRA.Mods.Common/Traits/World/WeatherOverlay.cs index 4b43e24a4d..f141e4eac9 100644 --- a/OpenRA.Mods.Common/Traits/World/WeatherOverlay.cs +++ b/OpenRA.Mods.Common/Traits/World/WeatherOverlay.cs @@ -56,12 +56,12 @@ namespace OpenRA.Mods.Common.Traits [Desc("The value range that can be swung to the left or right. SwingAmplitude min. and max. value in px/tick.")] public readonly float[] SwingAmplitude = { 1.0f, 1.5f }; - [Desc("The randomly selected ArgbColors for the particles. Use this order: a,r,g,b, a,r,g,b, a,...")] + [Desc("The randomly selected rgb(a) hex colors for the particles. Use this order: rrggbb[aa], rrggbb[aa], ...")] public readonly Color[] ParticleColors = { - Color.FromArgb(255, 236, 236, 236), - Color.FromArgb(255, 228, 228, 228), - Color.FromArgb(255, 208, 208, 208), - Color.FromArgb(255, 188, 188, 188) + Color.FromArgb(236, 236, 236), + Color.FromArgb(228, 228, 228), + Color.FromArgb(208, 208, 208), + Color.FromArgb(188, 188, 188) }; [Desc("Works only with line enabled and can get used to fade out the tail of the line like a contrail.")] diff --git a/OpenRA.Mods.Common/UtilityCommands/ExtractTraitDocsCommand.cs b/OpenRA.Mods.Common/UtilityCommands/ExtractTraitDocsCommand.cs index 8b6fbb570c..5661f2e585 100644 --- a/OpenRA.Mods.Common/UtilityCommands/ExtractTraitDocsCommand.cs +++ b/OpenRA.Mods.Common/UtilityCommands/ExtractTraitDocsCommand.cs @@ -12,6 +12,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Text; +using OpenRA.Graphics; using OpenRA.Traits; namespace OpenRA.Mods.Common.UtilityCommands @@ -164,6 +165,9 @@ namespace OpenRA.Mods.Common.UtilityCommands if (t == typeof(WVec)) return "3D World Vector"; + if (t == typeof(HSLColor)) + return "Color"; + return t.Name; } } diff --git a/OpenRA.Mods.Common/UtilityCommands/UpgradeModCommand.cs b/OpenRA.Mods.Common/UtilityCommands/UpgradeModCommand.cs index ee16de91c2..df960f5979 100644 --- a/OpenRA.Mods.Common/UtilityCommands/UpgradeModCommand.cs +++ b/OpenRA.Mods.Common/UtilityCommands/UpgradeModCommand.cs @@ -76,6 +76,28 @@ namespace OpenRA.Mods.Common.UtilityCommands file.WriteLine(yaml.WriteToString()); } + Console.WriteLine("Processing Chrome Metrics:"); + foreach (var filename in Game.ModData.Manifest.ChromeMetrics) + { + Console.WriteLine("\t" + filename); + var yaml = MiniYaml.FromFile(filename); + UpgradeRules.UpgradeChromeMetrics(engineDate, ref yaml, null, 0); + + using (var file = new StreamWriter(filename)) + file.WriteLine(yaml.WriteToString()); + } + + Console.WriteLine("Processing Chrome Layout:"); + foreach (var filename in Game.ModData.Manifest.ChromeLayout) + { + Console.WriteLine("\t" + filename); + var yaml = MiniYaml.FromFile(filename); + UpgradeRules.UpgradeChromeLayout(engineDate, ref yaml, null, 0); + + using (var file = new StreamWriter(filename)) + file.WriteLine(yaml.WriteToString()); + } + Console.WriteLine("Processing Maps:"); var maps = Game.ModData.MapCache .Where(m => m.Status == MapStatus.Available) diff --git a/OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs b/OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs index a9ca53425b..ce3e8edd05 100644 --- a/OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs +++ b/OpenRA.Mods.Common/UtilityCommands/UpgradeRules.cs @@ -10,8 +10,10 @@ using System; using System.Collections.Generic; +using System.Drawing; using System.Globalization; using System.Linq; +using OpenRA.Graphics; namespace OpenRA.Mods.Common.UtilityCommands { @@ -148,6 +150,72 @@ namespace OpenRA.Mods.Common.UtilityCommands } } + internal static void TryUpdateColor(ref string value) + { + if (value.Length == 0) + return; + + try + { + var parts = value.Split(','); + if (parts.Length == 3) + value = FieldSaver.FormatValue(Color.FromArgb( + Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255))); + else if (parts.Length == 4) + value = FieldSaver.FormatValue(Color.FromArgb( + Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[3]).Clamp(0, 255))); + } + catch { } + } + + internal static void TryUpdateColors(ref string value) + { + if (value.Length == 0) + return; + + try + { + var parts = value.Split(','); + if (parts.Length % 4 != 0) + return; + + var colors = new Color[parts.Length / 4]; + for (var i = 0; i < colors.Length; i++) + { + colors[i] = Color.FromArgb( + Exts.ParseIntegerInvariant(parts[4 * i]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[4 * i + 1]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[4 * i + 2]).Clamp(0, 255), + Exts.ParseIntegerInvariant(parts[4 * i + 3]).Clamp(0, 255)); + } + + value = FieldSaver.FormatValue(colors); + } + catch { } + } + + internal static void TryUpdateHSLColor(ref string value) + { + if (value.Length == 0) + return; + + try + { + var parts = value.Split(','); + if (parts.Length == 3 || parts.Length == 4) + value = FieldSaver.FormatValue(new HSLColor( + (byte)Exts.ParseIntegerInvariant(parts[0]).Clamp(0, 255), + (byte)Exts.ParseIntegerInvariant(parts[1]).Clamp(0, 255), + (byte)Exts.ParseIntegerInvariant(parts[2]).Clamp(0, 255))); + } + catch { } + } + internal static void UpgradeActorRules(int engineVersion, ref List nodes, MiniYamlNode parent, int depth) { var parentKey = parent != null ? parent.Key.Split('@').First() : null; @@ -2277,6 +2345,21 @@ namespace OpenRA.Mods.Common.UtilityCommands } } + if (engineVersion < 20151027 && depth == 2) + { + if (node.Key == "Color") + { + if (parent.Key.StartsWith("FixedColorPalette")) + TryUpdateHSLColor(ref node.Value.Value); + else + TryUpdateColor(ref node.Value.Value); + } + else if (node.Key == "RadarPingColor" || node.Key == "SelectionBoxColor" || node.Key == "BarColor") + TryUpdateColor(ref node.Value.Value); + else if (node.Key == "Fog" || node.Key == "Shroud" || node.Key == "ParticleColors") + TryUpdateColors(ref node.Value.Value); + } + UpgradeActorRules(engineVersion, ref node.Value.Nodes, node, depth + 1); } } @@ -2764,6 +2847,12 @@ namespace OpenRA.Mods.Common.UtilityCommands node.Key = "TrailImage"; } + if (engineVersion < 20151027) + { + if (node.Key == "Color" || node.Key == "ContrailColor") + TryUpdateColor(ref node.Value.Value); + } + UpgradeWeaponRules(engineVersion, ref node.Value.Nodes, node, depth + 1); } } @@ -2785,6 +2874,14 @@ namespace OpenRA.Mods.Common.UtilityCommands if (depth == 2 && node.Key == "Image") node.Key = "Images"; + if (engineVersion < 20151027) + { + if (node.Key == "LeftColor" || node.Key == "RightColor" || node.Key == "Color") + TryUpdateColor(ref node.Value.Value); + else if (node.Key == "HeightDebugColors") + TryUpdateColors(ref node.Value.Value); + } + UpgradeTileset(engineVersion, ref node.Value.Nodes, node, depth + 1); } @@ -2829,10 +2926,49 @@ namespace OpenRA.Mods.Common.UtilityCommands lockRace.Key = "LockFaction"; } + if (engineVersion < 20151027 && node.Key == "ColorRamp") + { + TryUpdateHSLColor(ref node.Value.Value); + node.Key = "Color"; + } + UpgradePlayers(engineVersion, ref node.Value.Nodes, node, depth + 1); } } + internal static void UpgradeChromeMetrics(int engineVersion, ref List nodes, MiniYamlNode parent, int depth) + { + foreach (var node in nodes) + { + if (engineVersion < 20151027) + { + if (node.Key.EndsWith("Color") || node.Key.EndsWith("ColorDisabled") || node.Key.EndsWith("ColorInvalid")) + TryUpdateColor(ref node.Value.Value); + } + + UpgradeChromeMetrics(engineVersion, ref node.Value.Nodes, node, depth + 1); + } + } + + internal static void UpgradeChromeLayout(int engineVersion, ref List nodes, MiniYamlNode parent, int depth) + { + foreach (var node in nodes) + { + if (engineVersion < 20151027) + { + if (node.Key == "Color" || node.Key == "ReadyTextAltColor" || node.Key == "TextColor" || node.Key == "TextColorDisabled") + { + if (parent.Key.StartsWith("MapPreview@")) + TryUpdateHSLColor(ref node.Value.Value); + else + TryUpdateColor(ref node.Value.Value); + } + } + + UpgradeChromeLayout(engineVersion, ref node.Value.Nodes, node, depth + 1); + } + } + internal static void UpgradeActors(int engineVersion, ref List nodes, MiniYamlNode parent, int depth) { foreach (var node in nodes)