Move Enter and Repair Building activities, EngineerRepair trait and ActorExts to Mods.Common and extract IgnoresDisguise trait to its own file

OpenRA.Mods.Common/Activities/Enter.cs

@@ -0,0 +1,269 @@
+#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 System.Linq;
+using OpenRA.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Activities
+{
+	public abstract class Enter : Activity
+	{
+		public enum ReserveStatus { None, TooFar, Pending, Ready }
+		enum State { ApproachingOrEntering, Inside, Exiting, Done }
+
+		readonly IMove move;
+		readonly int maxTries = 0;
+		readonly bool targetCenter;
+		public Target Target { get { return target; } }
+		Target target;
+		State nextState = State.ApproachingOrEntering; // Hint/starting point for next state
+		bool isEnteringOrInside = false; // Used to know if exiting should be used
+		WPos savedPos; // Position just before entering
+		Activity inner;
+		bool firstApproach = true;
+
+		protected Enter(Actor self, Actor target, int maxTries = 1, bool targetCenter = false)
+		{
+			this.move = self.Trait<IMove>();
+			this.target = Target.FromActor(target);
+			this.maxTries = maxTries;
+			this.targetCenter = targetCenter;
+		}
+
+		// CanEnter(target) should to be true; othwise, Enter may abort.
+		// Tries counter starts at 1 (reset every tick)
+		protected virtual bool TryGetAlternateTarget(Actor self, int tries, ref Target target) { return false; }
+		protected virtual bool CanReserve(Actor self) { return true; }
+		protected virtual ReserveStatus Reserve(Actor self)
+		{
+			return !CanReserve(self) ? ReserveStatus.None : move.CanEnterTargetNow(self, target) ? ReserveStatus.Ready : ReserveStatus.TooFar;
+		}
+
+		protected virtual void Unreserve(Actor self, bool abort) { }
+		protected virtual void OnInside(Actor self) { }
+
+		protected bool TryGetAlternateTargetInCircle(Actor self, WRange radius, Action<Target> update, Func<Actor, bool> primaryFilter, Func<Actor, bool>[] preferenceFilters = null)
+		{
+			var radiusSquared = radius.Range * radius.Range;
+			var diff = new WVec(radius, radius, WRange.Zero);
+			var candidates = self.World.ActorMap.ActorsInBox(self.CenterPosition - diff, self.CenterPosition + diff)
+				.Where(primaryFilter).Select(a => new { Actor = a, Ls = (self.CenterPosition - a.CenterPosition).HorizontalLengthSquared })
+				.Where(p => p.Ls <= radiusSquared).OrderBy(p => p.Ls).Select(p => p.Actor);
+			if (preferenceFilters != null)
+				foreach (var filter in preferenceFilters)
+				{
+					var preferredCandidate = candidates.FirstOrDefault(filter);
+					if (preferredCandidate == null)
+						continue;
+					target = Target.FromActor(preferredCandidate);
+					update(target);
+					return true;
+				}
+
+			var candidate = candidates.FirstOrDefault();
+			if (candidate == null)
+				return false;
+			target = Target.FromActor(candidate);
+			update(target);
+			return true;
+		}
+
+		// Called when inner activity is this and returns inner activity for next tick.
+		protected virtual Activity InsideTick(Actor self) { return null; }
+
+		// Abort entering and/or leave if necessary
+		protected virtual void AbortOrExit(Actor self)
+		{
+			if (nextState == State.Done)
+				return;
+			nextState = isEnteringOrInside ? State.Exiting : State.Done;
+			if (inner == this)
+				inner = null;
+			else if (inner != null)
+				inner.Cancel(self);
+			if (isEnteringOrInside)
+				Unreserve(self, true);
+		}
+
+		// Cancel inner activity and mark as done unless already leaving or done
+		protected void Done(Actor self)
+		{
+			if (nextState == State.Done)
+				return;
+			nextState = State.Done;
+			if (inner == this)
+				inner = null;
+			else if (inner != null)
+				inner.Cancel(self);
+		}
+
+		public override void Cancel(Actor self)
+		{
+			AbortOrExit(self);
+			if (nextState < State.Exiting)
+				base.Cancel(self);
+			else
+				NextActivity = null;
+		}
+
+		ReserveStatus TryReserveElseTryAlternateReserve(Actor self)
+		{
+			for (var tries = 0;;) 
+				switch (Reserve(self))
+				{
+					case ReserveStatus.None:
+						if (++tries > maxTries || !TryGetAlternateTarget(self, tries, ref target))
+							return ReserveStatus.None;
+						continue;
+					case ReserveStatus.TooFar:
+						// Always goto to transport on first approach
+						if (firstApproach)
+						{
+							firstApproach = false;
+							return ReserveStatus.TooFar;
+						}
+
+						if (++tries > maxTries)
+							return ReserveStatus.TooFar;
+						Target t = target;
+						if (!TryGetAlternateTarget(self, tries, ref t))
+							return ReserveStatus.TooFar;
+						if ((target.CenterPosition - self.CenterPosition).HorizontalLengthSquared <= (t.CenterPosition - self.CenterPosition).HorizontalLengthSquared)
+							return ReserveStatus.TooFar;
+						target = t;
+						continue;
+					case ReserveStatus.Pending:
+						return ReserveStatus.Pending;
+					case ReserveStatus.Ready:
+						return ReserveStatus.Ready;
+				}
+		}
+
+		State FindAndTransitionToNextState(Actor self)
+		{
+			switch (nextState)
+			{
+				case State.ApproachingOrEntering:
+
+					// Reserve to enter or approach
+					isEnteringOrInside = false;
+					switch (TryReserveElseTryAlternateReserve(self))
+					{
+						case ReserveStatus.None:
+							return State.Done; // No available target -> abort to next activity
+						case ReserveStatus.TooFar:
+							inner = move.MoveToTarget(self, targetCenter ? Target.FromPos(target.CenterPosition) : target); // Approach
+							return State.ApproachingOrEntering;
+						case ReserveStatus.Pending:
+							return State.ApproachingOrEntering; // Retry next tick
+						case ReserveStatus.Ready:
+							break; // Reserved target -> start entering target
+					}
+
+					// Entering
+					isEnteringOrInside = true;
+					savedPos = self.CenterPosition; // Save position of self, before entering, for returning on exit
+
+					inner = move.MoveIntoTarget(self, target); // Enter
+
+					if (inner != null)
+					{
+						nextState = State.Inside; // Should be inside once inner activity is null
+						return State.ApproachingOrEntering;
+					}
+
+					// Can enter but there is no activity for it, so go inside without one
+					goto case State.Inside;
+
+				case State.Inside:
+					// Might as well teleport into target if there is no MoveIntoTarget activity
+					if (nextState == State.ApproachingOrEntering)
+						nextState = State.Inside;
+
+					// Otherwise, try to recover from moving target
+					else if (target.CenterPosition != self.CenterPosition)
+					{
+						nextState = State.ApproachingOrEntering;
+						Unreserve(self, false);
+						if (Reserve(self) == ReserveStatus.Ready)
+						{
+							inner = move.MoveIntoTarget(self, target); // Enter
+							if (inner != null)
+								return State.ApproachingOrEntering;
+
+							nextState = State.ApproachingOrEntering;
+							goto case State.ApproachingOrEntering;
+						}
+
+						nextState = State.ApproachingOrEntering;
+						isEnteringOrInside = false;
+						inner = move.MoveIntoWorld(self, self.World.Map.CellContaining(savedPos));
+
+						return State.ApproachingOrEntering;
+					}
+
+					OnInside(self);
+
+					// Return if Abort(Actor) or Done(self) was called from OnInside.
+					if (nextState >= State.Exiting)
+						return State.Inside;
+
+					inner = this; // Start inside activity
+					nextState = State.Exiting; // Exit once inner activity is null (unless Done(self) is called)
+					return State.Inside;
+
+				// TODO: Handle target moved while inside or always call done for movable targets and use a separate exit activity
+				case State.Exiting:
+					inner = move.MoveIntoWorld(self, self.World.Map.CellContaining(savedPos));
+
+					// If not successfully exiting, retry on next tick
+					if (inner == null)
+						return State.Exiting;
+					isEnteringOrInside = false;
+					nextState = State.Done;
+					return State.Exiting;
+
+				case State.Done:
+					return State.Done;
+			}
+
+			return State.Done; // dummy to quiet dumb compiler
+		}
+
+		Activity CanceledTick(Actor self)
+		{
+			if (inner == null)
+				return Util.RunActivity(self, NextActivity);
+			inner.Cancel(self);
+			inner.Queue(NextActivity);
+			return Util.RunActivity(self, inner);
+		}
+
+		public override Activity Tick(Actor self)
+		{
+			if (IsCanceled)
+				return CanceledTick(self);
+
+			// Check target validity if not exiting or done
+			if (nextState != State.Done && (target.Type != TargetType.Actor || !target.IsValidFor(self)))
+					AbortOrExit(self);
+
+			// If no current activity, tick next activity
+			if (inner == null && FindAndTransitionToNextState(self) == State.Done)
+				return CanceledTick(self);
+
+			// Run inner activity/InsideTick
+			inner = inner == this ? InsideTick(self) : Util.RunActivity(self, inner);
+			return this;
+		}
+	}
+}

OpenRA.Mods.Common/Activities/RepairBuilding.cs

@@ -0,0 +1,40 @@
+#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 OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Activities
+{
+	class RepairBuilding : Enter
+	{
+		readonly Actor target;
+		readonly Health health;
+
+		public RepairBuilding(Actor self, Actor target)
+			: base(self, target)
+		{
+			this.target = target;
+			health = target.Trait<Health>();
+		}
+
+		protected override bool CanReserve(Actor self)
+		{
+			return health.DamageState != DamageState.Undamaged;
+		}
+
+		protected override void OnInside(Actor self)
+		{
+			if (health.DamageState == DamageState.Undamaged)
+				return;
+			target.InflictDamage(self, -health.MaxHP, null);
+			self.Destroy();
+		}
+	}
+}

OpenRA.Mods.Common/ActorExts.cs

@@ -0,0 +1,81 @@
+#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.Drawing;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common
+{
+	public static class ActorExts
+	{
+		public static bool AppearsFriendlyTo(this Actor self, Actor toActor)
+		{
+			var stance = toActor.Owner.Stances[self.Owner];
+			if (stance == Stance.Ally)
+				return true;
+
+			if (self.EffectiveOwner != null && self.EffectiveOwner.Disguised && !toActor.HasTrait<IgnoresDisguise>())
+				return toActor.Owner.Stances[self.EffectiveOwner.Owner] == Stance.Ally;
+
+			return stance == Stance.Ally;
+		}
+
+		public static bool AppearsHostileTo(this Actor self, Actor toActor)
+		{
+			var stance = toActor.Owner.Stances[self.Owner];
+			if (stance == Stance.Ally)
+				return false;		/* otherwise, we'll hate friendly disguised spies */
+
+			if (self.EffectiveOwner != null && self.EffectiveOwner.Disguised && !toActor.HasTrait<IgnoresDisguise>())
+				return toActor.Owner.Stances[self.EffectiveOwner.Owner] == Stance.Enemy;
+
+			return stance == Stance.Enemy;
+		}
+
+		public static Target ResolveFrozenActorOrder(this Actor self, Order order, Color targetLine)
+		{
+			// Not targeting a frozen actor
+			if (order.ExtraData == 0)
+				return Target.FromOrder(self.World, order);
+
+			// Targeted an actor under the fog
+			var frozenLayer = self.Owner.PlayerActor.TraitOrDefault<FrozenActorLayer>();
+			if (frozenLayer == null)
+				return Target.Invalid;
+
+			var frozen = frozenLayer.FromID(order.ExtraData);
+			if (frozen == null)
+				return Target.Invalid;
+
+			// Flashes the frozen proxy
+			self.SetTargetLine(frozen, targetLine, true);
+
+			// Target is still alive - resolve the real order
+			if (frozen.Actor != null && frozen.Actor.IsInWorld)
+				return Target.FromActor(frozen.Actor);
+
+			if (!order.Queued)
+				self.CancelActivity();
+
+			var move = self.TraitOrDefault<IMove>();
+			if (move != null)
+			{
+				// Move within sight range of the frozen actor
+				var sight = self.TraitOrDefault<RevealsShroud>();
+				var range = sight != null ? sight.Range : WRange.FromCells(2);
+
+				self.QueueActivity(move.MoveWithinRange(Target.FromPos(frozen.CenterPosition), range));
+			}
+
+			return Target.Invalid;
+		}
+	}
+}

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

@@ -56,11 +56,14 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Activities\Enter.cs" />
     <Compile Include="Activities\Move\Drag.cs" />
     <Compile Include="Activities\RemoveSelf.cs" />
+    <Compile Include="Activities\RepairBuilding.cs" />
     <Compile Include="Activities\SimpleTeleport.cs" />
     <Compile Include="Activities\Turn.cs" />
     <Compile Include="Activities\Wait.cs" />
+    <Compile Include="ActorExts.cs" />
     <Compile Include="Effects\Beacon.cs" />
     <Compile Include="Effects\Bullet.cs" />
     <Compile Include="Effects\Contrail.cs" />
@@ -135,7 +138,9 @@
     <Compile Include="Traits\Buildings\RepairsUnits.cs" />
     <Compile Include="Traits\Buildings\FootprintUtils.cs" />
     <Compile Include="Traits\Burns.cs" />
+    <Compile Include="Traits\IgnoresDisguise.cs" />
     <Compile Include="Traits\DetectCloaked.cs" />
+    <Compile Include="Traits\EngineerRepair.cs" />
     <Compile Include="Traits\GainsExperience.cs" />
     <Compile Include="Traits\GivesBounty.cs" />
     <Compile Include="Traits\GivesExperience.cs" />

OpenRA.Mods.Common/Traits/EngineerRepair.cs

@@ -0,0 +1,124 @@
+#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.Drawing;
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Mods.Common.Orders;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Can instantly repair other actors, but gets consumed afterwards.")]
+	class EngineerRepairInfo : TraitInfo<EngineerRepair> { }
+
+	class EngineerRepair : IIssueOrder, IResolveOrder, IOrderVoice
+	{
+		public IEnumerable<IOrderTargeter> Orders
+		{
+			get { yield return new EngineerRepairOrderTargeter(); }
+		}
+
+		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
+		{
+			if (order.OrderID != "EngineerRepair")
+				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 };
+		}
+
+		static bool IsValidOrder(Actor self, Order order)
+		{
+			// Not targeting a frozen 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;
+
+				return frozen.DamageState > DamageState.Undamaged;
+			}
+
+			return order.TargetActor.GetDamageState() > DamageState.Undamaged;
+		}
+
+		public string VoicePhraseForOrder(Actor self, Order order)
+		{
+			return order.OrderString == "EngineerRepair" && IsValidOrder(self, order)
+				? "Attack" : null;
+		}
+
+		public void ResolveOrder(Actor self, Order order)
+		{
+			if (order.OrderString != "EngineerRepair" || !IsValidOrder(self, order))
+				return;
+
+			var target = self.ResolveFrozenActorOrder(order, Color.Yellow);
+			if (target.Type != TargetType.Actor)
+				return;
+
+			if (!order.Queued)
+				self.CancelActivity();
+
+			self.SetTargetLine(target, Color.Yellow);
+			self.QueueActivity(new RepairBuilding(self, target.Actor));
+		}
+
+		class EngineerRepairOrderTargeter : UnitOrderTargeter
+		{
+			public EngineerRepairOrderTargeter()
+				: base("EngineerRepair", 6, "goldwrench", false, true) { }
+
+			public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
+			{
+				if (!target.HasTrait<EngineerRepairable>())
+					return false;
+
+				if (self.Owner.Stances[target.Owner] != Stance.Ally)
+					return false;
+
+				if (target.GetDamageState() == DamageState.Undamaged)
+					cursor = "goldwrench-blocked";
+
+				return true;
+			}
+
+			public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
+			{
+				if (!target.Info.Traits.Contains<EngineerRepairable>())
+					return false;
+
+				if (self.Owner.Stances[target.Owner] != Stance.Ally)
+					return false;
+
+				if (target.DamageState == DamageState.Undamaged)
+					cursor = "goldwrench-blocked";
+
+				return true;
+			}
+		}
+	}
+
+	[Desc("Eligible for instant repair.")]
+	class EngineerRepairableInfo : TraitInfo<EngineerRepairable> { }
+
+	class EngineerRepairable { }
+}

OpenRA.Mods.Common/Traits/IgnoresDisguise.cs

@@ -0,0 +1,19 @@
+#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 OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+    [Desc("Allows automatic targeting of disguised actors.")]
+    class IgnoresDisguiseInfo : TraitInfo<IgnoresDisguise> { }
+
+    class IgnoresDisguise { }
+}