Make deploying mines queueable.

make use of QueueActivity's own handling of order.Queued

Make LayMines use childactivities.

OpenRA.Mods.Cnc/Activities/LayMines.cs

@@ -22,26 +22,35 @@ namespace OpenRA.Mods.Cnc.Activities
 	// Assumes you have Minelayer on that unit
 	public class LayMines : Activity
 	{
-		readonly Minelayer minelayer;
 		readonly MinelayerInfo info;
 		readonly AmmoPool[] ammoPools;
 		readonly IMove movement;
 		readonly RearmableInfo rearmableInfo;
+		readonly CPos[] minefield;
 
-		public LayMines(Actor self)
+		public LayMines(Actor self, CPos[] minefield)
 		{
-			minelayer = self.TraitOrDefault<Minelayer>();
 			info = self.Info.TraitInfo<MinelayerInfo>();
 			ammoPools = self.TraitsImplementing<AmmoPool>().ToArray();
 			movement = self.Trait<IMove>();
 			rearmableInfo = self.Info.TraitInfoOrDefault<RearmableInfo>();
+			this.minefield = minefield;
 		}
 
 		public override Activity Tick(Actor self)
 		{
+			if (ChildActivity != null)
+			{
+				ChildActivity = ActivityUtils.RunActivity(self, ChildActivity);
+				return this;
+			}
+
 			if (IsCanceling)
 				return NextActivity;
 
+			if (minefield.Length == 0)
+				return NextActivity;
+
 			if (rearmableInfo != null && ammoPools.Any(p => p.Info.Name == info.AmmoPoolName && !p.HasAmmo()))
 			{
 				// Rearm (and possibly repair) at rearm building, then back out here to refill the minefield some more
@@ -50,36 +59,39 @@ public override Activity Tick(Actor self)
 					.ClosestTo(self);
 
 				if (rearmTarget == null)
-					return new Wait(20);
+					return NextActivity;
 
 				// Add a CloseEnough range of 512 to the Rearm/Repair activities in order to ensure that we're at the host actor
-				return ActivityUtils.SequenceActivities(self,
-					new MoveAdjacentTo(self, Target.FromActor(rearmTarget)),
-					movement.MoveTo(self.World.Map.CellContaining(rearmTarget.CenterPosition), rearmTarget),
-					new Rearm(self, rearmTarget, new WDist(512)),
-					new Repair(self, rearmTarget, new WDist(512)),
-					this);
+				QueueChild(self, new MoveAdjacentTo(self, Target.FromActor(rearmTarget)), true);
+				QueueChild(self, movement.MoveTo(self.World.Map.CellContaining(rearmTarget.CenterPosition), rearmTarget));
+				QueueChild(self, new Rearm(self, rearmTarget, new WDist(512)));
+				QueueChild(self, new Repair(self, rearmTarget, new WDist(512)));
+				return this;
 			}
 
-			if (minelayer.Minefield.Contains(self.Location) && ShouldLayMine(self, self.Location))
+			if (minefield.Contains(self.Location) && ShouldLayMine(self, self.Location))
 			{
 				LayMine(self);
-				return ActivityUtils.SequenceActivities(self, new Wait(20), this); // A little wait after placing each mine, for show
+				QueueChild(self, new Wait(20), true); // A little wait after placing each mine, for show
+				return this;
 			}
 
-			if (minelayer.Minefield.Length > 0)
+			if (minefield.Length > 0)
 			{
 				// Don't get stuck forever here
 				for (var n = 0; n < 20; n++)
 				{
-					var p = minelayer.Minefield.Random(self.World.SharedRandom);
+					var p = minefield.Random(self.World.SharedRandom);
 					if (ShouldLayMine(self, p))
-						return ActivityUtils.SequenceActivities(self, movement.MoveTo(p, 0), this);
+					{
+						QueueChild(self, movement.MoveTo(p, 0), true);
+						return this;
+					}
 				}
 			}
 
 			// TODO: Return somewhere likely to be safe (near rearm building) so we're not sitting out in the minefield.
-			return new Wait(20);	// nothing to do here
+			return NextActivity;
 		}
 
 		static bool ShouldLayMine(Actor self, CPos p)

OpenRA.Mods.Cnc/Traits/Minelayer.cs

@@ -70,11 +70,11 @@ Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, Target target, bo
 					if (self.World.OrderGenerator is MinefieldOrderGenerator)
 						((MinefieldOrderGenerator)self.World.OrderGenerator).AddMinelayer(self, start);
 					else
-						self.World.OrderGenerator = new MinefieldOrderGenerator(self, start);
+						self.World.OrderGenerator = new MinefieldOrderGenerator(self, start, queued);
 
-					return new Order("BeginMinefield", self, Target.FromCell(self.World, start), false);
+					return new Order("BeginMinefield", self, Target.FromCell(self.World, start), queued);
 				case "PlaceMine":
-					return new Order("PlaceMine", self, Target.FromCell(self.World, self.Location), false);
+					return new Order("PlaceMine", self, Target.FromCell(self.World, self.Location), queued);
 				default:
 					return null;
 			}
@@ -99,8 +99,7 @@ void IResolveOrder.ResolveOrder(Actor self, Order order)
 			{
 				minefieldStart = cell;
 				Minefield = new[] { cell };
-				self.CancelActivity();
-				self.QueueActivity(new LayMines(self));
+				self.QueueActivity(order.Queued, new LayMines(self, Minefield));
 			}
 			else if (order.OrderString == "PlaceMinefield")
 			{
@@ -112,8 +111,7 @@ void IResolveOrder.ResolveOrder(Actor self, Order order)
 				if (Minefield.Length == 1 && Minefield[0] != self.Location)
 					self.SetTargetLine(Target.FromCell(self.World, Minefield[0]), Color.Red);
 
-				self.CancelActivity();
-				self.QueueActivity(new LayMines(self));
+				self.QueueActivity(order.Queued, new LayMines(self, Minefield));
 			}
 		}
 
@@ -167,11 +165,13 @@ class MinefieldOrderGenerator : IOrderGenerator
 			readonly Sprite tileOk;
 			readonly Sprite tileBlocked;
 			readonly CPos minefieldStart;
+			readonly bool queued;
 
-			public MinefieldOrderGenerator(Actor a, CPos xy)
+			public MinefieldOrderGenerator(Actor a, CPos xy, bool queued)
 			{
 				minelayers = new List<Actor>() { a };
 				minefieldStart = xy;
+				this.queued = queued;
 
 				var tileset = a.World.Map.Tileset.ToLowerInvariant();
 				tileOk = a.World.Map.Rules.Sequences.GetSequence("overlay", "build-valid-{0}".F(tileset)).GetSprite(0);
@@ -201,7 +201,7 @@ public IEnumerable<Order> Order(World world, CPos cell, int2 worldPixel, MouseIn
 				{
 					minelayers.First().World.CancelInputMode();
 					foreach (var minelayer in minelayers)
-						yield return new Order("PlaceMinefield", minelayer, Target.FromCell(world, cell), false);
+						yield return new Order("PlaceMinefield", minelayer, Target.FromCell(world, cell), queued);
 				}
 			}
 

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

@@ -987,4 +987,4 @@
     <Message Text="DEBUG TargetName:             $(TargetName)"/>
     -->
   </Target>
-</Project>
+</Project>