diff --git a/OpenRA.Game/Graphics/Animation.cs b/OpenRA.Game/Graphics/Animation.cs
index e07e69d499..94bc600bfc 100644
--- a/OpenRA.Game/Graphics/Animation.cs
+++ b/OpenRA.Game/Graphics/Animation.cs
@@ -40,7 +40,7 @@ namespace OpenRA.Graphics
 			get
 			{
 				return backwards
-					? CurrentSequence.GetSprite(CurrentSequence.End - frame - 1, facingFunc())
+					? CurrentSequence.GetSprite(CurrentSequence.Start + CurrentSequence.Length - frame - 1, facingFunc())
 					: CurrentSequence.GetSprite(frame, facingFunc());
 			}
 		}
diff --git a/OpenRA.Game/Graphics/Sequence.cs b/OpenRA.Game/Graphics/Sequence.cs
index 59ec7a2931..4f191f2efd 100644
--- a/OpenRA.Game/Graphics/Sequence.cs
+++ b/OpenRA.Game/Graphics/Sequence.cs
@@ -9,7 +9,6 @@
 #endregion
 
 using System;
-using System.Xml;
 using System.Collections.Generic;
 using System.Linq;
 using OpenRA.FileFormats;
@@ -19,16 +18,14 @@ namespace OpenRA.Graphics
 	public class Sequence
 	{
 		readonly Sprite[] sprites;
-		readonly int start, length, stride, facings, tick;
 		readonly bool reverseFacings, transpose;
 
 		public readonly string Name;
-		public int Start { get { return start; } }
-		public int End { get { return start + length; } }
-		public int Length { get { return length; } }
-		public int Stride { get { return stride; } }
-		public int Facings { get { return facings; } }
-		public int Tick { get { return tick; } }
+		public readonly int Start;
+		public readonly int Length;
+		public readonly int Stride;
+		public readonly int Facings;
+		public readonly int Tick;
 		public readonly int ZOffset;
 
 		public Sequence(string unit, string name, MiniYaml info)
@@ -38,7 +35,7 @@ namespace OpenRA.Graphics
 			var d = info.NodesDict;
 			var offset = float2.Zero;
 
-			start = int.Parse(d["Start"].Value);
+			Start = int.Parse(d["Start"].Value);
 
 			if (d.ContainsKey("Offset"))
 				offset = FieldLoader.GetValue<float2>("Offset", d["Offset"].Value);
@@ -49,30 +46,30 @@ namespace OpenRA.Graphics
 				s => new Sprite(s.sheet, s.bounds, s.offset + offset, s.channel)).ToArray();
 
 			if (!d.ContainsKey("Length"))
-				length = 1;
+				Length = 1;
 			else if (d["Length"].Value == "*")
-				length = sprites.Length - Start;
+				Length = sprites.Length - Start;
 			else
-				length = int.Parse(d["Length"].Value);
+				Length = int.Parse(d["Length"].Value);
 
 			if (d.ContainsKey("Stride"))
-				stride = int.Parse(d["Stride"].Value);
+				Stride = int.Parse(d["Stride"].Value);
 			else
-				stride = length;
+				Stride = Length;
 
 			if (d.ContainsKey("Facings"))
 			{
 				var f = int.Parse(d["Facings"].Value);
-				facings = Math.Abs(f);
+				Facings = Math.Abs(f);
 				reverseFacings = f < 0;
 			}
 			else
-				facings = 1;
+				Facings = 1;
 
 			if (d.ContainsKey("Tick"))
-				tick = int.Parse(d["Tick"].Value);
+				Tick = int.Parse(d["Tick"].Value);
 			else
-				tick = 40;
+				Tick = 40;
 
 			if (d.ContainsKey("Transpose"))
 			    transpose = bool.Parse(d["Transpose"].Value);
@@ -80,15 +77,15 @@ namespace OpenRA.Graphics
 			if (d.ContainsKey("ZOffset"))
 				ZOffset = int.Parse(d["ZOffset"].Value);
 
-			if (length > stride)
+			if (Length > Stride)
 				throw new InvalidOperationException(
 					"{0}: Sequence {1}.{2}: Length must be <= stride"
 						.F(info.Nodes[0].Location, unit, name));
 
-			if (start < 0 || start + facings * stride > sprites.Length)
+			if (Start < 0 || Start + Facings * Stride > sprites.Length)
 				throw new InvalidOperationException(
 					"{6}: Sequence {0}.{1} uses frames [{2}..{3}] of SHP `{4}`, but only 0..{5} actually exist"
-					.F(unit, name, start, start + facings * stride - 1, srcOverride ?? unit, sprites.Length - 1,
+					.F(unit, name, Start, Start + Facings * Stride - 1, srcOverride ?? unit, sprites.Length - 1,
 					info.Nodes[0].Location));
 		}
 
@@ -99,15 +96,15 @@ namespace OpenRA.Graphics
 
 		public Sprite GetSprite(int frame, int facing)
 		{
-			var f = Traits.Util.QuantizeFacing(facing, facings);
+			var f = Traits.Util.QuantizeFacing(facing, Facings);
 
 			if (reverseFacings)
-				f = (facings - f) % facings;
+				f = (Facings - f) % Facings;
 
-			int i = transpose ? (frame % length) * facings + f :
-				(f * stride) + (frame % length);
+			int i = transpose ? (frame % Length) * Facings + f :
+				(f * Stride) + (frame % Length);
 
-			return sprites[start + i];
+			return sprites[Start + i];
 		}
 	}
 }