Implement new mod/map updater framework.

OpenRA.Mods.Common/UpdateRules/Rules/DefineSoundDefaults.cs

@@ -0,0 +1,78 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class DefineSoundDefaults : UpdateRule
+	{
+		public override string Name { get { return "Move mod-specific sound defaults to yaml"; } }
+		public override string Description
+		{
+			get
+			{
+				return "Mod-specific default sound values have been removed from several traits.\n" +
+					"The original values are added back via yaml.";
+			}
+		}
+
+		Tuple<string, string, string, List<MiniYamlNode>>[] fields =
+		{
+			Tuple.Create("ParaDrop", "ChuteSound", "chute1.aud", new List<MiniYamlNode>()),
+			Tuple.Create("EjectOnDeath", "ChuteSound", "chute1.aud", new List<MiniYamlNode>()),
+			Tuple.Create("ProductionParadrop", "ChuteSound", "chute1.aud", new List<MiniYamlNode>()),
+			Tuple.Create("Building", "BuildSounds", "placbldg.aud, build5.aud", new List<MiniYamlNode>()),
+			Tuple.Create("Building", "UndeploySounds", "cashturn.aud", new List<MiniYamlNode>())
+		};
+
+		public override IEnumerable<string> BeforeUpdate(ModData modData)
+		{
+			// Reset state for each mod/map
+			foreach (var field in fields)
+				field.Item4.Clear();
+
+			yield break;
+		}
+
+		string BuildMessage(Tuple<string, string, string, List<MiniYamlNode>> field)
+		{
+			return "The default value for {0}.{1} has been removed.\n".F(field.Item1, field.Item2)
+				+ "You may wish to explicitly define `{0}: {1}` at the following\n".F(field.Item2, field.Item3)
+				+ "locations if the sound has not already been inherited from a parent definition.\n"
+				+ UpdateUtils.FormatMessageList(field.Item4.Select(n => n.Location.ToString()));
+		}
+
+		public override IEnumerable<string> AfterUpdate(ModData modData)
+		{
+			foreach (var field in fields)
+				if (field.Item4.Any())
+					yield return BuildMessage(field);
+		}
+
+		public override IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode)
+		{
+			foreach (var field in fields)
+			{
+				foreach (var traitNode in actorNode.ChildrenMatching(field.Item1))
+				{
+					var node = traitNode.LastChildMatching(field.Item2);
+					if (node == null)
+						field.Item4.Add(traitNode);
+				}
+			}
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/Rules/RemoveTerrainTypeIsWaterFlag.cs

@@ -0,0 +1,37 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class RemoveTerrainTypeIsWaterFlag : UpdateRule
+	{
+		public override string Name { get { return "Remove TerrainType IsWater flag"; } }
+		public override string Description
+		{
+			get
+			{
+				return "The IsWater flag on terrain type definitions has been unused for some time.\n" +
+					"This flag has now been removed from the tileset yaml.";
+			}
+		}
+
+		public override IEnumerable<string> UpdateTilesetNode(ModData modData, MiniYamlNode tilesetNode)
+		{
+			if (tilesetNode.Key == "Terrain")
+				foreach (var type in tilesetNode.Value.Nodes)
+					type.Value.Nodes.RemoveAll(n => n.Key == "IsWater");
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/Rules/RemoveWeaponScanRadius.cs

@@ -0,0 +1,53 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class RemoveWeaponScanRadius : UpdateRule
+	{
+		public override string Name { get { return "Remove Weapon ScanRadius parameters"; } }
+		public override string Description
+		{
+			get
+			{
+				return "The *ScanRadius parameters have been removed from weapon projectiles and warheads.\n" +
+					"These values are now automatically determined by the engine.\n" +
+					"CreateEffect.ImpactActors: False has been added to replace VictimScanRadius: 0";
+			}
+		}
+
+		public override IEnumerable<string> UpdateWeaponNode(ModData modData, MiniYamlNode weaponNode)
+		{
+			foreach (var node in weaponNode.ChildrenMatching("Warhead"))
+			{
+				if (node.Value.Value == "CreateEffect")
+				{
+					var victimScanRadius = node.LastChildMatching("VictimScanRadius");
+					if (victimScanRadius != null && victimScanRadius.NodeValue<int>() == 0)
+						node.AddNode("ImpactActors", "false");
+					node.RemoveNodes("VictimScanRadius");
+				}
+			}
+
+			var projectile = weaponNode.LastChildMatching("Projectile");
+			if (projectile != null)
+			{
+				projectile.RemoveNodes("BounceBlockerScanRadius");
+				projectile.RemoveNodes("BlockerScanRadius");
+				projectile.RemoveNodes("AreaVictimScanRadius");
+			}
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/Rules/RemoveWithReloadingSpriteTurret.cs

@@ -0,0 +1,40 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class RemoveWithReloadingSpriteTurret : UpdateRule
+	{
+		public override string Name { get { return "Remove WithReloadingSpriteTurret trait"; } }
+		public override string Description
+		{
+			get
+			{
+				return "WithReloadingSpriteTurret has been superseded by conditions.\n" +
+					"The trait is switched for with WithSpriteTurret.\n";
+			}
+		}
+
+		public override IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode)
+		{
+			foreach (var turret in actorNode.ChildrenMatching("WithReloadingSpriteTurret"))
+			{
+				turret.RenameKeyPreservingSuffix("WithSpriteTurret");
+				yield return turret.Location.ToString() + ": WithReloadingSpriteTurret has been replaced by WithSpriteTurret.\n" +
+					"You should use AmmoPool.AmmoConditions to switch turret type when reloading to restore the previous behaviour.";
+			}
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/Rules/RenameWormSpawner.cs

@@ -0,0 +1,44 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class RenameWormSpawner : UpdateRule
+	{
+		public override string Name { get { return "WormSpawner renamed and generalized to ActorSpawner"; } }
+		public override string Description
+		{
+			get
+			{
+				return "The D2k-specific WormSpawner trait was renamed to ActorSpawner,\n" +
+					"generalized, and moved into the common mod code.";
+			}
+		}
+
+		public override IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode)
+		{
+			foreach (var spawner in actorNode.ChildrenMatching("WormSpawner"))
+				spawner.RenameKeyPreservingSuffix("ActorSpawner");
+
+			foreach (var manager in actorNode.ChildrenMatching("WormManager"))
+			{
+				manager.RenameKeyPreservingSuffix("ActorSpawnManager");
+				var signature = manager.LastChildMatching("WormSignature");
+				if (signature != null)
+					signature.RenameKeyPreservingSuffix("Actors");
+			}
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/Rules/SplitTurretAimAnimation.cs

@@ -0,0 +1,91 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenRA.Mods.Common.UpdateRules.Rules
+{
+	public class SplitTurretAimAnimation : UpdateRule
+	{
+		public override string Name { get { return "Introduce WithTurretAimAnimation trait"; } }
+		public override string Description
+		{
+			get
+			{
+				return "WithSpriteTurret.AimSequence and WithTurretAttackAnimation.AimSequence\n" +
+					"have been split into a new WithTurretAimAnimation trait.";
+			}
+		}
+
+		public override IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode)
+		{
+			var turretAttack = actorNode.LastChildMatching("WithTurretAttackAnimation");
+			if (turretAttack != null)
+			{
+				var attackSequence = turretAttack.LastChildMatching("AttackSequence");
+				var aimSequence = turretAttack.LastChildMatching("AimSequence");
+
+				// If only AimSequence is null, just rename AttackSequence to Sequence (ReloadPrefix is very unlikely to be defined in that case).
+				// If only AttackSequence is null, just rename the trait and property (the delay properties will likely be undefined).
+				// If both aren't null, split/copy everything relevant to the new WithTurretAimAnimation.
+				// If both are null (extremely unlikely), do nothing.
+				if (attackSequence == null && aimSequence != null)
+				{
+					turretAttack.RenameKeyPreservingSuffix("WithTurretAimAnimation");
+					aimSequence.RenameKeyPreservingSuffix("Sequence");
+				}
+				else if (attackSequence != null && aimSequence == null)
+					attackSequence.RenameKeyPreservingSuffix("Sequence");
+				else if (attackSequence != null && aimSequence != null)
+				{
+					var turretAim = new MiniYamlNode("WithTurretAimAnimation", "");
+					aimSequence.RenameKeyPreservingSuffix("Sequence");
+					turretAim.Value.Nodes.Add(aimSequence);
+					turretAttack.Value.Nodes.Remove(aimSequence);
+
+					var reloadPrefix = turretAttack.LastChildMatching("ReloadPrefix");
+					var turret = turretAttack.LastChildMatching("Turret");
+					var armament = turretAttack.LastChildMatching("Armament");
+					if (reloadPrefix != null)
+					{
+						turretAim.Value.Nodes.Add(reloadPrefix);
+						turretAttack.Value.Nodes.Remove(reloadPrefix);
+					}
+
+					if (turret != null)
+						turretAim.Value.Nodes.Add(turret);
+					if (armament != null)
+						turretAim.Value.Nodes.Add(armament);
+
+					attackSequence.RenameKeyPreservingSuffix("Sequence");
+					actorNode.Value.Nodes.Add(turretAim);
+				}
+			}
+
+			var spriteTurret = actorNode.LastChildMatching("WithSpriteTurret");
+			if (spriteTurret != null)
+			{
+				var aimSequence = spriteTurret.Value.Nodes.FirstOrDefault(n => n.Key == "AimSequence");
+				if (aimSequence != null)
+				{
+					var aimAnim = new MiniYamlNode("WithTurretAimAnimation", "");
+					aimSequence.RenameKeyPreservingSuffix("Sequence");
+					aimAnim.Value.Nodes.Add(aimSequence);
+					spriteTurret.Value.Nodes.Remove(aimSequence);
+					actorNode.Value.Nodes.Add(aimAnim);
+				}
+			}
+
+			yield break;
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/UpdatePath.cs

@@ -0,0 +1,95 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using OpenRA.Mods.Common.UpdateRules.Rules;
+
+namespace OpenRA.Mods.Common.UpdateRules
+{
+	public class UpdatePath
+	{
+		// Define known update paths from stable tags to the current bleed tip
+		//
+		// This file should be maintained separately on prep branches vs bleed.
+		// The bleed version of this file should ignore the presence of the prep branch
+		// and list rules from the playtest that forked the prep branch and current bleed.
+		// The prep branch should maintain its own list of rules along the prep branch
+		// until the eventual final release.
+		//
+		// When a final release has been tagged the update paths from the prep branch
+		// can be merged back into bleed by replacing the forking-playtest-to-bleed path
+		// with the prep playtest-to-playtest-to-release paths and finally a new/modified
+		// release-to-bleed path.
+		[SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1118:ParameterMustNotSpanMultipleLines",
+			Justification = "Extracting update lists to temporary variables obfuscates the definitions.")]
+		static readonly UpdatePath[] Paths =
+		{
+			new UpdatePath("release-20180218", "release-20180307", new UpdateRule[0]),
+
+			new UpdatePath("release-20180307", new UpdateRule[]
+			{
+				// Bleed only changes here
+				new RemoveTerrainTypeIsWaterFlag(),
+				new RemoveWeaponScanRadius(),
+				new SplitTurretAimAnimation(),
+				new DefineSoundDefaults(),
+				new RenameWormSpawner(),
+				new RemoveWithReloadingSpriteTurret()
+			})
+		};
+
+		public static IEnumerable<UpdateRule> FromSource(ObjectCreator objectCreator, string source)
+		{
+			// Use reflection to identify types
+			var namedType = objectCreator.FindType(source);
+			if (namedType != null && namedType.IsSubclassOf(typeof(UpdateRule)))
+				return new[] { (UpdateRule)objectCreator.CreateBasic(namedType) };
+
+			var namedPath = Paths.FirstOrDefault(p => p.source == source);
+			return namedPath != null ? namedPath.Rules : null;
+		}
+
+		public static IEnumerable<string> KnownPaths { get { return Paths.Select(p => p.source); } }
+		public static IEnumerable<string> KnownRules(ObjectCreator objectCreator)
+		{
+			return objectCreator.GetTypesImplementing<UpdateRule>().Select(t => t.Name);
+		}
+
+		readonly string source;
+		readonly string chainToSource;
+		readonly UpdateRule[] rules;
+		UpdatePath(string source, UpdateRule[] rules)
+			: this(source, null, rules) { }
+
+		UpdatePath(string source, string chainToSource, UpdateRule[] rules)
+		{
+			this.source = source;
+			this.rules = rules;
+			this.chainToSource = chainToSource;
+		}
+
+		IEnumerable<UpdateRule> Rules
+		{
+			get
+			{
+				if (chainToSource != null)
+				{
+					var chain = Paths.First(p => p.source == chainToSource);
+					return rules.Concat(chain.Rules);
+				}
+
+				return rules;
+			}
+		}
+	}
+}

OpenRA.Mods.Common/UpdateRules/UpdateRule.cs

@@ -0,0 +1,34 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenRA.Mods.Common.UpdateRules
+{
+	public abstract class UpdateRule
+	{
+		public abstract string Name { get; }
+		public abstract string Description { get; }
+
+		/// <summary>Defines a transformation that is run on each top-level node in a yaml file set.</summary>
+		/// <returns>An enumerable of manual steps to be run by the user</returns>
+		public delegate IEnumerable<string> TopLevelNodeTransform(ModData modData, MiniYamlNode node);
+
+		public virtual IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode) { yield break; }
+		public virtual IEnumerable<string> UpdateWeaponNode(ModData modData, MiniYamlNode weaponNode) { yield break; }
+		public virtual IEnumerable<string> UpdateTilesetNode(ModData modData, MiniYamlNode tilesetNode) { yield break; }
+
+		public virtual IEnumerable<string> BeforeUpdate(ModData modData) { yield break; }
+		public virtual IEnumerable<string> AfterUpdate(ModData modData) { yield break; }
+	}
+}

OpenRA.Mods.Common/UpdateRules/UpdateUtils.cs

@@ -0,0 +1,196 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
+ * This file is part of OpenRA, which is free software. It is made
+ * available to you under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using OpenRA.FileSystem;
+
+namespace OpenRA.Mods.Common.UpdateRules
+{
+	using YamlFileSet = List<Tuple<IReadWritePackage, string, List<MiniYamlNode>>>;
+
+	public static class UpdateUtils
+	{
+		static YamlFileSet LoadYaml(ModData modData, IEnumerable<string> files)
+		{
+			var yaml = new YamlFileSet();
+			foreach (var filename in files)
+			{
+				string name;
+				IReadOnlyPackage package;
+				if (!modData.ModFiles.TryGetPackageContaining(filename, out package, out name) || !(package is IReadWritePackage))
+				{
+					Console.WriteLine("Failed to load file `{0}` for writing. It will not be updated.", filename);
+					continue;
+				}
+
+				yaml.Add(Tuple.Create((IReadWritePackage)package, name, MiniYaml.FromStream(package.GetStream(name), name)));
+			}
+
+			return yaml;
+		}
+
+		static YamlFileSet LoadMapYaml(ModData modData, IReadWritePackage mapPackage, MiniYaml yaml)
+		{
+			var fileSet = new YamlFileSet()
+			{
+				Tuple.Create<IReadWritePackage, string, List<MiniYamlNode>>(null, "map.yaml", yaml.Nodes)
+			};
+
+			var files = FieldLoader.GetValue<string[]>("value", yaml.Value);
+			foreach (var filename in files)
+			{
+				if (!filename.Contains("|") && mapPackage.Contains(filename))
+					fileSet.Add(Tuple.Create(mapPackage, filename, MiniYaml.FromStream(mapPackage.GetStream(filename))));
+				else
+					fileSet.AddRange(LoadYaml(modData, new[] { filename }));
+			}
+
+			return fileSet;
+		}
+
+		public static List<string> UpdateMap(ModData modData, IReadWritePackage mapPackage, UpdateRule rule, out YamlFileSet files)
+		{
+			var manualSteps = new List<string>();
+
+			var mapStream = mapPackage.GetStream("map.yaml");
+			if (mapStream == null)
+			{
+				// Not a valid map
+				files = new YamlFileSet();
+				return manualSteps;
+			}
+
+			var yaml = new MiniYaml(null, MiniYaml.FromStream(mapStream, mapPackage.Name));
+			files = new YamlFileSet() { Tuple.Create(mapPackage, "map.yaml", yaml.Nodes) };
+
+			manualSteps.AddRange(rule.BeforeUpdate(modData));
+
+			var mapRulesNode = yaml.Nodes.FirstOrDefault(n => n.Key == "Rules");
+			if (mapRulesNode != null)
+			{
+				var mapRules = LoadMapYaml(modData, mapPackage, mapRulesNode.Value);
+				manualSteps.AddRange(ApplyTopLevelTransform(modData, mapRules, rule.UpdateActorNode));
+				files.AddRange(mapRules);
+			}
+
+			var mapWeaponsNode = yaml.Nodes.FirstOrDefault(n => n.Key == "Weapons");
+			if (mapWeaponsNode != null)
+			{
+				var mapWeapons = LoadMapYaml(modData, mapPackage, mapWeaponsNode.Value);
+				manualSteps.AddRange(ApplyTopLevelTransform(modData, mapWeapons, rule.UpdateWeaponNode));
+				files.AddRange(mapWeapons);
+			}
+
+			manualSteps.AddRange(rule.AfterUpdate(modData));
+
+			return manualSteps;
+		}
+
+		public static List<string> UpdateMod(ModData modData, UpdateRule rule, out YamlFileSet files)
+		{
+			var manualSteps = new List<string>();
+			var modRules = LoadYaml(modData, modData.Manifest.Rules);
+			var modWeapons = LoadYaml(modData, modData.Manifest.Weapons);
+			var modTilesets = LoadYaml(modData, modData.Manifest.TileSets);
+			var modChromeLayout = LoadYaml(modData, modData.Manifest.ChromeLayout);
+
+			manualSteps.AddRange(rule.BeforeUpdate(modData));
+			manualSteps.AddRange(ApplyTopLevelTransform(modData, modRules, rule.UpdateActorNode));
+			manualSteps.AddRange(ApplyTopLevelTransform(modData, modWeapons, rule.UpdateWeaponNode));
+			manualSteps.AddRange(ApplyTopLevelTransform(modData, modTilesets, rule.UpdateTilesetNode));
+			manualSteps.AddRange(rule.AfterUpdate(modData));
+
+			files = modRules.ToList();
+			files.AddRange(modWeapons);
+			files.AddRange(modTilesets);
+			files.AddRange(modChromeLayout);
+
+			return manualSteps;
+		}
+
+		static IEnumerable<string> ApplyTopLevelTransform(ModData modData, YamlFileSet files, UpdateRule.TopLevelNodeTransform transform)
+		{
+			if (transform == null)
+				yield break;
+
+			foreach (var file in files)
+				foreach (var node in file.Item3)
+					foreach (var manualStep in transform(modData, node))
+						yield return manualStep;
+		}
+
+		public static string FormatMessageList(IEnumerable<string> messages, int indent = 0)
+		{
+			var prefix = string.Concat(Enumerable.Repeat("   ", indent));
+			return string.Concat(messages.Select(m => prefix + " * {0}\n".F(m.Replace("\n", "\n   " + prefix))));
+		}
+	}
+
+	public static class UpdateExtensions
+	{
+		public static void Save(this YamlFileSet files)
+		{
+			foreach (var file in files)
+				if (file.Item1 != null)
+					file.Item1.Update(file.Item2, Encoding.ASCII.GetBytes(file.Item3.WriteToString()));
+		}
+
+		/// <summary>Renames a yaml key preserving any @suffix</summary>
+		public static void RenameKeyPreservingSuffix(this MiniYamlNode node, string newKey)
+		{
+			var split = node.Key.IndexOf("@", StringComparison.Ordinal);
+			if (split == -1)
+				node.Key = newKey;
+			else
+				node.Key = newKey + node.Key.Substring(split);
+		}
+
+		public static T NodeValue<T>(this MiniYamlNode node)
+		{
+			return FieldLoader.GetValue<T>(node.Key, node.Value.Value);
+		}
+
+		public static void AddNode(this MiniYamlNode node, string key, object value)
+		{
+			node.Value.Nodes.Add(new MiniYamlNode(key, FieldSaver.FormatValue(value)));
+		}
+
+		/// <summary>Removes children with keys equal to [match] or [match]@[arbitrary suffix]</summary>
+		public static int RemoveNodes(this MiniYamlNode node, string match)
+		{
+			return node.Value.Nodes.RemoveAll(n => n.KeyMatches(match));
+		}
+
+		/// <summary>Returns true if the node is of the form <match> or <match>@arbitrary</summary>
+		public static bool KeyMatches(this MiniYamlNode node, string match)
+		{
+			if (node.Key == match)
+				return true;
+
+			var atPosition = node.Key.IndexOf('@');
+			return atPosition > 0 && node.Key.Substring(0, atPosition) == match;
+		}
+
+		/// <summary>Returns children with keys equal to [match] or [match]@[arbitrary suffix]</summary>
+		public static IEnumerable<MiniYamlNode> ChildrenMatching(this MiniYamlNode node, string match)
+		{
+			return node.Value.Nodes.Where(n => n.KeyMatches(match));
+		}
+
+		public static MiniYamlNode LastChildMatching(this MiniYamlNode node, string match)
+		{
+			return node.ChildrenMatching(match).LastOrDefault();
+		}
+	}
+}