Add FrozenActor target type.

OpenRA.Game/GameRules/WeaponInfo.cs

@@ -149,11 +149,27 @@ namespace OpenRA.GameRules
 			return true;
 		}
 
+		public bool IsValidAgainst(FrozenActor a)
+		{
+			var targetable = a.Info.Traits.GetOrDefault<ITargetableInfo>();
+			if (targetable == null || !ValidTargets.Intersect(targetable.GetTargetTypes()).Any())
+				return false;
+
+			if (Warheads.All(w => w.EffectivenessAgainst(a.Info) <= 0))
+				return false;
+
+			return true;
+		}
+
+
 		public bool IsValidAgainst(Target target, World world)
 		{
 			if (target.Type == TargetType.Actor)
 				return IsValidAgainst(target.Actor);
 
+			if (target.Type == TargetType.FrozenActor)
+				return IsValidAgainst(target.FrozenActor);
+
 			if (target.Type == TargetType.Terrain)
 			{
 				var cell = target.CenterPosition.ToCPos();

OpenRA.Game/Traits/Target.cs

@@ -14,7 +14,7 @@ using System.Linq;
 
 namespace OpenRA.Traits
 {
-	public enum TargetType { Invalid, Actor, Terrain }
+	public enum TargetType { Invalid, Actor, Terrain, FrozenActor }
 	public struct Target
 	{
 		public static readonly Target[] None = {};
@@ -22,6 +22,7 @@ namespace OpenRA.Traits
 
 		TargetType type;
 		Actor actor;
+		FrozenActor frozen;
 		WPos pos;
 		int generation;
 
@@ -44,8 +45,11 @@ namespace OpenRA.Traits
 			};
 		}
 
+		public static Target FromFrozenActor(FrozenActor a)  { return new Target { frozen = a, type = TargetType.FrozenActor }; }
+
 		public bool IsValid { get { return Type != TargetType.Invalid; } }
 		public Actor Actor { get { return actor; } }
+		public FrozenActor FrozenActor { get { return frozen; } }
 
 		public TargetType Type
 		{
@@ -71,10 +75,18 @@ namespace OpenRA.Traits
 		{
 			get
 			{
-				if (Type == TargetType.Invalid)
+				switch (Type)
+				{
+				case TargetType.Actor:
+					return actor.CenterPosition;
+				case TargetType.FrozenActor:
+					return frozen.CenterPosition;
+				case TargetType.Terrain:
+					return pos;
+				default:
+				case TargetType.Invalid:
 					throw new InvalidOperationException("Attempting to query the position of an invalid Target");
-
-				return actor != null ? actor.CenterPosition : pos;
+				}
 			}
 		}
 
@@ -84,17 +96,23 @@ namespace OpenRA.Traits
 		{
 			get
 			{
-				if (Type == TargetType.Invalid)
+				switch (Type)
+				{
+				case TargetType.Actor:
+					var targetable = actor.TraitOrDefault<ITargetable>();
+					if (targetable == null)
+						return new [] { actor.CenterPosition };
+
+					var positions = targetable.TargetablePositions(actor);
+					return positions.Any() ? positions : new [] { actor.CenterPosition };
+				case TargetType.FrozenActor:
+					return new [] { frozen.CenterPosition };
+				case TargetType.Terrain:
+					return new [] { pos };
+				default:
+				case TargetType.Invalid:
 					return NoPositions;
-
-				if (actor == null)
-					return new []{pos};
-
-				var targetable = actor.TraitOrDefault<ITargetable>();
-				if (targetable == null)
-					return new []{actor.CenterPosition};
-
-				return targetable.TargetablePositions(actor);
+				}
 			}
 		}
 

OpenRA.Game/Traits/Util.cs

@@ -134,13 +134,7 @@ namespace OpenRA.Traits
 
 		public static IEnumerable<CPos> AdjacentCells(Target target)
 		{
-			var cells = target.Type == TargetType.Actor
-				? target.Actor.OccupiesSpace.OccupiedCells().Select(c => c.First).ToArray()
-				: new CPos[] { };
-
-			if (cells.Length == 0)
-				cells = new CPos[] { target.CenterPosition.ToCPos() };
-
+			var cells = target.Positions.Select(p => p.ToCPos()).Distinct();
 			return Util.ExpandFootprint(cells, true);
 		}
 	}