call DoAttack from activities instead of from Tick in AttackPlane/AttackHeli

OpenRA.Mods.RA/Activities/FlyAttack.cs

@@ -14,24 +14,39 @@ namespace OpenRA.Mods.RA.Activities
 {
 	public class FlyAttack : CancelableActivity
 	{
-		Target Target;
+		readonly Target Target;
+		IActivity inner;
 
 		public FlyAttack(Target target) { Target = target; }
 
 		public override IActivity Tick(Actor self)
 		{
-			if (IsCanceled) return NextActivity;
+			if( !Target.IsValid )
-			if (!Target.IsValid)
+				Cancel( self );
-				return NextActivity;
-
 			var limitedAmmo = self.TraitOrDefault<LimitedAmmo>();
-			if (limitedAmmo != null && !limitedAmmo.HasAmmo())
+			if( limitedAmmo != null && !limitedAmmo.HasAmmo() )
-				return NextActivity;
+				Cancel( self );
 
-			return Util.SequenceActivities(
+			self.Trait<AttackPlane>().DoAttack( self );
+
+			if( IsCanceled && inner == null ) return NextActivity;
+
+			if( inner == null )
+			{
+				inner = Util.SequenceActivities(
 					Fly.ToPx(Target.CenterLocation),
-				new FlyTimed(50),
+					new FlyTimed(50));
-				this);
+			}
+			inner = inner.Tick( self );
+
+			return this;
+		}
+
+		protected override bool OnCancel( Actor self )
+		{
+			if( inner != null )
+				inner.Cancel( self );
+			return base.OnCancel( self );
 		}
 	}
 

OpenRA.Mods.RA/Activities/HeliAttack.cs

@@ -39,7 +39,8 @@ namespace OpenRA.Mods.RA.Activities
 				return this;
 			}
 
-			var range = self.Trait<AttackBase>().GetMaximumRange() - 1;
+			var attack = self.Trait<AttackBase>();
+			var range = attack.GetMaximumRange() - 1;
 			var dist = target.CenterLocation - self.CenterLocation;
 
 			var desiredFacing = Util.GetFacing(dist, aircraft.Facing);
@@ -49,6 +50,8 @@ namespace OpenRA.Mods.RA.Activities
 			if (!float2.WithinEpsilon(float2.Zero, dist, range * Game.CellSize))
 				aircraft.center += (rawSpeed / dist.Length) * dist;
 
+			attack.DoAttack( self );
+
 			return this;
 		}
 	}

OpenRA.Mods.RA/AttackFrontal.cs

@@ -20,17 +20,18 @@ namespace OpenRA.Mods.RA
 
 		readonly int FacingTolerance;
 
-		public override void Tick(Actor self)
+		protected override bool CanAttack( Actor self )
 		{
-			base.Tick(self);
+			if( !base.CanAttack( self ) )
-
+				return false;
-			if (!target.IsValid) return;
 
 			var facing = self.Trait<IFacing>().Facing;
 			var facingToTarget = Util.GetFacing(target.CenterLocation - self.CenterLocation, facing);
 
-			if (Math.Abs(facingToTarget - facing) % 256 < FacingTolerance)
+			if( Math.Abs( facingToTarget - facing ) % 256 >= FacingTolerance )
-				DoAttack(self);
+				return false;
+
+			return true;
 		}
 	}
 }