Moved two more Orders from RA to Common

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

@@ -69,6 +69,8 @@
     <Compile Include="Graphics\VoxelRenderable.cs" />
     <Compile Include="ModChooserLoadScreen.cs" />
     <Compile Include="Orders\DeployOrderTargeter.cs" />
+    <Compile Include="Orders\EnterAlliedActorTargeter.cs" />
+    <Compile Include="Orders\UnitOrderTargeter.cs" />
     <Compile Include="PaletteFromFile.cs" />
     <Compile Include="RallyPoint.cs" />
     <Compile Include="ServerTraits\ColorValidator.cs" />

OpenRA.Mods.Common/Orders/EnterAlliedActorTargeter.cs

@@ -0,0 +1,44 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2014 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. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Orders
+{
+	public class EnterAlliedActorTargeter<T> : UnitOrderTargeter
+	{
+		readonly Func<Actor, bool> canTarget;
+		readonly Func<Actor, bool> useEnterCursor;
+
+		public EnterAlliedActorTargeter(string order, int priority,
+			Func<Actor, bool> canTarget, Func<Actor, bool> useEnterCursor)
+			: base (order, priority, "enter", false, true)
+		{
+			this.canTarget = canTarget;
+			this.useEnterCursor = useEnterCursor;
+		}
+
+		public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
+		{
+			if (!target.HasTrait<T>() || !canTarget(target))
+				return false;
+
+			cursor = useEnterCursor(target) ? "enter" : "enter-blocked";
+			return true;
+		}
+
+		public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
+		{
+			// Allied actors are never frozen
+			return false;
+		}
+	}
+}

OpenRA.Mods.Common/Orders/UnitOrderTargeter.cs

@@ -0,0 +1,87 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2014 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. For more information,
+ * see COPYING.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Orders
+{
+	public abstract class UnitOrderTargeter : IOrderTargeter
+	{
+		readonly string cursor;
+		readonly bool targetEnemyUnits, targetAllyUnits;
+
+		public UnitOrderTargeter(string order, int priority, string cursor, bool targetEnemyUnits, bool targetAllyUnits)
+		{
+			this.OrderID = order;
+			this.OrderPriority = priority;
+			this.cursor = cursor;
+			this.targetEnemyUnits = targetEnemyUnits;
+			this.targetAllyUnits = targetAllyUnits;
+		}
+
+		public string OrderID { get; private set; }
+		public int OrderPriority { get; private set; }
+		public bool? ForceAttack = null;
+
+		public abstract bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor);
+		public abstract bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor);
+
+		public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, TargetModifiers modifiers, ref string cursor)
+		{
+			var type = target.Type;
+			if (type != TargetType.Actor && type != TargetType.FrozenActor)
+				return false;
+
+			cursor = this.cursor;
+			IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
+
+			if (ForceAttack != null && modifiers.HasModifier(TargetModifiers.ForceAttack) != ForceAttack)
+				return false;
+
+			var owner = type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
+			var playerRelationship = self.Owner.Stances[owner];
+
+			if (!modifiers.HasModifier(TargetModifiers.ForceAttack) && playerRelationship == Stance.Ally && !targetAllyUnits)
+				return false;
+
+			if (!modifiers.HasModifier(TargetModifiers.ForceAttack) && playerRelationship == Stance.Enemy && !targetEnemyUnits)
+				return false;
+
+			return type == TargetType.FrozenActor ?
+				CanTargetFrozenActor(self, target.FrozenActor, modifiers, ref cursor) :
+				CanTargetActor(self, target.Actor, modifiers, ref cursor);
+		}
+
+		public virtual bool IsQueued { get; protected set; }
+	}
+
+	public class TargetTypeOrderTargeter : UnitOrderTargeter
+	{
+		readonly string[] targetTypes;
+
+		public TargetTypeOrderTargeter(string[] targetTypes, string order, int priority, string cursor, bool targetEnemyUnits, bool targetAllyUnits)
+			: base(order, priority, cursor, targetEnemyUnits, targetAllyUnits)
+		{
+			this.targetTypes = targetTypes;
+		}
+
+		public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
+		{
+			return target.TraitsImplementing<ITargetable>().Any(t => t.TargetTypes.Intersect(targetTypes).Any());
+		}
+
+		public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
+		{
+			return target.Info.Traits.WithInterface<ITargetableInfo>().Any(t => t.GetTargetTypes().Intersect(targetTypes).Any());
+		}
+	}
+}