Merge remote-tracking branch 'darkademic/dev'

Author: Inq8

OpenRA.Mods.CA/Activities/MassRideTransport.cs

@@ -0,0 +1,88 @@
+#region Copyright & License Information
+/*
+ * Copyright (c) The OpenRA Developers and Contributors
+ * 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Primitives;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.CA.Activities
+{
+	public class MassRideTransport : Enter
+	{
+		readonly Passenger passenger;
+
+		Actor enterActor;
+		Cargo enterCargo;
+		Aircraft enterAircraft;
+
+		public MassRideTransport(Actor self, in Target target, Color? targetLineColor)
+			: base(self, target, targetLineColor)
+		{
+			passenger = self.Trait<Passenger>();
+		}
+
+		protected override bool TryStartEnter(Actor self, Actor targetActor)
+		{
+			enterActor = targetActor;
+			enterCargo = targetActor.TraitOrDefault<Cargo>();
+			enterAircraft = targetActor.TraitOrDefault<Aircraft>();
+
+			// Make sure we can still enter the transport
+			// (but not before, because this may stop the actor in the middle of nowhere)
+			if (enterCargo == null || !passenger.Reserve(self, enterCargo))
+			{
+				Cancel(self, true);
+				return false;
+			}
+
+			if (enterAircraft != null && !enterAircraft.AtLandAltitude)
+				return false;
+
+			return true;
+		}
+
+		protected override void OnEnterComplete(Actor self, Actor targetActor)
+		{
+			self.World.AddFrameEndTask(w =>
+			{
+				if (self.IsDead)
+					return;
+
+				// Make sure the target hasn't changed while entering
+				// OnEnterComplete is only called if targetActor is alive
+				if (targetActor != enterActor)
+					return;
+
+				if (!enterCargo.CanLoad(self))
+					return;
+
+				foreach (var inl in targetActor.TraitsImplementing<INotifyLoadCargo>())
+					inl.Loading(self);
+
+				enterCargo.Load(enterActor, self);
+				w.Remove(self);
+			});
+		}
+
+		protected override void OnLastRun(Actor self)
+		{
+			passenger.Unreserve(self);
+		}
+
+		public override void Cancel(Actor self, bool keepQueue = false)
+		{
+			passenger.Unreserve(self);
+
+			base.Cancel(self, keepQueue);
+		}
+	}
+}

OpenRA.Mods.CA/Activities/TargetedLeap.cs

@@ -59,17 +59,35 @@ public TargetedLeap(Actor self, CPos targetCell, TargetedLeapAbility ability, Mo
 
 		protected override void OnFirstRun(Actor self)
 		{
+			if (!ability.CanLeap)
+			{
+				canceling = true;
+				return;
+			}
+
 			originPos = self.CenterPosition;
 
 			var cell = ChooseBestDestinationCell(self, targetCell);
 			if (cell.HasValue)
+			{
 				destinationCell = cell.Value;
+			}
 			else
+			{
 				canceling = true;
+				return;
+			}
 
 			var subCell = mobile.GetAvailableSubCell(destinationCell);
 			if (subCell != SubCell.Invalid)
+			{
 				destinationSubCell = subCell;
+			}
+			else
+			{
+				canceling = true;
+				return;
+			}
 
 			destinationPos = self.World.Map.CenterOfSubCell(destinationCell, destinationSubCell);
 			length = Math.Max((originPos - destinationPos).Length / speed, 1);
@@ -145,22 +163,28 @@ public override IEnumerable<Target> GetTargets(Actor self)
 
 		CPos? ChooseBestDestinationCell(Actor self, CPos destination)
 		{
-			var restrictTo = self.World.Map.FindTilesInCircle(self.Location, ability.Info.MaxDistance);
-			destination = restrictTo.MinBy(x => (x - destination).LengthSquared);
-
+			var maxDistance = ability.Info.MaxDistance;
+			var restrictTo = self.World.Map.FindTilesInCircle(self.Location, maxDistance).ToList();
 			var pos = self.Trait<IPositionable>();
-			if (pos.CanEnterCell(destination)
-				&& self.Owner.Shroud.IsExplored(destination))
-				return destination;
 
-			foreach (var tile in self.World.Map.FindTilesInCircle(destination, ability.Info.MaxDistance))
+			// Check if the original destination is within MaxDistance and is valid
+			if ((destination - self.Location).LengthSquared <= maxDistance * maxDistance &&
+				restrictTo.Contains(destination) &&
+				pos.CanEnterCell(destination) &&
+				self.Owner.Shroud.IsExplored(destination))
 			{
-				if (self.Owner.Shroud.IsExplored(tile)
-					&& (restrictTo == null || (restrictTo != null && restrictTo.Contains(tile)))
-					&& pos.CanEnterCell(tile))
-					return tile;
+				return destination;
 			}
 
+			// Find the closest valid cell within MaxDistance
+			var closestValidCell = restrictTo
+				.Where(tile => pos.CanEnterCell(tile) && self.Owner.Shroud.IsExplored(tile))
+				.OrderBy(tile => (tile - destination).LengthSquared)
+				.FirstOrDefault();
+
+			if (closestValidCell != default)
+				return closestValidCell;
+
 			return null;
 		}
 	}

OpenRA.Mods.CA/Orders/MassEnterCargoOrderTargeter.cs

@@ -0,0 +1,51 @@
+#region Copyright & License Information
+/**
+ * Copyright (c) The OpenRA Combined Arms Developers (see CREDITS).
+ * This file is part of OpenRA Combined Arms, 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, either version 3 of the License,
+ * or (at your option) any later version. For more information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Mods.CA.Traits;
+using OpenRA.Mods.Common.Orders;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.CA.Orders
+{
+	class MassEnterCargoOrderTargeter : UnitOrderTargeter
+	{
+		public const string Id = "MassEnterCargo";
+
+		private string cursor;
+
+		public MassEnterCargoOrderTargeter(string cursor)
+			: base(Id, 6, cursor, false, true)
+		{
+			this.cursor = cursor;
+		}
+
+		public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
+		{
+			cursor = null;
+
+			if (!target.Info.HasTraitInfo<UnitConverterInfo>())
+				return false;
+
+			if (target.Trait<UnitConverter>().IsTraitDisabled)
+				return false;
+
+			if (self.Owner != target.Owner)
+				return false;
+
+			cursor = this.cursor;
+			return true;
+		}
+
+		public override bool CanTargetFrozenActor(Actor self, FrozenActor target, TargetModifiers modifiers, ref string cursor)
+		{
+			return false;
+		}
+	}
+}

OpenRA.Mods.CA/Scripting/AirstrikeCAProperties.cs

@@ -0,0 +1,36 @@
+#region Copyright & License Information
+/**
+ * Copyright (c) The OpenRA Combined Arms Developers (see CREDITS).
+ * This file is part of OpenRA Combined Arms, 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, either version 3 of the License,
+ * or (at your option) any later version. For more information, see COPYING.
+ */
+#endregion
+
+using System.Linq;
+using OpenRA.Mods.CA.Traits;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Scripting;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.CA.Scripting
+{
+	[ScriptPropertyGroup("Support Powers")]
+	public class AirstrikeCAProperties : ScriptActorProperties, Requires<AirstrikePowerCAInfo>
+	{
+		readonly AirstrikePowerCA ap;
+
+		public AirstrikeCAProperties(ScriptContext context, Actor self)
+			: base(context, self)
+		{
+			ap = self.TraitsImplementing<AirstrikePowerCA>().First();
+		}
+
+		[Desc("Activate the actor's Airstrike Power. Returns the aircraft that will attack.")]
+		public Actor[] TargetAirstrike(WPos target, WAngle? facing = null)
+		{
+			return ap.SendAirstrike(Self, target, facing);
+		}
+	}
+}

OpenRA.Mods.CA/Scripting/PortableChronoCAGlobal.cs

@@ -0,0 +1,36 @@
+#region Copyright & License Information
+/**
+ * Copyright (c) The OpenRA Combined Arms Developers (see CREDITS).
+ * This file is part of OpenRA Combined Arms, 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, either version 3 of the License,
+ * or (at your option) any later version. For more information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Mods.CA.Traits;
+using OpenRA.Scripting;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.CA.Scripting
+{
+	[ScriptPropertyGroup("PortableChronoCA")]
+	public class PortableChronoCAProperties : ScriptActorProperties, Requires<PortableChronoCAInfo>
+	{
+		readonly PortableChronoCA PortableChrono;
+
+		public PortableChronoCAProperties(ScriptContext context, Actor self)
+			: base(context, self)
+		{
+			PortableChrono = self.Trait<PortableChronoCA>();
+		}
+
+		[ScriptActorPropertyActivity]
+		[Desc("Queue portable chrono teleport.")]
+		public void PortableChronoTeleport(CPos targetCell, bool queued = false)
+		{
+			var target = Target.FromCell(Self.World, targetCell);
+			PortableChrono.ResolveOrder(Self, new Order("PortableChronoTeleport", Self, target, queued));
+		}
+	}
+}

OpenRA.Mods.CA/Scripting/UtilsCAGlobal.cs

@@ -44,5 +44,13 @@ public string FormatTimeForGameSpeed(int ticks)
 		{
 			return WidgetUtils.FormatTime(ticks, world.Timestep);
 		}
+
+		[Desc("Returns hotkey for a specified hotkey name.")]
+		public string Hotkey(string hotkeyName)
+		{
+			var reference = Game.ModData.Hotkeys[hotkeyName];
+			var hotkey = reference.GetValue();
+			return hotkey.DisplayString();
+		}
 	}
 }