Implement new mod/map updater framework.

OpenRA.Mods.Common/OpenRA.Mods.Common.csproj

@@ -578,9 +578,6 @@
     <Compile Include="UtilityCommands\ImportLegacyMapCommand.cs" />
     <Compile Include="UtilityCommands\RemapShpCommand.cs" />
     <Compile Include="UtilityCommands\ReplayMetadataCommand.cs" />
-    <Compile Include="UtilityCommands\UpgradeMapCommand.cs" />
-    <Compile Include="UtilityCommands\UpgradeModCommand.cs" />
-    <Compile Include="UtilityCommands\UpgradeRules.cs" />
     <Compile Include="UtilityCommands\Rgba2Hex.cs" />
     <Compile Include="Warheads\CreateEffectWarhead.cs" />
     <Compile Include="Warheads\CreateResourceWarhead.cs" />
@@ -847,6 +844,17 @@
     <Compile Include="Widgets\Logic\DirectConnectLogic.cs" />
     <Compile Include="Traits\Conditions\ToggleConditionOnOrder.cs" />
     <Compile Include="Widgets\Logic\ServerListLogic.cs" />
+    <Compile Include="UpdateRules\UpdateRule.cs" />
+    <Compile Include="UtilityCommands\UpdateModCommand.cs" />
+    <Compile Include="UpdateRules\UpdatePath.cs" />
+    <Compile Include="UpdateRules\UpdateUtils.cs" />
+    <Compile Include="UtilityCommands\UpdateMapCommand.cs" />
+    <Compile Include="UpdateRules\Rules\RemoveTerrainTypeIsWaterFlag.cs" />
+    <Compile Include="UpdateRules\Rules\RemoveWeaponScanRadius.cs" />
+    <Compile Include="UpdateRules\Rules\DefineSoundDefaults.cs" />
+    <Compile Include="UpdateRules\Rules\SplitTurretAimAnimation.cs" />
+    <Compile Include="UpdateRules\Rules\RenameWormSpawner.cs" />
+    <Compile Include="UpdateRules\Rules\RemoveWithReloadingSpriteTurret.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Target Name="AfterBuild">

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();
+		}
+	}
+}

OpenRA.Mods.Common/UtilityCommands/UpdateMapCommand.cs

@@ -0,0 +1,121 @@
+#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.IO;
+using System.Linq;
+using OpenRA.FileSystem;
+using OpenRA.Mods.Common.UpdateRules;
+
+namespace OpenRA.Mods.Common.UtilityCommands
+{
+	using YamlFileSet = List<Tuple<IReadWritePackage, string, List<MiniYamlNode>>>;
+
+	class UpdateMapCommand : IUtilityCommand
+	{
+		string IUtilityCommand.Name { get { return "--update-map"; } }
+
+		bool IUtilityCommand.ValidateArguments(string[] args)
+		{
+			return args.Length >= 2;
+		}
+
+		[Desc("MAP SOURCE [--detailed] [--apply]", "Updates a map to the latest engine version. SOURCE is either a known tag or the name of an update rule.")]
+		void IUtilityCommand.Run(Utility utility, string[] args)
+		{
+			// HACK: The engine code assumes that Game.modData is set.
+			var modData = Game.ModData = utility.ModData;
+
+			// HACK: We know that maps can only be oramap or folders, which are ReadWrite
+			var package = new Folder(".").OpenPackage(args[1], modData.ModFiles) as IReadWritePackage;
+			if (package == null)
+				throw new FileNotFoundException(args[1]);
+
+			IEnumerable<UpdateRule> rules = null;
+			if (args.Length > 1)
+				rules = UpdatePath.FromSource(modData.ObjectCreator, args[2]);
+
+			if (rules == null)
+			{
+				Console.WriteLine("--update-map MAP SOURCE [--detailed] [--apply]");
+
+				if (args.Length > 2)
+					Console.WriteLine("Unknown source: " + args[2]);
+
+				Console.WriteLine("Valid sources are:");
+
+				// Print known tags
+				Console.WriteLine("   Update Paths:");
+				foreach (var p in UpdatePath.KnownPaths)
+					Console.WriteLine("      " + p);
+
+				// Print known rules
+				Console.WriteLine("   Individual Rules:");
+				foreach (var r in UpdatePath.KnownRules(modData.ObjectCreator))
+					Console.WriteLine("      " + r);
+
+				return;
+			}
+
+			if (args.Contains("--apply"))
+				ApplyRules(modData, package, rules);
+			else
+				UpdateModCommand.PrintSummary(rules, args.Contains("--detailed"));
+		}
+
+		static void ApplyRules(ModData modData, IReadWritePackage mapPackage, IEnumerable<UpdateRule> rules)
+		{
+			foreach (var rule in rules)
+			{
+				Console.WriteLine("{0}: {1}", rule.GetType().Name, rule.Name);
+				var mapFiles = new YamlFileSet();
+				var manualSteps = new List<string>();
+
+				Console.Write("   Updating map... ");
+
+				try
+				{
+					manualSteps = UpdateUtils.UpdateMap(modData, mapPackage, rule, out mapFiles);
+				}
+				catch (Exception ex)
+				{
+					Console.WriteLine("FAILED");
+
+					Console.WriteLine();
+					Console.WriteLine("   The automated changes for this rule were not applied because of an error.");
+					Console.WriteLine("   After the issue reported below is resolved you should run the updater");
+					Console.WriteLine("   with SOURCE set to {0} to retry these changes", rule.GetType().Name);
+					Console.WriteLine();
+					Console.WriteLine("   The exception reported was:");
+					Console.WriteLine("     " + ex.ToString().Replace("\n", "\n     "));
+					continue;
+				}
+
+				// Files are saved after each successful automated rule update
+				mapFiles.Save();
+				Console.WriteLine("COMPLETE");
+
+				if (manualSteps.Any())
+				{
+					Console.WriteLine("   Manual changes are required to complete this update:");
+					foreach (var manualStep in manualSteps)
+						Console.WriteLine("    * " + manualStep.Replace("\n", "\n      "));
+				}
+
+				Console.WriteLine();
+			}
+
+			Console.WriteLine("Semi-automated update complete.");
+			Console.WriteLine("Please review the messages above for any manual actions that must be applied.");
+		}
+	}
+}

OpenRA.Mods.Common/UtilityCommands/UpdateModCommand.cs

@@ -0,0 +1,206 @@
+#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 OpenRA.FileSystem;
+using OpenRA.Mods.Common.UpdateRules;
+
+namespace OpenRA.Mods.Common.UtilityCommands
+{
+	using YamlFileSet = List<Tuple<IReadWritePackage, string, List<MiniYamlNode>>>;
+
+	class UpdateModCommand : IUtilityCommand
+	{
+		string IUtilityCommand.Name { get { return "--update-mod"; } }
+
+		bool IUtilityCommand.ValidateArguments(string[] args) { return true; }
+
+		[Desc("SOURCE [--detailed] [--apply] [--skip-maps]", "Updates a mod to the latest version. SOURCE is either a known tag or the name of an update rule.")]
+		void IUtilityCommand.Run(Utility utility, string[] args)
+		{
+			// HACK: The engine code assumes that Game.modData is set.
+			var modData = Game.ModData = utility.ModData;
+
+			IEnumerable<UpdateRule> rules = null;
+			if (args.Length > 1)
+				rules = UpdatePath.FromSource(modData.ObjectCreator, args[1]);
+
+			if (rules == null)
+			{
+				Console.WriteLine("--update-mod SOURCE [--detailed] [--apply] [--skip-maps]");
+
+				if (args.Length > 1)
+					Console.WriteLine("Unknown source: " + args[1]);
+
+				Console.WriteLine("Valid sources are:");
+
+				// Print known tags
+				Console.WriteLine("   Update Paths:");
+				foreach (var p in UpdatePath.KnownPaths)
+					Console.WriteLine("      " + p);
+
+				// Print known rules
+				Console.WriteLine("   Individual Rules:");
+				foreach (var r in UpdatePath.KnownRules(modData.ObjectCreator))
+					Console.WriteLine("      " + r);
+
+				return;
+			}
+
+			if (args.Contains("--apply"))
+			{
+				if (!args.Contains("--yes"))
+				{
+					Console.WriteLine("WARNING: This command will automatically rewrite your mod rules.");
+					Console.WriteLine("Side effects of this command may include changing the whitespace to ");
+					Console.WriteLine("match the default conventions, and any yaml comments will be removed.");
+					Console.WriteLine();
+					Console.WriteLine("We strongly recommend that you have a backup of your mod rules, and ");
+					Console.WriteLine("for best results, to use a Git client to review the line-by-line ");
+					Console.WriteLine("changes and discard any unwanted side effects.");
+					Console.WriteLine();
+					Console.Write("Press y to continue, or any other key to cancel: ");
+
+					var confirmKey = Console.ReadKey().KeyChar;
+					Console.WriteLine();
+
+					if (confirmKey != 'y')
+					{
+						Console.WriteLine("Update cancelled.");
+						return;
+					}
+				}
+
+				ApplyRules(modData, rules, args.Contains("--skip-maps"));
+			}
+			else
+				PrintSummary(rules, args.Contains("--detailed"));
+		}
+
+		public static void PrintSummary(IEnumerable<UpdateRule> rules, bool detailed)
+		{
+			var count = rules.Count();
+			if (count == 1)
+				Console.WriteLine("Found 1 API change:");
+			else
+				Console.WriteLine("Found {0} API changes:", count);
+
+			foreach (var rule in rules)
+			{
+				Console.WriteLine("  * {0}: {1}", rule.GetType().Name, rule.Name);
+				if (detailed)
+				{
+					Console.WriteLine("     " + rule.Description.Replace("\n", "\n     "));
+					Console.WriteLine();
+				}
+			}
+
+			if (!detailed)
+			{
+				Console.WriteLine();
+				Console.WriteLine("Run this command with the --detailed flag to view detailed information on each change.");
+			}
+
+			Console.WriteLine("Run this command with the --apply flag to apply the update rules.");
+		}
+
+		static void ApplyRules(ModData modData, IEnumerable<UpdateRule> rules, bool skipMaps)
+		{
+			Console.WriteLine();
+			foreach (var rule in rules)
+			{
+				var manualSteps = new List<string>();
+				var allFiles = new YamlFileSet();
+
+				Console.WriteLine("{0}: {1}", rule.GetType().Name, rule.Name);
+
+				try
+				{
+					Console.Write("   Updating mod... ");
+					manualSteps.AddRange(UpdateUtils.UpdateMod(modData, rule, out allFiles));
+					Console.WriteLine("COMPLETE");
+				}
+				catch (Exception ex)
+				{
+					Console.WriteLine("FAILED");
+
+					Console.WriteLine();
+					Console.WriteLine("   The automated changes for this rule were not applied because of an error.");
+					Console.WriteLine("   After the issue reported below is resolved you should run the updater");
+					Console.WriteLine("   with SOURCE set to {0} to retry these changes", rule.GetType().Name);
+					Console.WriteLine();
+					Console.WriteLine("   The exception reported was:");
+					Console.WriteLine("     " + ex.ToString().Replace("\n", "\n     "));
+
+					continue;
+				}
+
+				Console.Write("   Updating system maps... ");
+				if (!skipMaps)
+				{
+					var mapsFailed = false;
+					foreach (var package in modData.MapCache.EnumerateMapPackagesWithoutCaching())
+					{
+						try
+						{
+							YamlFileSet mapFiles;
+							var mapSteps = UpdateUtils.UpdateMap(modData, package, rule, out mapFiles);
+							allFiles.AddRange(mapFiles);
+
+							if (mapSteps.Any())
+								manualSteps.Add("Map: " + package.Name + ":\n" + UpdateUtils.FormatMessageList(mapSteps));
+						}
+						catch (Exception ex)
+						{
+							Console.WriteLine("FAILED");
+
+							Console.WriteLine();
+							Console.WriteLine("   The automated changes for this rule were not applied because of an error.");
+							Console.WriteLine("   After the issue reported below is resolved you should run the updater");
+							Console.WriteLine("   with SOURCE set to {0} to retry these changes", rule.GetType().Name);
+							Console.WriteLine();
+							Console.WriteLine("   The map that caused the error was:");
+							Console.WriteLine("     " + package.Name);
+							Console.WriteLine();
+							Console.WriteLine("   The exception reported was:");
+							Console.WriteLine("     " + ex.ToString().Replace("\n", "\n     "));
+							mapsFailed = true;
+							break;
+						}
+					}
+
+					if (mapsFailed)
+						continue;
+
+					Console.WriteLine("COMPLETE");
+				}
+				else
+					Console.WriteLine("SKIPPED");
+
+				// Files are saved after each successful automated rule update
+				allFiles.Save();
+
+				if (manualSteps.Any())
+				{
+					Console.WriteLine("   Manual changes are required to complete this update:");
+					Console.WriteLine(UpdateUtils.FormatMessageList(manualSteps, 1));
+				}
+
+				Console.WriteLine();
+			}
+
+			Console.WriteLine("Semi-automated update complete.");
+			Console.WriteLine("Please review the messages above for any manual actions that must be applied.");
+		}
+	}
+}

OpenRA.Mods.Common/UtilityCommands/UpgradeMapCommand.cs

@@ -1,122 +0,0 @@
-#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.IO;
-using System.Linq;
-using System.Text;
-using OpenRA.FileSystem;
-
-namespace OpenRA.Mods.Common.UtilityCommands
-{
-	class UpgradeMapCommand : IUtilityCommand
-	{
-		string IUtilityCommand.Name { get { return "--upgrade-map"; } }
-
-		bool IUtilityCommand.ValidateArguments(string[] args)
-		{
-			return args.Length >= 3;
-		}
-
-		delegate void UpgradeAction(ModData modData, int engineVersion, ref List<MiniYamlNode> nodes, MiniYamlNode parent, int depth);
-
-		static Stream Open(string filename, IReadOnlyPackage package, IReadOnlyFileSystem fallback)
-		{
-			// Explicit package paths never refer to a map
-			if (!filename.Contains("|") && package.Contains(filename))
-				return package.GetStream(filename);
-
-			return fallback.Open(filename);
-		}
-
-		static void ProcessYaml(ModData modData, IReadOnlyPackage package, MiniYaml yaml, int engineDate, UpgradeAction processYaml)
-		{
-			if (yaml == null)
-				return;
-
-			if (yaml.Value != null)
-			{
-				var files = FieldLoader.GetValue<string[]>("value", yaml.Value);
-				foreach (var filename in files)
-				{
-					var fileNodes = MiniYaml.FromStream(Open(filename, package, modData.DefaultFileSystem), filename);
-					processYaml(modData, engineDate, ref fileNodes, null, 0);
-
-					// HACK: Obtain the writable save path using knowledge of the underlying filesystem workings
-					var packagePath = filename;
-					var p = package;
-					if (filename.Contains("|"))
-						modData.DefaultFileSystem.TryGetPackageContaining(filename, out p, out packagePath);
-
-					((IReadWritePackage)p).Update(packagePath, Encoding.ASCII.GetBytes(fileNodes.WriteToString()));
-				}
-			}
-
-			processYaml(modData, engineDate, ref yaml.Nodes, null, 1);
-		}
-
-		public static void UpgradeMap(ModData modData, IReadWritePackage package, int engineDate)
-		{
-			UpgradeRules.UpgradeMapFormat(modData, package);
-
-			if (engineDate < UpgradeRules.MinimumSupportedVersion)
-			{
-				Console.WriteLine("Unsupported engine version. Use the release-{0} utility to update to that version, and then try again",
-					UpgradeRules.MinimumSupportedVersion);
-				return;
-			}
-
-			var mapStream = package.GetStream("map.yaml");
-			if (mapStream == null)
-				return;
-
-			var yaml = new MiniYaml(null, MiniYaml.FromStream(mapStream, package.Name));
-
-			var rules = yaml.Nodes.FirstOrDefault(n => n.Key == "Rules");
-			if (rules != null)
-				ProcessYaml(modData, package, rules.Value, engineDate, UpgradeRules.UpgradeActorRules);
-
-			var weapons = yaml.Nodes.FirstOrDefault(n => n.Key == "Weapons");
-			if (weapons != null)
-				ProcessYaml(modData, package, weapons.Value, engineDate, UpgradeRules.UpgradeWeaponRules);
-
-			var sequences = yaml.Nodes.FirstOrDefault(n => n.Key == "Sequences");
-			if (sequences != null)
-				ProcessYaml(modData, package, sequences.Value, engineDate, UpgradeRules.UpgradeSequences);
-
-			var players = yaml.Nodes.FirstOrDefault(n => n.Key == "Players");
-			if (players != null)
-				UpgradeRules.UpgradePlayers(modData, engineDate, ref players.Value.Nodes, null, 0);
-
-			var actors = yaml.Nodes.FirstOrDefault(n => n.Key == "Actors");
-			if (actors != null)
-				UpgradeRules.UpgradeActors(modData, engineDate, ref actors.Value.Nodes, null, 0);
-
-			package.Update("map.yaml", Encoding.UTF8.GetBytes(yaml.Nodes.WriteToString()));
-		}
-
-		[Desc("MAP", "OLDENGINE", "Upgrade map rules to the latest engine version.")]
-		void IUtilityCommand.Run(Utility utility, string[] args)
-		{
-			// HACK: The engine code assumes that Game.modData is set.
-			var modData = Game.ModData = utility.ModData;
-
-			// HACK: We know that maps can only be oramap or folders, which are ReadWrite
-			var package = new Folder(".").OpenPackage(args[1], modData.ModFiles) as IReadWritePackage;
-			if (package == null)
-				throw new FileNotFoundException(args[1]);
-
-			var engineDate = Exts.ParseIntegerInvariant(args[2]);
-			UpgradeMap(modData, package, engineDate);
-		}
-	}
-}

OpenRA.Mods.Common/UtilityCommands/UpgradeModCommand.cs

@@ -1,95 +0,0 @@
-#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.IO;
-using System.Linq;
-using OpenRA.FileSystem;
-
-namespace OpenRA.Mods.Common.UtilityCommands
-{
-	class UpgradeModCommand : IUtilityCommand
-	{
-		string IUtilityCommand.Name { get { return "--upgrade-mod"; } }
-
-		bool IUtilityCommand.ValidateArguments(string[] args)
-		{
-			return args.Length >= 2;
-		}
-
-		delegate void UpgradeAction(ModData modData, int engineVersion, ref List<MiniYamlNode> nodes, MiniYamlNode parent, int depth);
-
-		void ProcessYaml(string type, IEnumerable<string> files, ModData modData, int engineDate, UpgradeAction processFile)
-		{
-			Console.WriteLine("Processing {0}:", type);
-			foreach (var filename in files)
-			{
-				Console.WriteLine("\t" + filename);
-				string name;
-				IReadOnlyPackage package;
-				if (!modData.ModFiles.TryGetPackageContaining(filename, out package, out name) || !(package is Folder))
-				{
-					Console.WriteLine("\t\tFile cannot be opened for writing! Ignoring...");
-					continue;
-				}
-
-				var yaml = MiniYaml.FromStream(package.GetStream(name), name);
-				processFile(modData, engineDate, ref yaml, null, 0);
-
-				// Generate the on-disk path
-				var path = Path.Combine(package.Name, name);
-				using (var file = new StreamWriter(path))
-					file.Write(yaml.WriteToString());
-			}
-		}
-
-		[Desc("OLDENGINE", "Upgrade mod rules to the latest engine version.")]
-		void IUtilityCommand.Run(Utility utility, string[] args)
-		{
-			// HACK: The engine code assumes that Game.modData is set.
-			var modData = Game.ModData = utility.ModData;
-
-			var engineDate = Exts.ParseIntegerInvariant(args[1]);
-			if (engineDate < UpgradeRules.MinimumSupportedVersion)
-			{
-				Console.WriteLine("Unsupported engine version. Use the release-{0} utility to update to that version, and then try again",
-					UpgradeRules.MinimumSupportedVersion);
-				return;
-			}
-
-			ProcessYaml("Rules", modData.Manifest.Rules, modData, engineDate, UpgradeRules.UpgradeActorRules);
-			ProcessYaml("Weapons", modData.Manifest.Weapons, modData, engineDate, UpgradeRules.UpgradeWeaponRules);
-			ProcessYaml("Sequences", modData.Manifest.Sequences, modData, engineDate, UpgradeRules.UpgradeSequences);
-			ProcessYaml("Tilesets", modData.Manifest.TileSets, modData, engineDate, UpgradeRules.UpgradeTileset);
-			ProcessYaml("Cursors", modData.Manifest.Cursors, modData, engineDate, UpgradeRules.UpgradeCursors);
-			ProcessYaml("Chrome Metrics", modData.Manifest.ChromeMetrics, modData, engineDate, UpgradeRules.UpgradeChromeMetrics);
-			ProcessYaml("Chrome Layout", modData.Manifest.ChromeLayout, modData, engineDate, UpgradeRules.UpgradeChromeLayout);
-
-			// The map cache won't be valid if there was a map format upgrade, so walk the map packages manually
-			// Only upgrade system maps - user maps must be updated manually using --upgrade-map
-			Console.WriteLine("Processing System Maps:");
-			foreach (var package in modData.MapCache.EnumerateMapPackagesWithoutCaching())
-			{
-				try
-				{
-					Console.WriteLine(package.Name);
-					UpgradeMapCommand.UpgradeMap(modData, package, engineDate);
-				}
-				catch (Exception e)
-				{
-					Console.WriteLine("Failed to upgrade map {0}", package.Name);
-					Console.WriteLine("Error was: {0}", e.ToString());
-				}
-			}
-		}
-	}
-}