Tackle the last of the low hanging fruit for memory allocations in the main game loop.

- Avoid calling string.Split twice in SprintFont.Measure.
- Change ActorsInBox method of ActorMap and ScreenMap to avoid allocating and intermediate list. As a bonus this allows the sequence to be lazily consumed. Also avoid LINQ in these methods.
- In FrozenUnderFog.TickRender, the method exits early if no players are visible so the attempt at lazy generation was not needed.
- Unwrap a LINQ Any call in ClassicProductionQueue.Tick.
- Merge some successive Where calls in ProximityCapturable into single predicates.

OpenRA.Game/Graphics/SpriteFont.cs

@@ -85,7 +85,8 @@ namespace OpenRA.Graphics
 
 		public int2 Measure(string text)
 		{
-			return new int2((int)text.Split('\n').Max(s => s.Sum(a => glyphs[Pair.New(a, Color.White)].Advance)), text.Split('\n').Count()*size);
+			var lines = text.Split('\n');
+			return new int2((int)Math.Ceiling(lines.Max(s => s.Sum(a => glyphs[Pair.New(a, Color.White)].Advance))), lines.Length * size);
 		}
 
 		Cache<Pair<char,Color>, GlyphInfo> glyphs;

OpenRA.Game/Traits/World/ActorMap.cs

@@ -189,21 +189,22 @@ namespace OpenRA.Traits
 			var j1 = (top / info.BinSize).Clamp(0, rows - 1);
 			var j2 = (bottom / info.BinSize).Clamp(0, rows - 1);
 
-			var actorsInBox = new List<Actor>();
+			var actorsChecked = new HashSet<Actor>();
 			for (var j = j1; j <= j2; j++)
 			{
 				for (var i = i1; i <= i2; i++)
 				{
 					foreach (var actor in actors[j * cols + i])
+					{
+						if (actor.IsInWorld && actorsChecked.Add(actor))
 						{
 							var c = actor.CenterPosition;
-						if (actor.IsInWorld && left <= c.X && c.X <= right && top <= c.Y && c.Y <= bottom)
-							actorsInBox.Add(actor);
+							if (left <= c.X && c.X <= right && top <= c.Y && c.Y <= bottom)
+								yield return actor;
+						}
 					}
 				}
 			}
-
-			return actorsInBox.Distinct();
 		}
 	}
 }

OpenRA.Game/Traits/World/ScreenMap.cs

@@ -153,14 +153,15 @@ namespace OpenRA.Traits
 			var top = (r.Top / info.BinSize).Clamp(0, rows - 1);
 			var bottom = (r.Bottom / info.BinSize).Clamp(0, rows - 1);
 
-			var actorsInBox = new List<Actor>();
+			var actorsChecked = new HashSet<Actor>();
 			for (var j = top; j <= bottom; j++)
 				for (var i = left; i <= right; i++)
-					actorsInBox.AddRange(actors[j * cols + i]
-						.Where(kv => kv.Key.IsInWorld && kv.Value.IntersectsWith(r))
-						.Select(kv => kv.Key));
-
-			return actorsInBox.Distinct();
+					foreach (var kvp in actors[j * cols + i])
+					{
+						var actor = kvp.Key;
+						if (actor.IsInWorld && kvp.Value.IntersectsWith(r) && actorsChecked.Add(actor))
+							yield return actor;
+					}
 		}
 
 		public IEnumerable<FrozenActor> FrozenActorsInBox(Player p, int2 a, int2 b)

OpenRA.Mods.RA/Modifiers/FrozenUnderFog.cs

@@ -111,19 +111,14 @@ namespace OpenRA.Mods.RA
 
 		public void TickRender(WorldRenderer wr, Actor self)
 		{
-			if (self.Destroyed || !initialized || !visible.Any(v => v.Value))
+			if (self.Destroyed || !initialized || !visible.Values.Any(v => v))
 				return;
 
-			IRenderable[] renderables = null;
+			var renderables = self.Render(wr).ToArray();
 			foreach (var player in self.World.Players)
 				if (visible[player])
-				{
-					// Lazily generate a copy of the underlying data.
-					if (renderables == null)
-						renderables = self.Render(wr).ToArray();
 					frozen[player].Renderables = renderables;
 		}
-		}
 
 		public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
 		{

OpenRA.Mods.RA/Player/ClassicProductionQueue.cs

@@ -45,10 +45,13 @@ namespace OpenRA.Mods.RA
 
 		public override void Tick(Actor self)
 		{
-			isActive = self.World.ActorsWithTrait<Production>()
-				.Any(x => x.Actor.Owner == self.Owner
-					 && x.Trait.Info.Produces.Contains(Info.Type));
-
+			isActive = false;
+			foreach (var x in self.World.ActorsWithTrait<Production>())
+				if (x.Actor.Owner == self.Owner && x.Trait.Info.Produces.Contains(Info.Type))
+				{
+					isActive = true;
+					break;
+				}
 			base.Tick(self);
 		}
 

OpenRA.Mods.RA/ProximityCapturable.cs

@@ -110,32 +110,26 @@ namespace OpenRA.Mods.RA
 		IEnumerable<Actor> UnitsInRange()
 		{
 			return Self.World.FindActorsInCircle(Self.CenterPosition, WRange.FromCells(Info.Range))
-				.Where(a => a.IsInWorld && a != Self && !a.Destroyed)
-				.Where(a => !a.Owner.NonCombatant);
+				.Where(a => a.IsInWorld && a != Self && !a.Destroyed && !a.Owner.NonCombatant);
 		}
 
 		bool IsClear(Actor self, Player currentOwner, Player originalOwner)
 		{
-			return UnitsInRange().Where(a => a.Owner != originalOwner)
-				.Where(a => a.Owner != currentOwner)
-				.Where(a => CanBeCapturedBy(a))
-				.All(a => WorldUtils.AreMutualAllies(a.Owner, currentOwner));
+			return UnitsInRange()
+				.All(a => a.Owner == originalOwner || a.Owner == currentOwner ||
+					WorldUtils.AreMutualAllies(a.Owner, currentOwner) || !CanBeCapturedBy(a));
 		}
 
 		// TODO exclude other NeutralActor that arent permanent
 		bool IsStillInRange(Actor self)
 		{
-			return UnitsInRange()
-				.Where(a => a.Owner == self.Owner)
-				.Where(a => CanBeCapturedBy(a))
-				.Any();
+			return UnitsInRange().Any(a => a.Owner == self.Owner && CanBeCapturedBy(a));
 		}
 
 		IEnumerable<Actor> CaptorsInRange(Actor self)
 		{
 			return UnitsInRange()
-				.Where(a => a.Owner != OriginalOwner)
-				.Where(a => CanBeCapturedBy(a));
+				.Where(a => a.Owner != OriginalOwner && CanBeCapturedBy(a));
 		}
 
 		// TODO exclude other NeutralActor that arent permanent
@@ -146,8 +140,8 @@ namespace OpenRA.Mods.RA
 
 		int CountPlayersNear(Actor self, Player ignoreMe)
 		{
-			return CaptorsInRange(self).Select(a => a.Owner)
-				.Distinct().Count(p => p != ignoreMe);
+			return CaptorsInRange(self).Select(a => a.Owner).Where(p => p != ignoreMe)
+				.Distinct().Count();
 		}
 	}
 }