Fix idle animations / prone.

OpenRA.Mods.RA/AutoHeal.cs

@@ -51,7 +51,6 @@ namespace OpenRA.Mods.RA
 		Actor currentTarget;
 		public void TickIdle( Actor self )
 		{
-			System.Console.WriteLine("AutoHeal:TickIdle");
 			var attack = self.Trait<AttackBase>();
 			var range = attack.GetMaximumRange();
 
@@ -59,11 +58,8 @@ namespace OpenRA.Mods.RA
 			{
 				var currentTarget = ChooseTarget(self, range);
 				if( currentTarget != null )
-				{
-					System.Console.WriteLine("AutoHeal: Queing heal activity");
 					self.QueueActivity(self.Trait<AttackBase>().GetAttackActivity(self, Target.FromActor( currentTarget ), false ));
 			}
 		}
 	}
-	}
 }

OpenRA.Mods.RA/AutoTarget.cs

@@ -39,17 +39,13 @@ namespace OpenRA.Mods.RA
 
 		public void TickIdle( Actor self )
 		{
-			System.Console.WriteLine("AutoTarget:TickIdle");
 			var attack = self.Trait<AttackBase>();
 			var currentTarget = attack.ScanForTarget(self, null);
 			if( currentTarget != null )
-			{
-				System.Console.WriteLine("AutoTarget: Queing attack activity");
 				self.QueueActivity(attack.GetAttackActivity( self,
 				                                            Target.FromActor(currentTarget),
 				                                            self.Info.Traits.Get<AutoTargetInfo>().AllowMovement
 				                                            ));
 		}
 	}
-	}
 }

OpenRA.Mods.RA/IdleAnimation.cs

@@ -23,10 +23,17 @@ namespace OpenRA.Mods.RA
 	// infantry prone behavior
 	class IdleAnimation : ITick, INotifyIdle
 	{
+		enum IdleState
+		{
+			None,
+			Waiting,
+			Active
+		};
+		
 		IdleAnimationInfo Info;
 		string sequence;
 		int delay;
-		bool active, waiting;
+		IdleState state;
 		
 		public IdleAnimation(IdleAnimationInfo info)
 		{
@@ -35,49 +42,30 @@ namespace OpenRA.Mods.RA
 
 		public void Tick(Actor self)
 		{		
-			if (active)
-			{
-				//System.Console.WriteLine("active: {0} ({1})", self.Info.Name, self.ActorID);
-				return;
-			}
 			if (!self.IsIdle)
 			{
-				//System.Console.WriteLine("notidle: {0} ({1}) ",self.Info.Name, self.ActorID);
+				state = IdleState.None;
-				active = false;
-				waiting = false;
 				return;
 			}
 			
-			if (delay > 0 && --delay == 0)
+			if (state == IdleState.Active)
+				return;
+				
+			else if (delay > 0 && --delay == 0)
 			{
-				System.Console.WriteLine("activate: {0} ({1})",self.Info.Name, self.ActorID);
+				state = IdleState.Active;
-				active = true;
+				self.Trait<RenderInfantry>().anim.PlayThen(sequence, () => state = IdleState.None);
-				waiting = false;
-				self.Trait<RenderInfantry>().anim.PlayThen(sequence, () =>
-				{
-					//System.Console.WriteLine("finished: {0} ({1}) ",self.Info.Name, self.ActorID);
-					active = false;
-				});
 			}
 		}
 		
 		public void TickIdle(Actor self)
 		{
-			System.Console.WriteLine("IdleAnimation:TickIdle");
+			if (state != IdleState.None)
-
-			//if (active)
-			//	System.Console.WriteLine("idleactive: {0} ({1}) ",self.Info.Name, self.ActorID);
-			
-			//if (waiting)
-			//	System.Console.WriteLine("idlewaiting: {0} ({1}) ",self.Info.Name, self.ActorID);
-			if (active || waiting)
 				return;
 			
-			waiting = true;
+			state = IdleState.Waiting;
 			sequence = Info.Animations.Random(self.World.SharedRandom);
 			delay = Info.IdleWaitTicks;
-			System.Console.WriteLine("IdleAnimation: setting anim to {0} delay {1}", sequence, delay);
-
 		}
 	}
 }

OpenRA.Mods.RA/Render/RenderInfantry.cs

@@ -23,58 +23,53 @@ namespace OpenRA.Mods.RA.Render
 
 	public class RenderInfantry : RenderSimple, INotifyAttack, INotifyDamage, INotifyIdle
 	{
+		public enum AnimationState
+		{
+			Idle,
+			Attacking,
+			Moving
+		};
+		
+		public AnimationState State { get; private set; }
+		Mobile mobile = self.Trait<Mobile>();
 		public RenderInfantry(Actor self)
 			: base(self, () => self.Trait<IFacing>().Facing)
 		{
 			anim.Play("stand");
-		}
+			State = AnimationState.Idle;
-
-		bool ChooseMoveAnim(Actor self)
-		{
-			var mobile = self.Trait<Mobile>();
-			if( !mobile.IsMoving ) return false;
-
-			if (float2.WithinEpsilon(self.CenterLocation, Util.CenterOfCell(mobile.toCell), 2)) return false;
-
-			var seq = IsProne(self) ? "crawl" : "run";
-
-			if (anim.CurrentSequence.Name != seq)
-				anim.PlayRepeating(seq);
-
-			return true;
-		}
-
-		bool inAttack = false;
-		bool IsProne(Actor self)
-		{
-			var takeCover = self.TraitOrDefault<TakeCover>();
-			return takeCover != null && takeCover.IsProne;
 		}
 
 		public void Attacking(Actor self, Target target)
 		{
-			inAttack = true;
+			State = AnimationState.Attacking;
-
+			if (anim.HasSequence("shoot"))
-			var seq = IsProne(self) ? "prone-shoot" : "shoot";
+				anim.PlayThen("shoot", () => State = AnimationState.Idle);
-
-			if (anim.HasSequence(seq))
-				anim.PlayThen(seq, () => inAttack = false);
 			else if (anim.HasSequence("heal"))
-				anim.PlayThen("heal", () => inAttack = false);
+				anim.PlayThen("heal", () => State = AnimationState.Idle);
 		}
 
 		public override void Tick(Actor self)
 		{
 			base.Tick(self);
-			if (self.IsIdle || inAttack) return;
+
-			ChooseMoveAnim(self);
+			if (State == AnimationState.Attacking || self.IsIdle || !mobile.IsMoving)
+				return;
+			
+			// Set move animation
+			if (State != AnimationState.Moving)
+			{
+				State = AnimationState.Moving;
+				anim.PlayRepeating("run");
+			}
 		}
 		
 		public void TickIdle(Actor self)
 		{
-			System.Console.WriteLine("RenderInfantry:TickIdle");
+			if (State != AnimationState.Idle)
-			System.Console.WriteLine("RenderInfantry: setting anim to stand");
+			{
 				anim.Play("stand");
+				State = AnimationState.Idle;
+			}
 		}
 		
 

OpenRA.Mods.RA/TakeCover.cs

@@ -10,13 +10,14 @@
 
 using OpenRA.GameRules;
 using OpenRA.Traits;
+using OpenRA.Mods.RA.Render;
 
 namespace OpenRA.Mods.RA
 {
-	class TakeCoverInfo : TraitInfo<TakeCover> { }
+	class TakeCoverInfo : TraitInfo<TakeCover>, ITraitPrerequisite<RenderInfantryInfo> { }
 
 	// infantry prone behavior
-	class TakeCover : ITick, INotifyDamage, IDamageModifier, ISpeedModifier, INotifyIdle
+	class TakeCover : ITick, INotifyDamage, IDamageModifier, ISpeedModifier
 	{
 		const int defaultProneTime = 100;	/* ticks, =4s */
 		const float proneDamage = .5f;
@@ -29,28 +30,36 @@ namespace OpenRA.Mods.RA
 
 		public void Damaged(Actor self, AttackInfo e)
 		{
-			if (e.Damage > 0)		/* fix to allow healing via `damage` */
+			if (e.Damage > 0) /* Don't go prone when healed */
 			{
 				if (e.Warhead == null || !e.Warhead.PreventProne)
 					remainingProneTime = defaultProneTime;
-				
 			}
 		}
 
 		public void Tick(Actor self)
 		{
-			if (IsProne)
+			if (!IsProne)
-				--remainingProneTime;
+				return;
-		}
 			
-		public void TickIdle(Actor self)
+			remainingProneTime--;
-		{
+			
-			System.Console.WriteLine("TakeCover:TickIdle");
+			var ri = self.Trait<RenderInfantry>();
-			if (remainingProneTime > 0)
+			if (ri.State == RenderInfantry.AnimationState.Idle)
-			{
+				if (IsProne)
-				System.Console.WriteLine("TakeCover: set anim to crawl");
+					ri.anim.PlayFetchIndex("crawl", () => 0);
-				self.Trait<RenderSimple>().anim.PlayFetchIndex("crawl", () => 0);
+				else
-			}
+					ri.anim.Play("stand");
+			
+			if (ri.anim.CurrentSequence.Name == "run" && IsProne)
+				ri.anim.ReplaceAnim("crawl");
+			else if (ri.anim.CurrentSequence.Name == "crawl" && !IsProne)
+				ri.anim.ReplaceAnim("run");
+			
+			if (ri.anim.CurrentSequence.Name == "shoot" && IsProne)
+				ri.anim.ReplaceAnim("prone-shoot");
+			else if (ri.anim.CurrentSequence.Name == "prone-shoot" && !IsProne)
+				ri.anim.ReplaceAnim("shoot");
 		}
 		
 		public float GetDamageModifier(Actor attacker, WarheadInfo warhead )