Enable frozen order: Captures.

OpenRA.Mods.RA/Capturable.cs

@@ -28,6 +28,28 @@ namespace OpenRA.Mods.RA
 		[Desc("Seconds it takes to change the owner.", "You might want to add a CapturableBar: trait, too.")]
 		public readonly int CaptureCompleteTime = 15;
 
+		public bool CanBeTargetedBy(Actor captor, Player owner)
+		{
+			var c = captor.TraitOrDefault<Captures>();
+			if (c == null)
+				return false;
+
+			var playerRelationship = owner.Stances[captor.Owner];
+			if (playerRelationship == Stance.Ally && !AllowAllies)
+				return false;
+
+			if (playerRelationship == Stance.Enemy && !AllowEnemies)
+				return false;
+
+			if (playerRelationship == Stance.Neutral && !AllowNeutral)
+				return false;
+
+			if (!c.Info.CaptureTypes.Contains(Type))
+				return false;
+
+			return true;
+		}
+
 		public object Create(ActorInitializer init) { return new Capturable(init.self, this); }
 	}
 
@@ -45,31 +67,6 @@ namespace OpenRA.Mods.RA
 			Info = info;
 		}
 
-		public bool CanBeTargetedBy(Actor captor)
-		{
-			var c = captor.TraitOrDefault<Captures>();
-			if (c == null)
-				return false;
-
-			var playerRelationship = self.Owner.Stances[captor.Owner];
-			if (playerRelationship == Stance.Ally && !Info.AllowAllies)
-				return false;
-
-			if (playerRelationship == Stance.Enemy && !Info.AllowEnemies)
-				return false;
-
-			if (playerRelationship == Stance.Neutral && !Info.AllowNeutral)
-				return false;
-
-			if (!c.Info.CaptureTypes.Contains(Info.Type))
-				return false;
-
-			if (CaptureInProgress)
-				return false;
-
-			return true;
-		}
-
 		public void BeginCapture(Actor captor)
 		{
 			var building = self.TraitOrDefault<Building>();

OpenRA.Mods.RA/Captures.cs

@@ -12,11 +12,11 @@ using System;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
+using OpenRA.FileFormats;
 using OpenRA.Mods.RA.Activities;
 using OpenRA.Mods.RA.Buildings;
 using OpenRA.Mods.RA.Orders;
 using OpenRA.Traits;
-using OpenRA.FileFormats;
 
 namespace OpenRA.Mods.RA
 {
@@ -34,11 +34,9 @@ namespace OpenRA.Mods.RA
 	class Captures : IIssueOrder, IResolveOrder, IOrderVoice
 	{
 		public readonly CapturesInfo Info;
-		readonly Actor self;
 
 		public Captures(Actor self, CapturesInfo info)
 		{
-			this.self = self;
 			Info = info;
 		}
 
@@ -46,65 +44,89 @@ namespace OpenRA.Mods.RA
 		{
 			get
 			{
-				yield return new CaptureOrderTargeter(CanCapture);
+				yield return new CaptureOrderTargeter();
 			}
 		}
 
 		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
 		{
-			if (order.OrderID == "CaptureActor")
-				return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
+			if (order.OrderID != "CaptureActor")
+				return null;
 
-			return null;
+			if (target.Type == TargetType.FrozenActor)
+				return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID };
+
+			return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
+		}
+
+		bool IsValidOrder(Actor self, Order order)
+		{
+			// Not targeting an actor
+			if (order.ExtraData == 0 && order.TargetActor == null)
+				return false;
+
+			if (order.ExtraData != 0)
+			{
+				// Targeted an actor under the fog
+				var frozenLayer = self.Owner.PlayerActor.TraitOrDefault<FrozenActorLayer>();
+				if (frozenLayer == null)
+					return false;
+
+				var frozen = frozenLayer.FromID(order.ExtraData);
+				if (frozen == null)
+					return false;
+
+				var ci = frozen.Info.Traits.GetOrDefault<CapturableInfo>();
+				return ci != null && ci.CanBeTargetedBy(self, frozen.Owner);
+			}
+
+			var c = order.TargetActor.TraitOrDefault<Capturable>();
+			return c != null && !c.CaptureInProgress && c.Info.CanBeTargetedBy(self, order.TargetActor.Owner);
 		}
 
 		public string VoicePhraseForOrder(Actor self, Order order)
 		{
-			return (order.OrderString == "CaptureActor" && CanCapture(order.TargetActor)) ? "Attack" : null;
+			return order.OrderString == "CaptureActor" && IsValidOrder(self, order)
+				? "Attack" : null;
 		}
 
 		public void ResolveOrder(Actor self, Order order)
 		{
-			if (order.OrderString == "CaptureActor")
-			{
-				if (!CanCapture(order.TargetActor))
-					return;
+			if (order.OrderString != "CaptureActor" || !IsValidOrder(self, order))
+				return;
 
-				self.SetTargetLine(Target.FromOrder(order), Color.Red);
+			var target = self.ResolveFrozenActorOrder(order, Color.Red);
+			if (target.Type != TargetType.Actor)
+				return;
 
+			if (!order.Queued)
 				self.CancelActivity();
-				self.QueueActivity(new CaptureActor(Target.FromOrder(order)));
-			}
-		}
 
-		bool CanCapture(Actor target)
-		{
-			var c = target.TraitOrDefault<Capturable>();
-			return c != null && c.CanBeTargetedBy(self);
+			self.SetTargetLine(target, Color.Red);
+			self.QueueActivity(new CaptureActor(target));
 		}
 	}
 
 	class CaptureOrderTargeter : UnitOrderTargeter
 	{
-		readonly Func<Actor, bool> useCaptureCursor;
-
-		public CaptureOrderTargeter(Func<Actor, bool> useCaptureCursor)
-			: base("CaptureActor", 6, "enter", true, true)
-		{
-			this.useCaptureCursor = useCaptureCursor;
-		}
+		public CaptureOrderTargeter() : base("CaptureActor", 6, "enter", true, true) { }
 
 		public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
 		{
-			var canTargetActor = useCaptureCursor(target);
+			var c = target.TraitOrDefault<Capturable>();
+
+			var canTargetActor = c != null && !c.CaptureInProgress && c.Info.CanBeTargetedBy(self, target.Owner);
 			cursor = canTargetActor ? "ability" : "move-blocked";
 			return canTargetActor;
 		}
 
 		public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
 		{
-			// TODO: Not yet supported
-			return false;
+			var c = target.Info.Traits.GetOrDefault<CapturableInfo>();
+
+			var canTargetActor = c != null && c.CanBeTargetedBy(self, target.Owner);
+			cursor = canTargetActor ? "ability" : "move-blocked";
+			return canTargetActor;
 		}
 	}
 }