add EffectPulsate and fix producing into cargo

Author: patrickwieth

OpenRA.Mods.Common/Traits/AutoTarget.cs

@@ -361,6 +361,9 @@ Target ChooseTarget(Actor self, AttackBase ab, PlayerRelationship attackStances,
 
 			var activePriorities = activeTargetPriorities.ToList();
 			if (activePriorities.Count == 0)
+
+\t\t\tif (self.Owner == null)
+\t\t\t\treturn Target.Invalid;
 				return chosenTarget;
 
 			var targetsInRange = self.World.FindActorsInCircle(self.CenterPosition, scanRange)
@@ -387,6 +390,8 @@ Target ChooseTarget(Actor self, AttackBase ab, PlayerRelationship attackStances,
 					// Check whether we can auto-target this actor
 					targetTypes = target.Actor.GetEnabledTargetTypes();
 
+\t\t\t\tif (target.Actor.Owner == null)
+\t\t\t\t\tcontinue;
 					if (PreventsAutoTarget(self, target.Actor) || !target.Actor.CanBeViewedByPlayer(self.Owner))
 						continue;
 
@@ -475,3 +480,6 @@ public StanceInit(TraitInfo info, UnitStance value)
 			: base(info, value) { }
 	}
 }
+
+
+

OpenRA.Mods.Common/Traits/Player/ClassicProductionQueue.cs

@@ -83,15 +83,10 @@ public override IEnumerable<ActorInfo> BuildableItems()
 
 		public override TraitPair<Production> MostLikelyProducer()
 		{
-			var productionActor = self.World.ActorsWithTrait<Production>()
-				.Where(x => x.Actor.Owner == self.Owner
-					&& !x.Trait.IsTraitDisabled && x.Trait.Info.Produces.Contains(Info.Type))
-				.OrderBy(x => x.Trait.IsTraitPaused)
-				.ThenByDescending(x => x.Actor.IsPrimaryBuilding())
-				.ThenByDescending(x => x.Actor.ActorID)
+			return OrderedProducers()
+				.ThenByDescending(p => p.Actor.IsPrimaryBuilding())
+				.ThenByDescending(p => p.Actor.ActorID)
 				.FirstOrDefault();
-
-			return productionActor;
 		}
 
 		protected override bool BuildUnit(ActorInfo unit)
@@ -102,14 +97,11 @@ protected override bool BuildUnit(ActorInfo unit)
 			// Some units may request a specific production type, which is ignored if the AllTech cheat is enabled
 			var type = developerMode.AllTech ? Info.Type : (bi.BuildAtProductionType ?? Info.Type);
 
-			var producers = self.World.ActorsWithTrait<Production>()
-				.Where(x => x.Actor.Owner == self.Owner
-					&& !x.Trait.IsTraitDisabled
-					&& x.Trait.Info.Produces.Contains(type))
-					.OrderByDescending(x => x.Actor.IsPrimaryBuilding())
-					.ThenByDescending(x => x.Actor.ActorID);
-
 			var anyProducers = false;
+			var producers = OrderedProducers(type)
+				.ThenByDescending(p => p.Actor.IsPrimaryBuilding())
+				.ThenByDescending(p => p.Actor.ActorID);
+
 			foreach (var p in producers)
 			{
 				anyProducers = true;

OpenRA.Mods.Common/Traits/Player/ProductionQueue.cs

@@ -688,24 +688,42 @@ public virtual int RemainingTimeActual(ProductionItem item)
 			return item.RemainingTimeActual;
 		}
 
+		IEnumerable<TraitPair<Production>> EnumerateProducers(string productionType = null)
+		{
+			var type = productionType ?? Info.Type;
+
+			foreach (var local in productionTraits)
+				if (!local.IsTraitDisabled && local.Info.Produces.Contains(type))
+					yield return new TraitPair<Production>(Actor, local);
+
+			foreach (var pair in Actor.Owner.World.ActorsWithTrait<Production>())
+				if (pair.Actor.Owner == Actor.Owner &&
+					!pair.Trait.IsTraitDisabled &&
+					pair.Trait.Info.Produces.Contains(type))
+					yield return pair;
+		}
+
+		protected virtual IOrderedEnumerable<TraitPair<Production>> OrderedProducers(string productionType = null)
+		{
+			return EnumerateProducers(productionType)
+				.OrderByDescending(p => p.Trait.Info.ProduceIntoCargo)
+				.ThenByDescending(p => p.Trait.Info.CargoPriority)
+				.ThenBy(p => p.Trait.IsTraitPaused)
+				.ThenBy(p => p.Actor == Actor ? 0 : 1);
+		}
+
 		// Returns the actor/trait that is most likely (but not necessarily guaranteed) to produce something in this queue
 		public virtual TraitPair<Production> MostLikelyProducer()
 		{
-			var trait = productionTraits
-				.Where(p => !p.IsTraitDisabled && p.Info.Produces.Contains(Info.Type))
-				.OrderBy(p => p.IsTraitPaused)
+			return OrderedProducers()
 				.FirstOrDefault();
-			return new TraitPair<Production>(Actor, trait);
 		}
 
 		// Builds a unit from the actor that holds this queue (1 queue per building)
 		// Returns false if the unit can't be built
 		protected virtual bool BuildUnit(ActorInfo unit)
 		{
-			var mostLikelyProducerTrait = MostLikelyProducer().Trait;
-
-			// Cannot produce if I'm dead or trait is disabled
-			if (!Actor.IsInWorld || Actor.IsDead || mostLikelyProducerTrait == null)
+			if (!Actor.IsInWorld || Actor.IsDead)
 			{
 				CancelProduction(unit.Name, 1);
 				return false;
@@ -720,12 +738,25 @@ protected virtual bool BuildUnit(ActorInfo unit)
 			var bi = BuildableInfo.GetTraitForQueue(unit, Info.Type);
 			var type = developerMode.AllTech ? Info.Type : (bi.BuildAtProductionType ?? Info.Type);
 			var item = Queue.First(i => i.Done && i.Item == unit.Name);
-			if (!mostLikelyProducerTrait.IsTraitPaused && mostLikelyProducerTrait.Produce(Actor, unit, type, inits, item.TotalCost))
+			foreach (var candidate in OrderedProducers(type))
 			{
-				EndProduction(item);
-				return true;
+				var producerActor = candidate.Actor;
+				var producerTrait = candidate.Trait;
+				if (producerActor == null || producerTrait == null)
+					continue;
+				if (producerTrait.IsTraitPaused)
+					continue;
+				if (!producerActor.IsInWorld || producerActor.IsDead)
+					continue;
+
+				if (producerTrait.Produce(producerActor, unit, type, inits, item.TotalCost))
+				{
+					EndProduction(item);
+					return true;
+				}
 			}
 
+			CancelProduction(unit.Name, 1);
 			return false;
 		}
 	}

OpenRA.Mods.Common/Traits/Production.cs

@@ -11,6 +11,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using OpenRA.Primitives;
 using OpenRA.Traits;
 
@@ -26,6 +27,15 @@ public class ProductionInfo : PausableConditionalTraitInfo
 		[Desc("When owner is changed, should the Faction be updated to the new owner's faction?")]
 		public readonly bool UpdateFactionOnOwnerChange = false;
 
+		[Desc("Produce new actors directly into this actor's cargo instead of spawning them on the map.")]
+		public readonly bool ProduceIntoCargo = false;
+
+		[Desc("When producing into cargo, also attempt to load into the cargo of passengers that themselves have cargo.")]
+		public readonly bool ProduceIntoCargoOfCargo = false;
+
+		[Desc("Priority value when multiple cargo-producing traits compete. Higher values are preferred.")]
+		public readonly int CargoPriority = 0;
+
 		public override object Create(ActorInitializer init) { return new Production(init, this); }
 	}
 
@@ -121,6 +131,9 @@ public virtual bool Produce(Actor self, ActorInfo producee, string productionTyp
 			if (IsTraitDisabled || IsTraitPaused)
 				return false;
 
+			if (Info.ProduceIntoCargo && TryProduceIntoCargo(self, producee, productionType, inits))
+				return true;
+
 			// Pick a spawn/exit point pair
 			var exit = SelectExit(self, producee, productionType);
 			if (exit != null || self.OccupiesSpace == null || !producee.HasTraitInfo<IOccupySpaceInfo>())
@@ -132,6 +145,62 @@ public virtual bool Produce(Actor self, ActorInfo producee, string productionTyp
 			return false;
 		}
 
+		bool TryProduceIntoCargo(Actor self, ActorInfo producee, string productionType, TypeDictionary inits)
+		{
+			var passengerInfo = producee.TraitInfoOrDefault<PassengerInfo>();
+			if (passengerInfo == null)
+				return false;
+
+			var candidates = GatherCargoTargets(self, passengerInfo.Weight);
+			if (candidates == null)
+				return false;
+
+			var td = new TypeDictionary();
+			foreach (var init in inits)
+				td.Add(init);
+
+			var (transport, cargo) = candidates.Value;
+			var newUnit = self.World.CreateActor(false, producee.Name, td);
+			cargo.Load(transport, newUnit);
+
+			self.World.AddFrameEndTask(w =>
+			{
+				if (!self.IsDead)
+					foreach (var t in self.TraitsImplementing<INotifyProduction>())
+						t.UnitProduced(self, newUnit, transport.Location);
+
+				var notifyOthers = self.World.ActorsWithTrait<INotifyOtherProduction>();
+				foreach (var notify in notifyOthers)
+					notify.Trait.UnitProducedByOther(notify.Actor, self, newUnit, productionType, td);
+			});
+
+			return true;
+		}
+
+		(Actor Transport, Cargo Cargo)? GatherCargoTargets(Actor self, int weight)
+		{
+			var cargos = self.TraitsImplementing<Cargo>().ToArray();
+			foreach (var cargo in cargos)
+				if (cargo.HasSpace(weight))
+					return (self, cargo);
+
+			if (!Info.ProduceIntoCargoOfCargo)
+				return null;
+
+			foreach (var cargo in cargos)
+				foreach (var passenger in cargo.Passengers)
+				{
+					if (passenger == null || passenger.IsDead)
+						continue;
+
+					var passengerCargo = passenger.TraitOrDefault<Cargo>();
+					if (passengerCargo != null && passengerCargo.HasSpace(weight))
+						return (passenger, passengerCargo);
+				}
+
+			return null;
+		}
+
 		public virtual void ProduceActors(Actor self, ActorInfo producee, string productionType, TypeDictionary inits, ExitInfo exit)
 		{
 			var buildable = BuildableInfo.GetTraitForQueue(producee, productionType);

OpenRA.Mods.Common/Warheads/CreateEffectPulsateWarhead.cs

@@ -0,0 +1,87 @@
+#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.GameRules;
+using OpenRA.Mods.Common.Effects;
+using OpenRA.Primitives;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Common.Warheads
+{
+	[Desc("Spawn a sprite that pulsates between scales during its lifetime.")]
+	public class CreateEffectPulsateWarhead : CreateEffectWarhead
+	{
+		[Desc("Scale at the start of the animation.")]
+		public readonly float StartScale = 0.1f;
+
+		[Desc("Scale reached at the apex of the pulse.")]
+		public readonly float PeakScale = 1f;
+
+		[Desc("Scale at the end of the pulse (defaults to StartScale).")]
+		public readonly float EndScale = 0.1f;
+
+		[Desc("Ticks spent scaling from StartScale to PeakScale.")]
+		public readonly int GrowTicks = 8;
+
+		[Desc("Ticks to remain at PeakScale before shrinking.")]
+		public readonly int HoldTicks = 0;
+
+		[Desc("Ticks spent scaling from PeakScale to EndScale.")]
+		public readonly int ShrinkTicks = 8;
+
+		[Desc("If true, repeats the grow/hold/shrink cycle until the animation ends.")]
+		public readonly bool Loop = false;
+
+		public override void DoImpact(in Target target, WarheadArgs args)
+		{
+			if (target.Type == TargetType.Invalid)
+				return;
+
+			var firedBy = args.SourceActor;
+			var pos = target.CenterPosition;
+			var world = firedBy.World;
+			var actorAtImpact = ImpactActors ? ActorTypeAtImpact(world, pos, firedBy) : ImpactActorType.None;
+
+			if (actorAtImpact == ImpactActorType.Invalid)
+				return;
+
+			if (actorAtImpact == ImpactActorType.None && !IsValidAgainstTerrain(world, pos))
+				return;
+
+			var explosion = Explosions.RandomOrDefault(world.LocalRandom);
+			if (Image != null && explosion != null)
+			{
+				if (Inaccuracy.Length > 0)
+					pos += WVec.FromPDF(world.SharedRandom, 2) * Inaccuracy.Length / 1024;
+
+				if (ForceDisplayAtGroundLevel)
+				{
+					var dat = world.Map.DistanceAboveTerrain(pos);
+					pos -= new WVec(0, 0, dat.Length);
+				}
+
+				var palette = ExplosionPalette;
+				if (UsePlayerPalette)
+					palette += firedBy.Owner.InternalName;
+
+				world.AddFrameEndTask(w => w.Add(new PulsatingSpriteEffect(
+					pos, w, Image, explosion, palette,
+					StartScale, PeakScale, EndScale,
+					GrowTicks, HoldTicks, ShrinkTicks, Loop)));
+			}
+
+			var impactSound = ImpactSounds.RandomOrDefault(world.LocalRandom);
+			if (impactSound != null && world.LocalRandom.Next(0, 100) < ImpactSoundChance
+				&& (AudibleThroughFog || (!world.ShroudObscures(pos) && !world.FogObscures(pos))))
+				Game.Sound.Play(SoundType.World, impactSound, pos, Volume);
+		}
+	}
+}