Rename tesla attack logic and move to Mods.Cnc.

OpenRA.Mods.Cnc/OpenRA.Mods.Cnc.csproj

@@ -90,6 +90,10 @@
     <Compile Include="UtilityCommands\LegacyRulesImporter.cs" />
     <Compile Include="UtilityCommands\LegacySequenceImporter.cs" />
     <Compile Include="Widgets\Logic\PreReleaseWarningPrompt.cs" />
+    <Compile Include="Traits\Attack\AttackTesla.cs" />
+    <Compile Include="Traits\Render\WithTeslaChargeAnimation.cs" />
+    <Compile Include="Traits\Render\WithTeslaChargeOverlay.cs" />
+    <Compile Include="TraitsInterfaces.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenRA.Game\OpenRA.Game.csproj">

OpenRA.Mods.Cnc/Traits/Attack/AttackTesla.cs

@@ -0,0 +1,135 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2017 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Activities;
+using OpenRA.Mods.Common.Activities;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Cnc.Traits
+{
+	[Desc("Implements the charge-then-burst attack logic specific to the RA tesla coil.")]
+	class AttackTeslaInfo : 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 ReloadDelay = 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;
+
+		[Desc("Sound to play when actor charges.")]
+		public readonly string ChargeAudio = null;
+
+		public override object Create(ActorInitializer init) { return new AttackTesla(init.Self, this); }
+	}
+
+	class AttackTesla : AttackOmni, ITick, INotifyAttack
+	{
+		readonly AttackTeslaInfo info;
+
+		[Sync] int charges;
+		[Sync] int timeToRecharge;
+
+		public AttackTesla(Actor self, AttackTeslaInfo 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);
+		}
+
+		void INotifyAttack.Attacking(Actor self, Target target, Armament a, Barrel barrel)
+		{
+			--charges;
+			timeToRecharge = info.ReloadDelay;
+		}
+
+		void INotifyAttack.PreparingAttack(Actor self, Target target, Armament a, Barrel barrel) { }
+
+		public override Activity GetAttackActivity(Actor self, Target newTarget, bool allowMove, bool forceAttack)
+		{
+			return new ChargeAttack(this, newTarget);
+		}
+
+		class ChargeAttack : Activity
+		{
+			readonly AttackTesla attack;
+			readonly Target target;
+
+			public ChargeAttack(AttackTesla 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;
+
+				foreach (var notify in self.TraitsImplementing<INotifyTeslaCharging>())
+					notify.Charging(self, target);
+
+				if (!string.IsNullOrEmpty(attack.info.ChargeAudio))
+					Game.Sound.Play(SoundType.World, attack.info.ChargeAudio, self.CenterPosition);
+
+				return ActivityUtils.SequenceActivities(new Wait(attack.info.InitialChargeDelay), new ChargeFire(attack, target), this);
+			}
+		}
+
+		class ChargeFire : Activity
+		{
+			readonly AttackTesla attack;
+			readonly Target target;
+
+			public ChargeFire(AttackTesla 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 ActivityUtils.SequenceActivities(new Wait(attack.info.ChargeDelay), this);
+			}
+		}
+	}
+}

OpenRA.Mods.Cnc/Traits/Render/WithTeslaChargeAnimation.cs

@@ -0,0 +1,42 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2017 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Mods.Common.Traits.Render;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Cnc.Traits.Render
+{
+	[Desc("This actor displays a charge-up animation before firing.")]
+	public class WithTeslaChargeAnimationInfo : ITraitInfo, Requires<WithSpriteBodyInfo>, Requires<RenderSpritesInfo>
+	{
+		[Desc("Sequence to use for charge animation.")]
+		[SequenceReference] public readonly string ChargeSequence = "active";
+
+		public object Create(ActorInitializer init) { return new WithTeslaChargeAnimation(init, this); }
+	}
+
+	public class WithTeslaChargeAnimation : INotifyTeslaCharging
+	{
+		readonly WithTeslaChargeAnimationInfo info;
+		readonly WithSpriteBody wsb;
+
+		public WithTeslaChargeAnimation(ActorInitializer init, WithTeslaChargeAnimationInfo info)
+		{
+			this.info = info;
+			wsb = init.Self.Trait<WithSpriteBody>();
+		}
+
+		void INotifyTeslaCharging.Charging(Actor self, Target target)
+		{
+			wsb.PlayCustomAnimation(self, info.ChargeSequence, () => wsb.CancelCustomAnimation(self));
+		}
+	}
+}

OpenRA.Mods.Cnc/Traits/Render/WithTeslaChargeOverlay.cs

@@ -0,0 +1,71 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2017 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Graphics;
+using OpenRA.Mods.Common.Traits;
+using OpenRA.Mods.Common.Traits.Render;
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Cnc.Traits.Render
+{
+	[Desc("Rendered together with AttackCharge.")]
+	public class WithTeslaChargeOverlayInfo : ITraitInfo, Requires<RenderSpritesInfo>
+	{
+		[Desc("Sequence name to use")]
+		[SequenceReference] public readonly string Sequence = "active";
+
+		[Desc("Custom palette name")]
+		[PaletteReference("IsPlayerPalette")] public readonly string Palette = null;
+
+		[Desc("Custom palette is a player palette BaseName")]
+		public readonly bool IsPlayerPalette = false;
+
+		public object Create(ActorInitializer init) { return new WithTeslaChargeOverlay(init, this); }
+	}
+
+	public class WithTeslaChargeOverlay : INotifyTeslaCharging, INotifyDamageStateChanged, INotifySold
+	{
+		readonly Animation overlay;
+		readonly RenderSprites renderSprites;
+		readonly WithTeslaChargeOverlayInfo info;
+
+		bool charging;
+
+		public WithTeslaChargeOverlay(ActorInitializer init, WithTeslaChargeOverlayInfo info)
+		{
+			this.info = info;
+
+			renderSprites = init.Self.Trait<RenderSprites>();
+
+			overlay = new Animation(init.World, renderSprites.GetImage(init.Self));
+
+			renderSprites.Add(new AnimationWithOffset(overlay, null, () => !charging),
+				info.Palette, info.IsPlayerPalette);
+		}
+
+		void INotifyTeslaCharging.Charging(Actor self, Target target)
+		{
+			charging = true;
+			overlay.PlayThen(RenderSprites.NormalizeSequence(overlay, self.GetDamageState(), info.Sequence), () => charging = false);
+		}
+
+		void INotifyDamageStateChanged.DamageStateChanged(Actor self, AttackInfo e)
+		{
+			overlay.ReplaceAnim(RenderSprites.NormalizeSequence(overlay, e.DamageState, info.Sequence));
+		}
+
+		void INotifySold.Sold(Actor self) { }
+		void INotifySold.Selling(Actor self)
+		{
+			charging = false;
+		}
+	}
+}

OpenRA.Mods.Cnc/TraitsInterfaces.cs

@@ -0,0 +1,18 @@
+#region Copyright & License Information
+/*
+ * Copyright 2007-2017 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, either version 3 of
+ * the License, or (at your option) any later version. For more
+ * information, see COPYING.
+ */
+#endregion
+
+using OpenRA.Traits;
+
+namespace OpenRA.Mods.Cnc.Traits
+{
+	[RequireExplicitImplementation]
+	public interface INotifyTeslaCharging { void Charging(Actor self, Target target); }
+}