Moves Attack, Armament, Move, Air traits and activities as well as anything required by them to Mods.Common.

Extracts Exit from Production into its own trait.

OpenRA.Mods.Common/Traits/Attack/AttackBase.cs

@@ -0,0 +1,271 @@
+#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.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using OpenRA.Activities;
+using OpenRA.GameRules;
+using OpenRA.Mods.Common;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	public abstract class AttackBaseInfo : ITraitInfo
+	{
+		[Desc("Armament names")]
+		public readonly string[] Armaments = { "primary", "secondary" };
+
+		public readonly string Cursor = "attack";
+		public readonly string OutsideRangeCursor = "attackoutsiderange";
+
+		[Desc("Does the attack type require the attacker to enter the target's cell?")]
+		public readonly bool AttackRequiresEnteringCell = false;
+
+		public abstract object Create(ActorInitializer init);
+	}
+
+	public abstract class AttackBase : IIssueOrder, IResolveOrder, IOrderVoice, ISync
+	{
+		[Sync] public bool IsAttacking { get; internal set; }
+		public IEnumerable<Armament> Armaments { get { return getArmaments(); } }
+		public readonly AttackBaseInfo Info;
+
+		protected Lazy<IFacing> facing;
+		protected Lazy<Building> building;
+		protected Lazy<IPositionable> positionable;
+		protected Func<IEnumerable<Armament>> getArmaments;
+
+		readonly Actor self;
+
+		public AttackBase(Actor self, AttackBaseInfo info)
+		{
+			this.self = self;
+			Info = info;
+
+			var armaments = Exts.Lazy(() => self.TraitsImplementing<Armament>()
+				.Where(a => info.Armaments.Contains(a.Info.Name)));
+
+			getArmaments = () => armaments.Value;
+
+			facing = Exts.Lazy(() => self.TraitOrDefault<IFacing>());
+			building = Exts.Lazy(() => self.TraitOrDefault<Building>());
+			positionable = Exts.Lazy(() => self.Trait<IPositionable>());
+		}
+
+		protected virtual bool CanAttack(Actor self, Target target)
+		{
+			if (!self.IsInWorld)
+				return false;
+
+			if (!HasAnyValidWeapons(target))
+				return false;
+
+			// Building is under construction or is being sold
+			if (building.Value != null && !building.Value.BuildComplete)
+				return false;
+
+			if (!target.IsValidFor(self))
+				return false;
+
+			if (Armaments.All(a => a.IsReloading))
+				return false;
+
+			if (self.IsDisabled())
+				return false;
+
+			return true;
+		}
+
+		public virtual void DoAttack(Actor self, Target target)
+		{
+			if (!CanAttack(self, target))
+				return;
+
+			foreach (var a in Armaments)
+				a.CheckFire(self, facing.Value, target);
+		}
+
+		public IEnumerable<IOrderTargeter> Orders
+		{
+			get
+			{
+				var armament = Armaments.FirstOrDefault(a => a.Weapon.Warheads.Any(w => (w is DamageWarhead)));
+				if (armament == null)
+					yield break;
+
+				var negativeDamage = (armament.Weapon.Warheads.FirstOrDefault(w => (w is DamageWarhead)) as DamageWarhead).Damage < 0;
+				yield return new AttackOrderTargeter(this, "Attack", 6, negativeDamage);
+			}
+		}
+
+		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
+		{
+			if (order is AttackOrderTargeter)
+			{
+				switch (target.Type)
+				{
+				case TargetType.Actor:
+					return new Order("Attack", self, queued) { TargetActor = target.Actor };
+				case TargetType.FrozenActor:
+					return new Order("Attack", self, queued) { ExtraData = target.FrozenActor.ID };
+				case TargetType.Terrain:
+					return new Order("Attack", self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) };
+				}
+			}
+
+			return null;
+		}
+
+		public virtual void ResolveOrder(Actor self, Order order)
+		{
+			if (order.OrderString == "Attack")
+			{
+				var target = self.ResolveFrozenActorOrder(order, Color.Red);
+				if (!target.IsValidFor(self))
+					return;
+
+				self.SetTargetLine(target, Color.Red);
+				AttackTarget(target, order.Queued, true);
+			}
+		}
+
+		public string VoicePhraseForOrder(Actor self, Order order)
+		{
+			return order.OrderString == "Attack" ? "Attack" : null;
+		}
+
+		public abstract Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove);
+
+		public bool HasAnyValidWeapons(Target t)
+		{
+			if (Info.AttackRequiresEnteringCell && !positionable.Value.CanEnterCell(t.Actor.Location, null, false))
+				return false;
+
+			return Armaments.Any(a => a.Weapon.IsValidAgainst(t, self.World, self));
+		}
+
+		public WRange GetMaximumRange()
+		{
+			return Armaments.Select(a => a.Weapon.Range).Append(WRange.Zero).Max();
+		}
+
+		public Armament ChooseArmamentForTarget(Target t) { return Armaments.FirstOrDefault(a => a.Weapon.IsValidAgainst(t, self.World, self)); }
+
+		public void AttackTarget(Target target, bool queued, bool allowMove)
+		{
+			if (!target.IsValidFor(self))
+				return;
+
+			if (!queued)
+				self.CancelActivity();
+
+			self.QueueActivity(GetAttackActivity(self, target, allowMove));
+		}
+
+		public bool IsReachableTarget(Target target, bool allowMove)
+		{
+			return HasAnyValidWeapons(target)
+				&& (target.IsInRange(self.CenterPosition, GetMaximumRange()) || (allowMove && self.HasTrait<IMove>()));
+		}
+
+		class AttackOrderTargeter : IOrderTargeter
+		{
+			readonly bool negativeDamage;
+			readonly AttackBase ab;
+
+			public AttackOrderTargeter(AttackBase ab, string order, int priority, bool negativeDamage)
+			{
+				this.ab = ab;
+				this.OrderID = order;
+				this.OrderPriority = priority;
+				this.negativeDamage = negativeDamage;
+			}
+
+			public string OrderID { get; private set; }
+			public int OrderPriority { get; private set; }
+
+			bool CanTargetActor(Actor self, Target target, TargetModifiers modifiers, ref string cursor)
+			{
+				IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
+
+				var a = ab.ChooseArmamentForTarget(target);
+				cursor = a != null && !target.IsInRange(self.CenterPosition, a.Weapon.Range)
+					? ab.Info.OutsideRangeCursor
+					: ab.Info.Cursor;
+
+				if (target.Type == TargetType.Actor && target.Actor == self)
+					return false;
+
+				if (!ab.HasAnyValidWeapons(target))
+					return false;
+
+				if (modifiers.HasModifier(TargetModifiers.ForceAttack))
+					return true;
+
+				if (modifiers.HasModifier(TargetModifiers.ForceMove))
+					return false;
+
+				if (target.RequiresForceFire)
+					return false;
+
+				var targetableRelationship = negativeDamage ? Stance.Ally : Stance.Enemy;
+
+				var owner = target.Type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
+				return self.Owner.Stances[owner] == targetableRelationship;
+			}
+
+			bool CanTargetLocation(Actor self, CPos location, List<Actor> actorsAtLocation, TargetModifiers modifiers, ref string cursor)
+			{
+				if (!self.World.Map.Contains(location))
+					return false;
+
+				IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
+
+				cursor = ab.Info.Cursor;
+
+				if (negativeDamage)
+					return false;
+
+				if (!ab.HasAnyValidWeapons(Target.FromCell(self.World, location)))
+					return false;
+
+				if (modifiers.HasModifier(TargetModifiers.ForceAttack))
+				{
+					var maxRange = ab.GetMaximumRange().Range;
+					var targetRange = (self.World.Map.CenterOfCell(location) - self.CenterPosition).HorizontalLengthSquared;
+					if (targetRange > maxRange * maxRange)
+						cursor = ab.Info.OutsideRangeCursor;
+
+					return true;
+				}
+
+				return false;
+			}
+
+			public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, TargetModifiers modifiers, ref string cursor)
+			{
+				switch (target.Type)
+				{
+				case TargetType.Actor:
+				case TargetType.FrozenActor:
+					return CanTargetActor(self, target, modifiers, ref cursor);
+				case TargetType.Terrain:
+					return CanTargetLocation(self, self.World.Map.CellContaining(target.CenterPosition), othersAtTarget, modifiers, ref cursor);
+				default:
+					return false;
+				}
+			}
+
+			public bool IsQueued { get; protected set; }
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackCharge.cs

@@ -0,0 +1,132 @@
+#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.Activities;
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Charges up before being able to attack.")]
+	class AttackChargeInfo : AttackOmniInfo
+	{
+		[Desc("How many charges this actor has to attack with, once charged.")]
+		public readonly int MaxCharges = 1;
+
+		[Desc("Reload time for all charges (in ticks).")]
+		public readonly int ReloadTime = 120;
+
+		[Desc("Delay for initial charge attack (in ticks).")]
+		public readonly int InitialChargeDelay = 22;
+
+		[Desc("Delay between charge attacks (in ticks).")]
+		public readonly int ChargeDelay = 3;
+
+		public override object Create(ActorInitializer init) { return new AttackCharge(init.self, this); }
+	}
+
+	class AttackCharge : AttackOmni, ITick, INotifyAttack, ISync
+	{
+		readonly AttackChargeInfo info;
+
+		[Sync] int charges;
+		[Sync] int timeToRecharge;
+
+		public AttackCharge(Actor self, AttackChargeInfo info)
+			: base(self, info)
+		{
+			this.info = info;
+			charges = info.MaxCharges;
+		}
+
+		public void Tick(Actor self)
+		{
+			if (--timeToRecharge <= 0)
+				charges = info.MaxCharges;
+		}
+
+		protected override bool CanAttack(Actor self, Target target)
+		{
+			if (!IsReachableTarget(target, true))
+				return false;
+
+			return base.CanAttack(self, target);
+		}
+
+		public void Attacking(Actor self, Target target, Armament a, Barrel barrel)
+		{
+			--charges;
+			timeToRecharge = info.ReloadTime;
+		}
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove)
+		{
+			return new ChargeAttack(this, newTarget);
+		}
+
+		public override void ResolveOrder(Actor self, Order order)
+		{
+			base.ResolveOrder(self, order);
+
+			if (order.OrderString == "Stop")
+				self.CancelActivity();
+		}
+
+		class ChargeAttack : Activity
+		{
+			readonly AttackCharge attack;
+			readonly Target target;
+
+			public ChargeAttack(AttackCharge attack, Target target) 
+			{ 
+				this.attack = attack;
+				this.target = target; 
+			}
+
+			public override Activity Tick(Actor self)
+			{
+				if (IsCanceled || !attack.CanAttack(self, target))
+					return NextActivity;
+
+				if (attack.charges == 0)
+					return this;
+
+				self.Trait<RenderBuildingCharge>().PlayCharge(self);
+
+				return Util.SequenceActivities(new Wait(attack.info.InitialChargeDelay), new ChargeFire(attack, target), this);
+			}
+		}
+
+		class ChargeFire : Activity
+		{
+			readonly AttackCharge attack;
+			readonly Target target;
+
+			public ChargeFire(AttackCharge attack, Target target) 
+			{ 
+				this.attack = attack;
+				this.target = target; 
+			}
+
+			public override Activity Tick(Actor self)
+			{
+				if (IsCanceled || !attack.CanAttack(self, target))
+					return NextActivity;
+
+				if (attack.charges == 0)
+					return NextActivity;
+
+				attack.DoAttack(self, target);
+
+				return Util.SequenceActivities(new Wait(attack.info.ChargeDelay), this);
+			}
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackFollow.cs

@@ -0,0 +1,104 @@
+#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.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Actor will follow units until in range to attack them.")]
+	public class AttackFollowInfo : AttackBaseInfo
+	{
+		public override object Create(ActorInitializer init) { return new AttackFollow(init.self, this); }
+	}
+
+	public class AttackFollow : AttackBase, ITick, ISync
+	{
+		public Target Target { get; protected set; }
+
+		public AttackFollow(Actor self, AttackFollowInfo info)
+			: base(self, info) { }
+
+		protected override bool CanAttack(Actor self, Target target)
+		{
+			if (!target.IsValidFor(self))
+				return false;
+
+			return base.CanAttack(self, target);
+		}
+
+		public virtual void Tick(Actor self)
+		{
+			DoAttack(self, Target);
+			IsAttacking = Target.IsValidFor(self);
+		}
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove)
+		{
+			return new AttackActivity(self, newTarget, allowMove);
+		}
+
+		public override void ResolveOrder(Actor self, Order order)
+		{
+			base.ResolveOrder(self, order);
+
+			if (order.OrderString == "Stop")
+				Target = Target.Invalid;
+		}
+
+		class AttackActivity : Activity
+		{
+			readonly AttackFollow attack;
+			readonly IMove move;
+			readonly Target target;
+
+			public AttackActivity(Actor self, Target target, bool allowMove)
+			{
+				attack = self.Trait<AttackFollow>();
+				move = allowMove ? self.TraitOrDefault<IMove>() : null;
+
+				// HACK: Mobile.OnRails is horrible
+				var mobile = move as Mobile;
+				if (mobile != null && mobile.Info.OnRails)
+					move = null;
+
+				this.target = target;
+			}
+
+			public override Activity Tick(Actor self)
+			{
+				if (IsCanceled || !target.IsValidFor(self))
+					return NextActivity;
+
+				if (self.IsDisabled())
+					return this;
+
+				var weapon = attack.ChooseArmamentForTarget(target);
+				if (weapon != null)
+				{
+					var targetIsMobile = (target.Type == TargetType.Actor && target.Actor.HasTrait<IMove>())
+						|| (target.Type == TargetType.FrozenActor && target.FrozenActor.Info.Traits.Contains<IMove>());
+
+					// Try and sit at least one cell closer than the max range to give some leeway if the target starts moving.
+					var maxRange = targetIsMobile ? new WRange(Math.Max(weapon.Weapon.MinRange.Range, weapon.Weapon.Range.Range - 1024))
+						: weapon.Weapon.Range;
+
+					attack.Target = target;
+
+					if (move != null)
+						return Util.SequenceActivities(move.MoveFollow(self, target, weapon.Weapon.MinRange, maxRange), this);
+				}
+
+				return NextActivity;
+			}
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackFrontal.cs

@@ -0,0 +1,58 @@
+#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.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Unit got to face the target")]
+	public class AttackFrontalInfo : AttackBaseInfo, Requires<IFacingInfo>
+	{
+		public readonly int FacingTolerance = 1;
+
+		public override object Create(ActorInitializer init) { return new AttackFrontal(init.self, this); }
+	}
+
+	public class AttackFrontal : AttackBase
+	{
+		readonly AttackFrontalInfo info;
+
+		public AttackFrontal(Actor self, AttackFrontalInfo info)
+			: base(self, info)
+		{
+			this.info = info;
+		}
+
+		protected override bool CanAttack(Actor self, Target target)
+		{
+			if (!base.CanAttack(self, target))
+				return false;
+
+			var f = facing.Value.Facing;
+			var facingToTarget = Util.GetFacing(target.CenterPosition - self.CenterPosition, f);
+
+			if (Math.Abs(facingToTarget - f) % 256 > info.FacingTolerance)
+				return false;
+
+			return true;
+		}
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove)
+		{
+			var a = ChooseArmamentForTarget(newTarget);
+			if (a == null)
+				return null;
+
+			return new Activities.Attack(self, newTarget, a.Weapon.MinRange, a.Weapon.Range, allowMove);
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackMedic.cs

@@ -0,0 +1,38 @@
+#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.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Give the unit a \"heal-weapon\" that attacks friendly targets if they are damaged.",
+		"It conflicts with any other weapon or Attack*: trait because it will hurt friendlies during the",
+		"heal process then. It also won't work with buildings (use RepairsUnits: for them)")]
+	public class AttackMedicInfo : AttackFrontalInfo
+	{
+		public override object Create(ActorInitializer init) { return new AttackMedic(init.self, this); }
+	}
+
+	public class AttackMedic : AttackFrontal
+	{
+		public AttackMedic(Actor self, AttackMedicInfo info)
+			: base(self, info) { }
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove)
+		{
+			var a = ChooseArmamentForTarget(newTarget);
+			if (a == null)
+				return null;
+
+			return new Activities.Heal(self, newTarget, a.Weapon.MinRange, a.Weapon.Range, allowMove);
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackOmni.cs

@@ -0,0 +1,52 @@
+#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.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	class AttackOmniInfo : AttackBaseInfo
+	{
+		public override object Create(ActorInitializer init) { return new AttackOmni(init.self, this); }
+	}
+
+	class AttackOmni : AttackBase, ISync
+	{
+		public AttackOmni(Actor self, AttackOmniInfo info)
+			: base(self, info) { }
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove)
+		{
+			return new SetTarget(this, newTarget);
+		}
+
+		class SetTarget : Activity
+		{
+			readonly Target target;
+			readonly AttackOmni attack;
+
+			public SetTarget(AttackOmni attack, Target target)
+			{
+				this.target = target;
+				this.attack = attack;
+			}
+
+			public override Activity Tick(Actor self)
+			{
+				if (IsCanceled || !target.IsValidFor(self))
+					return NextActivity;
+
+				attack.DoAttack(self, target);
+				return this;
+			}
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackTurreted.cs

@@ -0,0 +1,46 @@
+#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 OpenRA.Activities;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Traits
+{
+	[Desc("Actor has a visual turret used to attack.")]
+	public class AttackTurretedInfo : AttackFollowInfo, Requires<TurretedInfo>
+	{
+		public override object Create(ActorInitializer init) { return new AttackTurreted(init.self, this); }
+	}
+
+	public class AttackTurreted : AttackFollow, ITick, ISync
+	{
+		protected IEnumerable<Turreted> turrets;
+
+		public AttackTurreted(Actor self, AttackTurretedInfo info)
+			: base(self, info)
+		{
+			turrets = self.TraitsImplementing<Turreted>();
+		}
+
+		protected override bool CanAttack(Actor self, Target target)
+		{
+			if (!base.CanAttack(self, target))
+				return false;
+
+			var canAttack = false;
+			foreach (var t in turrets)
+				if (t.FaceTarget(self, target))
+					canAttack = true;
+
+			return canAttack;
+		}
+	}
+}

OpenRA.Mods.Common/Traits/Attack/AttackWander.cs

@@ -0,0 +1,37 @@
+#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("Will AttackMove to a random location within MoveRadius when idle.",
+		"This conflicts with player orders and should only be added to animal creeps.")]
+	class AttackWanderInfo : WandersInfo, Requires<AttackMoveInfo>
+	{
+		public override object Create(ActorInitializer init) { return new AttackWander(init.self, this); }
+	}
+
+	class AttackWander : Wanders
+	{
+		readonly AttackMove attackMove;
+
+		public AttackWander(Actor self, AttackWanderInfo info)
+			: base(self, info)
+		{
+			attackMove = self.TraitOrDefault<AttackMove>();
+		}
+
+		public override void DoAction(Actor self, CPos targetPos)
+		{
+			attackMove.ResolveOrder(self, new Order("AttackMove", self, false) { TargetLocation = targetPos });
+		}
+	}
+}