updated linq calls to zero allocation zlinq

Assets/Code/GameState/Entities/ModifiersResolver.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using ZLinq;
 
 namespace Nox.Game {
 
@@ -26,34 +26,40 @@ namespace Nox.Game {
                 return baseValue;
             }
 
-            var grouped = modifiers
-                .Where(m => m != null && m.Operation != ModifierOperation.None)
-                .GroupBy(m => m.Operation)
-                .ToDictionary(g => g.Key, g => g.ToList());
+            float flatSum = 0f;
+            float addSum = 0f;
+            float pctSum = 0f;
+            var mulValues = new List<float>();
+            var hasFlat = false;
 
-            float result = baseValue;
-
-            // 1. Flat — if any flat modifiers exist, they replace the base entirely
-            if(grouped.TryGetValue(ModifierOperation.Flat, out var flatMods)) {
-                result = flatMods.Sum(m => m.Value);
-            }
-
-            // 2. Addition — sum all additive bonuses
-            if(grouped.TryGetValue(ModifierOperation.Addition, out var addMods)) {
-                result += addMods.Sum(m => m.Value);
-            }
-
-            // 3. Percentage — summed into one multiplier: result * (1 + totalPercent / 100)
-            if(grouped.TryGetValue(ModifierOperation.Percentage, out var pctMods)) {
-                var totalPercent = pctMods.Sum(m => m.Value);
-                result *= 1f + (totalPercent / 100f);
-            }
-
-            // 4. Multiplication — each factor applied sequentially
-            if(grouped.TryGetValue(ModifierOperation.Multiplication, out var mulMods)) {
-                foreach(var mod in mulMods) {
-                    result *= mod.Value;
+            foreach(var m in modifiers) {
+                if(m == null || m.Operation == ModifierOperation.None) {
+                    continue;
                 }
+
+                switch(m.Operation) {
+                    case ModifierOperation.Flat:
+                        flatSum += m.Value;
+                        hasFlat = true;
+                        break;
+                    case ModifierOperation.Addition:
+                        addSum += m.Value;
+                        break;
+                    case ModifierOperation.Percentage:
+                        pctSum += m.Value;
+                        break;
+                    case ModifierOperation.Multiplication:
+                        mulValues.Add(m.Value);
+                        break;
+                }
+            }
+
+            float result = hasFlat ? flatSum : baseValue;
+            result += addSum;
+            result *= 1f + (pctSum / 100f);
+
+            foreach(var mul in mulValues) {
+                result *= mul;
             }
 
             return (int)Math.Round(result);
@@ -61,38 +67,64 @@ namespace Nox.Game {
 
         public IEnumerable<IModifier> CollectModifiers(IEntityDefinition entity, StatType statType) {
             if(entity == null) {
-                return Enumerable.Empty<IModifier>();
+                return Array.Empty<IModifier>();
             }
 
-            var direct = entity.Modifiers?.modifiers?
-                    .Where(m => m != null && m.StatType == statType)
-                ?? Enumerable.Empty<IModifier>();
+            var result = new List<IModifier>();
 
-            var fromPerks = entity.Perks?.perks?
-                    .Where(p => p?.Modifiers?.modifiers != null)
-                    .SelectMany(p => p.Modifiers.modifiers)
-                    .Where(m => m != null && m.StatType == statType)
-                ?? Enumerable.Empty<IModifier>();
+            if(entity.Modifiers?.modifiers != null) {
+                foreach(var m in entity.Modifiers.modifiers) {
+                    if(m != null && m.StatType == statType) {
+                        result.Add(m);
+                    }
+                }
+            }
 
-            return direct.Concat(fromPerks);
+            if(entity.Perks?.perks != null) {
+                foreach(var p in entity.Perks.perks) {
+                    if(p?.Modifiers?.modifiers == null) {
+                        continue;
+                    }
+                    foreach(var m in p.Modifiers.modifiers) {
+                        if(m != null && m.StatType == statType) {
+                            result.Add(m);
+                        }
+                    }
+                }
+            }
+
+            return result;
         }
 
         public IEnumerable<IModifier> CollectModifiers(IEntityDefinition entity, AttributeType attributeType) {
             if(entity == null) {
-                return Enumerable.Empty<IModifier>();
+                return Array.Empty<IModifier>();
             }
 
-            var direct = entity.Modifiers?.modifiers?
-                    .Where(m => m != null && m.AttributeType == attributeType)
-                ?? Enumerable.Empty<IModifier>();
+            var result = new List<IModifier>();
 
-            var fromPerks = entity.Perks?.perks?
-                    .Where(p => p?.Modifiers?.modifiers != null)
-                    .SelectMany(p => p.Modifiers.modifiers)
-                    .Where(m => m != null && m.AttributeType == attributeType)
-                ?? Enumerable.Empty<IModifier>();
+            if(entity.Modifiers?.modifiers != null) {
+                foreach(var m in entity.Modifiers.modifiers) {
+                    if(m != null && m.AttributeType == attributeType) {
+                        result.Add(m);
+                    }
+                }
+            }
 
-            return direct.Concat(fromPerks);
+            if(entity.Perks?.perks != null) {
+                foreach(var p in entity.Perks.perks) {
+                    if(p?.Modifiers?.modifiers == null) {
+                        continue;
+                    }
+                    foreach(var m in p.Modifiers.modifiers) {
+                        if(m != null && m.AttributeType == attributeType) {
+                            result.Add(m);
+                        }
+                    }
+                }
+            }
+
+            return result;
         }
     }
 }