Merge remote-tracking branch 'darkademic/dev'

Author: Inq8

OpenRA.Mods.CA/Activities/SpawnActor.cs

@@ -21,10 +21,10 @@ namespace OpenRA.Mods.CA.Activities
 {
 	public class SpawnActor : Activity
 	{
-		readonly WPos targetPos;
 		readonly CPos targetCell;
+		readonly WAngle? initFacing;
 		readonly bool skipMakeAnims;
-		readonly string type;
+		readonly string[]types;
 		readonly string[] spawnSounds;
 		readonly AmmoPool ammoPool;
 		readonly int range;
@@ -34,14 +34,14 @@ public class SpawnActor : Activity
 		readonly HashSet<string> allowedTerrainTypes;
 		readonly Action<Actor, Actor> onActorSpawned;
 
-		public SpawnActor(Actor self, CPos targetCell, WPos targetPos, string type, bool skipMakeAnims, string[] spawnSounds,
+		public SpawnActor(string[] types, CPos targetCell, WAngle? initFacing, bool skipMakeAnims, string[] spawnSounds,
 			AmmoPool ammoPool, int range, bool avoidActors, WDist maxRange, bool spawnInShroud, HashSet<string> allowedTerrainTypes,
 			Action<Actor, Actor> onActorSpawned = null)
 		{
-			this.targetPos = targetPos;
 			this.targetCell = targetCell;
+			this.initFacing = initFacing;
 			this.skipMakeAnims = skipMakeAnims;
-			this.type = type;
+			this.types = types;
 			this.spawnSounds = spawnSounds;
 			this.ammoPool = ammoPool;
 			this.range = range;
@@ -50,6 +50,8 @@ public SpawnActor(Actor self, CPos targetCell, WPos targetPos, string type, bool
 			this.spawnInShroud = spawnInShroud;
 			this.allowedTerrainTypes = allowedTerrainTypes;
 			this.onActorSpawned = onActorSpawned;
+
+			IsInterruptible = false;
 		}
 
 		public override bool Tick(Actor self)
@@ -66,94 +68,102 @@ void Spawn(Actor self)
 			var map = self.World.Map;
 			var targetCells = map.FindTilesInCircle(targetCell, range);
 			var cell = targetCells.GetEnumerator();
-			var ai = map.Rules.Actors[type.ToLowerInvariant()];
-			var td = CreateTypeDictionary(self, targetCell);
-			var placed = false;
+			var soundPlayed = false;
 
-			self.World.AddFrameEndTask(w =>
+			foreach (var type in types)
 			{
-				var unit = self.World.CreateActor(false, type, td);
-				var positionable = unit.TraitOrDefault<IPositionable>();
-
-				cell = targetCells.GetEnumerator();
+				var actorType = type.ToLowerInvariant();
+				var ai = map.Rules.Actors[actorType];
+				var td = CreateTypeDictionary(self, targetCell);
+				var placed = false;
 
-				if (positionable == null)
+				self.World.AddFrameEndTask(w =>
 				{
-					unit.Dispose();
+					Actor unit = null;
+					cell = targetCells.GetEnumerator();
 
-					if (avoidActors)
+					if (!ai.HasTraitInfo<IPositionableInfo>())
 					{
-						while (cell.MoveNext() && !placed)
+						if (avoidActors)
 						{
-							if (!IsValidTargetCell(cell.Current, self))
-								continue;
+							while (cell.MoveNext() && !placed)
+							{
+								if (!IsValidTargetCell(cell.Current, self))
+									continue;
 
-							var actorsInCell = self.World.ActorMap.GetActorsAt(cell.Current);
+								var actorsInCell = self.World.ActorMap.GetActorsAt(cell.Current);
 
-							if (actorsInCell.Any())
-								continue;
+								if (actorsInCell.Any())
+									continue;
 
-							placed = true;
-							td = CreateTypeDictionary(self, cell.Current);
+								placed = true;
+								td = CreateTypeDictionary(self, cell.Current);
+							}
 						}
+						else
+							placed = true;
+
+						if (placed)
+							unit = self.World.CreateActor(type, td);
 					}
 					else
-						placed = true;
-
-					if (placed)
-						unit = self.World.CreateActor(type, td);
-				}
-				else
-				{
-					while (cell.MoveNext() && !placed)
 					{
-						var subCell = positionable.GetAvailableSubCell(cell.Current);
+						unit = self.World.CreateActor(false, actorType, td);
+						var positionable = unit.TraitOrDefault<IPositionable>();
+
+						while (cell.MoveNext() && !placed)
+						{
+							var subCell = positionable.GetAvailableSubCell(cell.Current);
 
-						if (ai.HasTraitInfo<AircraftInfo>()
-							&& ai.TraitInfo<AircraftInfo>().CanEnterCell(self.World, unit, cell.Current, SubCell.FullCell, null, BlockedByActor.None))
-							subCell = SubCell.FullCell;
+							if (ai.HasTraitInfo<AircraftInfo>()
+								&& ai.TraitInfo<AircraftInfo>().CanEnterCell(self.World, unit, cell.Current, SubCell.FullCell, null, BlockedByActor.None))
+								subCell = SubCell.FullCell;
 
-						if (!IsValidTargetCell(cell.Current, self))
-							continue;
+							if (!IsValidTargetCell(cell.Current, self))
+								continue;
 
-						if (subCell != SubCell.Invalid)
-						{
-							positionable.SetPosition(unit, cell.Current, subCell);
+							if (subCell != SubCell.Invalid)
+							{
+								positionable.SetPosition(unit, cell.Current, subCell);
 
-							var pos = unit.CenterPosition;
+								var pos = unit.CenterPosition;
 
-							positionable.SetCenterPosition(unit, pos);
-							w.Add(unit);
+								positionable.SetCenterPosition(unit, pos);
+								w.Add(unit);
 
-							unit.QueueActivity(new FallDown(unit, pos, 130));
+								unit.QueueActivity(new FallDown(unit, pos, 130));
 
-							placed = true;
+								placed = true;
+							}
 						}
-					}
 
-					if (!placed)
-						unit.Dispose();
-				}
+						if (!placed)
+							unit.Dispose();
+					}
 
-				if (placed)
-				{
-					if (ammoPool != null)
-						ammoPool.TakeAmmo(self, 1);
+					if (placed && unit != null)
+					{
+						if (ammoPool != null)
+							ammoPool.TakeAmmo(self, 1);
 
-					if (spawnSounds.Length > 0)
-						Game.Sound.Play(SoundType.World, spawnSounds, self.World, unit.CenterPosition);
+						if (!soundPlayed && spawnSounds.Length > 0)
+						{
+							Game.Sound.Play(SoundType.World, spawnSounds, self.World, unit.CenterPosition);
+							soundPlayed = true;
+						}
 
-					onActorSpawned?.Invoke(self, unit);
-				}
-			});
+						onActorSpawned?.Invoke(self, unit);
+					}
+				});
+			}
 		}
 
 		bool IsValidTargetCell(CPos cell, Actor self)
 		{
 			var targetPos = self.World.Map.CenterOfCell(cell);
 			var sourcePos = self.CenterPosition;
 
-			return ((targetPos - sourcePos).Length <= maxRange.Length
+			return ((maxRange == WDist.Zero || (targetPos - sourcePos).Length <= maxRange.Length)
 				&& (spawnInShroud || self.Owner.Shroud.IsExplored(cell))
 				&& (allowedTerrainTypes.Count == 0 || allowedTerrainTypes.Contains(self.World.Map.GetTerrainInfo(cell).Type)));
 		}
@@ -167,6 +177,9 @@ TypeDictionary CreateTypeDictionary(Actor self, CPos targetCell)
 				new LocationInit(targetCell)
 			};
 
+			if (initFacing.HasValue)
+				td.Add(new FacingInit(initFacing.Value));
+
 			if (skipMakeAnims)
 				td.Add(new SkipMakeAnimsInit());
 

OpenRA.Mods.CA/Traits/Attack/AttackFrontalCharged.cs

@@ -45,6 +45,9 @@ public class AttackFrontalChargedInfo : AttackFrontalInfo, Requires<IFacingInfo>
 		[Desc("Armaments that count towards shots per charge. Leave empty for all.")]
 		public readonly string[] ChargeConsumingArmaments = default;
 
+		[Desc("If true, charge will be lost while turning.")]
+		public readonly bool LosesChargeWhileTurning = false;
+
 		public readonly bool ShowSelectionBar = false;
 		public readonly Color SelectionBarColor = Color.FromArgb(128, 200, 255);
 
@@ -118,6 +121,9 @@ protected override void Tick(Actor self)
 			if (IsTraitDisabled || IsTraitPaused)
 				return;
 
+			if (!IsAiming && ChargeLevel == 0)
+				return;
+
 			var reloading = false;
 			foreach (var armament in Armaments)
 			{
@@ -129,7 +135,13 @@ protected override void Tick(Actor self)
 			}
 
 			// Stop charging when we lose our target
-			charging = (self.CurrentActivity is AttackCharged || self.CurrentActivity is AttackMoveActivity) && !reloading && IsAiming && (ChargeLevel > 0 || !IsTurning);
+			bool isTurning = IsTurning;
+
+			charging =
+				(self.CurrentActivity is AttackCharged || self.CurrentActivity is AttackMoveActivity)
+				&& !reloading
+				&& IsAiming
+				&& (!isTurning || (isTurning && ChargeLevel > 0 && !Info.LosesChargeWhileTurning));
 
 			var delta = charging ? Info.ChargeRate : -Info.DischargeRate;
 			ChargeLevel = (ChargeLevel + delta).Clamp(0, requiredChargeLevel);

OpenRA.Mods.CA/Traits/BotModules/SquadManagerBotModuleCA.cs

@@ -98,7 +98,7 @@ public class SquadManagerBotModuleCAInfo : ConditionalTraitInfo
 		public readonly int AirToAirPriority = 85;
 
 		[Desc("Limit target types for specific air unit squads.")]
-		public readonly Dictionary<string, BitSet<TargetableType>> AirSquadTargetTypes = null;
+		public readonly Dictionary<string, BitSet<TargetableType>> AirSquadTargetArmorTypes = null;
 
 		[Desc("Enemy building types around which to scan for targets for naval squads.")]
 		public readonly HashSet<string> StaticAntiAirTypes = new HashSet<string>();
@@ -196,18 +196,16 @@ public bool IsHighValueTarget(Actor a)
 			return IsValidEnemyUnit(a) && Info.HighValueTargetTypes.Contains(a.Info.Name);
 		}
 
-		public bool IsAirSquadTargetType(Actor a, SquadCA owner)
+		public bool IsAirSquadTargetArmorType(Actor a, SquadCA owner)
 		{
 			if (a == null || a.IsDead)
 				return false;
 
 			var airSquadUnitType = owner.Units.First().Info.Name;
-			if (owner.SquadManager.Info.AirSquadTargetTypes.ContainsKey(airSquadUnitType))
+			if (owner.SquadManager.Info.AirSquadTargetArmorTypes.ContainsKey(airSquadUnitType))
 			{
-				var targetTypes = a.GetEnabledTargetTypes();
-
-				if (targetTypes.IsEmpty || !targetTypes.Overlaps(owner.SquadManager.Info.AirSquadTargetTypes[airSquadUnitType]))
-					return false;
+				var desiredArmorTypes = owner.SquadManager.Info.AirSquadTargetArmorTypes[airSquadUnitType];
+				return a.Info.TraitInfos<ArmorInfo>().Any(ai => desiredArmorTypes.Contains(ai.Type.ToString()));
 			}
 
 			return true;

OpenRA.Mods.CA/Traits/BotModules/Squads/States/AirStatesCA.cs

@@ -138,7 +138,7 @@ protected static bool NearToPosSafely(SquadCA owner, WPos loc, out Actor detecte
 			if (!unitsAroundPos.Any())
 				return true;
 
-			var possibleTargets = unitsAroundPos.Where(a => owner.SquadManager.IsAirSquadTargetType(a, owner)).ToList();
+			var possibleTargets = unitsAroundPos.Where(a => owner.SquadManager.IsAirSquadTargetArmorType(a, owner)).ToList();
 			var possibleAntiAir = unitsAroundPos.ToList();
 
 			if (CountStaticAntiAir(possibleAntiAir, owner) < owner.Units.Count)
@@ -204,8 +204,8 @@ public void Tick(SquadCA owner)
 				{
 					var a = owner.Units.Random(owner.Random);
 
-					// copied from FindClosestEnemy() so that non-air squads don't check IsAirSquadTargetType unnecessarily
-					var units = a.World.Actors.Where(t => owner.SquadManager.IsPreferredEnemyUnit(t) && owner.SquadManager.IsAirSquadTargetType(t, owner));
+					// copied from FindClosestEnemy() so that non-air squads don't check IsAirSquadTargetArmorType unnecessarily
+					var units = a.World.Actors.Where(t => owner.SquadManager.IsPreferredEnemyUnit(t) && owner.SquadManager.IsAirSquadTargetArmorType(t, owner));
 					closestEnemy = units.Where(owner.SquadManager.IsNotHiddenUnit).ClosestTo(a.CenterPosition) ?? units.ClosestTo(a.CenterPosition);
 				}
 

OpenRA.Mods.CA/Traits/FreeActorCA.cs

@@ -0,0 +1,95 @@
+#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 System.Collections.Generic;
+using OpenRA.Mods.Common;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Primitives;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.CA.Traits
+{
+	[Desc("Player receives a unit for free once the building is placed. This also works for structures.",
+		"If you want more than one unit to appear copy this section and assign IDs like FreeActor@2, ...")]
+	public class FreeActorCAInfo : ConditionalTraitInfo, IEditorActorOptions
+	{
+		[ActorReference]
+		[FieldLoader.Require]
+		[Desc("Name of the actor.")]
+		public readonly string Actor = null;
+
+		[Desc("Offset relative to the top-left cell of the building.")]
+		public readonly CVec SpawnOffset = CVec.Zero;
+
+		[Desc("Which direction the unit should face.")]
+		public readonly WAngle Facing = WAngle.Zero;
+
+		[Desc("Whether another actor should spawn upon re-enabling the trait.")]
+		public readonly bool AllowRespawn = false;
+
+		[Desc("Display order for the free actor checkbox in the map editor")]
+		public readonly int EditorFreeActorDisplayOrder = 4;
+
+		IEnumerable<EditorActorOption> IEditorActorOptions.ActorOptions(ActorInfo ai, World world)
+		{
+			yield return new EditorActorCheckbox("Spawn Child Actor", EditorFreeActorDisplayOrder,
+				actor =>
+				{
+					var init = actor.GetInitOrDefault<FreeActorInit>(this);
+					if (init != null)
+						return init.Value;
+
+					return true;
+				},
+				(actor, value) => actor.ReplaceInit(new FreeActorInit(this, value), this));
+		}
+
+		public override object Create(ActorInitializer init) { return new FreeActorCA(init, this); }
+	}
+
+	public class FreeActorCA : ConditionalTrait<FreeActorCAInfo>
+	{
+		protected bool allowSpawn;
+
+		public FreeActorCA(ActorInitializer init, FreeActorCAInfo info)
+			: base(info)
+		{
+			allowSpawn = init.GetValue<FreeActorInit, bool>(info, true);
+		}
+
+		protected override void TraitEnabled(Actor self)
+		{
+			if (!allowSpawn)
+				return;
+
+			allowSpawn = Info.AllowRespawn;
+
+			self.World.AddFrameEndTask(w =>
+			{
+				var td = new TypeDictionary
+				{
+					new ParentActorInit(self),
+					new OwnerInit(self.Owner),
+				};
+
+				var ai = w.Map.Rules.Actors[Info.Actor];
+
+				if (self.Info.HasTraitInfo<IOccupySpaceInfo>() && ai.HasTraitInfo<IOccupySpaceInfo>())
+					td.Add(new LocationInit(self.Location + Info.SpawnOffset));
+
+				if (self.Info.HasTraitInfo<IFacingInfo>() && ai.HasTraitInfo<IFacingInfo>())
+					td.Add(new FacingInit(Info.Facing));
+
+				w.CreateActor(Info.Actor, td);
+			});
+		}
+	}
+}