diff --git a/Services/Immortal/BuildOrderService.cs b/Services/Immortal/BuildOrderService.cs
index 18dd75e..2e6b7ce 100644
--- a/Services/Immortal/BuildOrderService.cs
+++ b/Services/Immortal/BuildOrderService.cs
@@ -58,7 +58,7 @@ public class BuildOrderService : IBuildOrderService
     public void Add(EntityModel entity, int atInterval)
     {
         if (!_buildOrder.StartedOrders.ContainsKey(atInterval))
-            _buildOrder.StartedOrders.Add(atInterval, new List<EntityModel>());
+            _buildOrder.StartedOrders.Add(atInterval, []);
 
         var production = entity.Production();
 
@@ -66,21 +66,18 @@ public class BuildOrderService : IBuildOrderService
         if (production != null) completedTime += production.BuildTime;
 
         if (!_buildOrder.CompletedOrders.ContainsKey(completedTime))
-            _buildOrder.CompletedOrders.Add(completedTime, new List<EntityModel>());
+            _buildOrder.CompletedOrders.Add(completedTime, []);
 
         _buildOrder.StartedOrders[atInterval].Add(entity.Clone());
         _buildOrder.CompletedOrders[completedTime].Add(entity.Clone());
 
-        if (!_buildOrder.UniqueCompletedTimes.ContainsKey(entity.DataType))
-            _buildOrder.UniqueCompletedTimes.Add(entity.DataType, atInterval);
+        _buildOrder.UniqueCompletedTimes.TryAdd(entity.DataType, atInterval);
 
-        if (!_buildOrder.UniqueCompletedCount.ContainsKey(entity.DataType))
-            _buildOrder.UniqueCompletedCount.Add(entity.DataType, 1);
-        else
+        if (!_buildOrder.UniqueCompletedCount.TryAdd(entity.DataType, 1))
             _buildOrder.UniqueCompletedCount[entity.DataType]++;
 
         if (!_buildOrder.UniqueCompleted.ContainsKey(entity.DataType))
-            _buildOrder.UniqueCompleted.Add(entity.DataType, new List<EntityModel>());
+            _buildOrder.UniqueCompleted.Add(entity.DataType, []);
 
         if (entity.Production()?.ProducedBy != null)
             _buildOrder.TrainingCapacityUsed.Add(new TrainingCapacityUsedModel
@@ -116,10 +113,10 @@ public class BuildOrderService : IBuildOrderService
         _lastInterval += forInterval;
 
         if (!_buildOrder.StartedOrders.ContainsKey(_lastInterval))
-            _buildOrder.StartedOrders.Add(_lastInterval, new List<EntityModel>());
+            _buildOrder.StartedOrders.Add(_lastInterval, []);
 
         if (!_buildOrder.CompletedOrders.ContainsKey(_lastInterval))
-            _buildOrder.CompletedOrders.Add(_lastInterval, new List<EntityModel>());
+            _buildOrder.CompletedOrders.Add(_lastInterval, []);
 
         NotifyDataChanged();
         return true;
@@ -140,10 +137,10 @@ public class BuildOrderService : IBuildOrderService
         _lastInterval = interval;
 
         if (!_buildOrder.StartedOrders.ContainsKey(_lastInterval))
-            _buildOrder.StartedOrders.Add(_lastInterval, new List<EntityModel>());
+            _buildOrder.StartedOrders.Add(_lastInterval, []);
 
         if (!_buildOrder.CompletedOrders.ContainsKey(_lastInterval))
-            _buildOrder.CompletedOrders.Add(_lastInterval, new List<EntityModel>());
+            _buildOrder.CompletedOrders.Add(_lastInterval, []);
 
         NotifyDataChanged();
         return true;
@@ -175,9 +172,10 @@ public class BuildOrderService : IBuildOrderService
 
         if (supply == null || supply.Takes.Equals(0)) return 0;
 
-        foreach (var supplyAtTime in _buildOrder.SupplyCountTimes)
-            if (supply.Takes + _buildOrder.CurrentSupplyUsed <= supplyAtTime.Key)
-                return supplyAtTime.Value;
+        foreach (var supplyAtTime in 
+                 _buildOrder.SupplyCountTimes
+                     .Where(supplyAtTime => supply.Takes + _buildOrder.CurrentSupplyUsed <= supplyAtTime.Key))
+            return supplyAtTime.Value;
 
         return null;
     }
@@ -199,65 +197,64 @@ public class BuildOrderService : IBuildOrderService
 
     public void RemoveLast()
     {
-        if (_buildOrder.StartedOrders.Keys.Count > 1)
+        if (_buildOrder.StartedOrders.Keys.Count <= 1) return;
+        
+        if (_buildOrder.StartedOrders.Count == 0)
         {
-            if (_buildOrder.StartedOrders.Count == 0)
-            {
-                _buildOrder.StartedOrders.Remove(_buildOrder.StartedOrders.Last().Key);
-                _buildOrder.CompletedOrders.Remove(_buildOrder.CompletedOrders.Last().Key);
+            _buildOrder.StartedOrders.Remove(_buildOrder.StartedOrders.Last().Key);
+            _buildOrder.CompletedOrders.Remove(_buildOrder.CompletedOrders.Last().Key);
 
-                _lastInterval = _buildOrder.StartedOrders.Last().Key;
-                return;
-            }
-
-            var lastStarted = _buildOrder.StartedOrders.Keys.Last();
-            var lastCompleted = _buildOrder.CompletedOrders.Keys.Last();
+            _lastInterval = _buildOrder.StartedOrders.Last().Key;
+            return;
+        }
 
-            EntityModel entityRemoved = default!;
+        var lastStarted = _buildOrder.StartedOrders.Keys.Last();
+        var lastCompleted = _buildOrder.CompletedOrders.Keys.Last();
 
-            if (_buildOrder.StartedOrders[lastStarted].Count > 0)
-            {
-                entityRemoved = _buildOrder.StartedOrders[lastStarted].Last();
-                _buildOrder.StartedOrders[lastStarted].Remove(_buildOrder.StartedOrders[lastStarted].Last());
-                _buildOrder.CompletedOrders[lastCompleted].Remove(_buildOrder.CompletedOrders[lastCompleted].Last());
-            }
+        EntityModel entityRemoved = default!;
 
-            if (_buildOrder.StartedOrders[lastStarted].Count == 0) _buildOrder.StartedOrders.Remove(lastStarted);
-            if (_buildOrder.CompletedOrders[lastCompleted].Count == 0)
-                _buildOrder.CompletedOrders.Remove(lastCompleted);
+        if (_buildOrder.StartedOrders[lastStarted].Count > 0)
+        {
+            entityRemoved = _buildOrder.StartedOrders[lastStarted].Last();
+            _buildOrder.StartedOrders[lastStarted].Remove(_buildOrder.StartedOrders[lastStarted].Last());
+            _buildOrder.CompletedOrders[lastCompleted].Remove(_buildOrder.CompletedOrders[lastCompleted].Last());
+        }
 
-            if (_buildOrder.StartedOrders.Keys.Count > 0)
-                _lastInterval = _buildOrder.StartedOrders.Keys.Last();
-            else
-                _lastInterval = 0;
+        if (_buildOrder.StartedOrders[lastStarted].Count == 0) _buildOrder.StartedOrders.Remove(lastStarted);
+        if (_buildOrder.CompletedOrders[lastCompleted].Count == 0)
+            _buildOrder.CompletedOrders.Remove(lastCompleted);
 
-            if (entityRemoved.Supply()?.Grants > 0)
-                SupplyCountTimes.Remove(SupplyCountTimes.Last().Key);
+        if (_buildOrder.StartedOrders.Keys.Count > 0)
+            _lastInterval = _buildOrder.StartedOrders.Keys.Last();
+        else
+            _lastInterval = 0;
 
-            if (entityRemoved.Supply()?.Takes > 0)
-                _buildOrder.CurrentSupplyUsed -= entityRemoved.Supply()!.Takes;
+        if (entityRemoved.Supply()?.Grants > 0)
+            SupplyCountTimes.Remove(SupplyCountTimes.Last().Key);
 
-            _buildOrder.UniqueCompletedCount[entityRemoved!.DataType]--;
-            if (_buildOrder.UniqueCompletedCount[entityRemoved!.DataType] == 0)
-                UniqueCompletedTimes.Remove(entityRemoved.DataType);
+        if (entityRemoved.Supply()?.Takes > 0)
+            _buildOrder.CurrentSupplyUsed -= entityRemoved.Supply()!.Takes;
 
-            _buildOrder.UniqueCompleted[entityRemoved.DataType]
-                .Remove(_buildOrder.UniqueCompleted[entityRemoved.DataType].Last());
+        _buildOrder.UniqueCompletedCount[entityRemoved!.DataType]--;
+        if (_buildOrder.UniqueCompletedCount[entityRemoved!.DataType] == 0)
+            UniqueCompletedTimes.Remove(entityRemoved.DataType);
 
-            if (entityRemoved.Production() != null
-                && entityRemoved.Production()!.ProducedBy != null
-                && entityRemoved.Supply() != null
-                && entityRemoved.Supply()!.Takes > 0)
-                _buildOrder.TrainingCapacityUsed.Remove(_buildOrder.TrainingCapacityUsed.Last());
+        _buildOrder.UniqueCompleted[entityRemoved.DataType]
+            .Remove(_buildOrder.UniqueCompleted[entityRemoved.DataType].Last());
 
-            if (entityRemoved.Info().Descriptive == DescriptiveType.Worker)
-            {
-                RemoveLast();
-                return;
-            }
+        if (entityRemoved.Production() != null
+            && entityRemoved.Production()!.ProducedBy != null
+            && entityRemoved.Supply() != null
+            && entityRemoved.Supply()!.Takes > 0)
+            _buildOrder.TrainingCapacityUsed.Remove(_buildOrder.TrainingCapacityUsed.Last());
 
-            NotifyDataChanged();
+        if (entityRemoved.Info().Descriptive == DescriptiveType.Worker)
+        {
+            RemoveLast();
+            return;
         }
+
+        NotifyDataChanged();
     }
 
 
@@ -352,22 +349,22 @@ public class BuildOrderService : IBuildOrderService
         var uniqueCompleted = _buildOrder.UniqueCompleted[producedBy];
 
         var shortestIncrement = int.MaxValue;
-        var trainingSlots = 0;
         var didDelay = false;
 
-        foreach (var productionEntity in uniqueCompleted) trainingSlots += productionEntity.Supply()!.Grants;
+        var trainingSlots = uniqueCompleted.Sum(productionEntity => productionEntity.Supply()!.Grants);
 
 
         while (true)
         {
             var usedSlots = 0;
-            foreach (var used in _buildOrder.TrainingCapacityUsed)
-                if (checkedInterval >= used.StartingUsageTime && checkedInterval < used.StopUsageTime)
-                {
-                    usedSlots += used.UsedSlots;
-                    var duration = used.StopUsageTime - used.StartingUsageTime;
-                    if (duration < shortestIncrement) shortestIncrement = duration;
-                }
+            foreach (var used in 
+                     _buildOrder.TrainingCapacityUsed
+                         .Where(used => checkedInterval >= used.StartingUsageTime && checkedInterval < used.StopUsageTime))
+            {
+                usedSlots += used.UsedSlots;
+                var duration = used.StopUsageTime - used.StartingUsageTime;
+                if (duration < shortestIncrement) shortestIncrement = duration;
+            }
 
             if (usedSlots + supply.Takes <= trainingSlots)
             {
@@ -399,16 +396,15 @@ public class BuildOrderService : IBuildOrderService
         for (var interval = atInterval; interval < withEconomy.GetOverTime().Count; interval++)
         {
             var economyAtSecond = withEconomy.GetOverTime()[interval];
-            if (economyAtSecond.Alloy >= production.Alloy
-                && economyAtSecond.Ether >= production.Ether
-                && economyAtSecond.Pyre >= production.Pyre)
-            {
-                atInterval = interval;
+            if (!(economyAtSecond.Alloy >= production.Alloy)
+                || !(economyAtSecond.Ether >= production.Ether)
+                || !(economyAtSecond.Pyre >= production.Pyre)) continue;
+            
+            atInterval = interval;
 
-                if (entity.EntityType != EntityType.Army) atInterval += _timingService.BuildingInputDelay;
+            if (entity.EntityType != EntityType.Army) atInterval += _timingService.BuildingInputDelay;
 
-                return true;
-            }
+            return true;
         }
 
         if (withEconomy.GetOverTime().Last().Ether < production.Ether)