Оптимизация

Author: Scream034

BulletShrapnelLogic.cs

@@ -7,52 +7,28 @@ namespace ScavShrapnelMod
     /// <summary>
     /// Осколки от пуль при попадании в металлический блок.
     /// 
+    /// Все числовые параметры читаются из <see cref="ShrapnelConfig"/> (секция Bullets).
+    /// 
     /// Механика:
     /// 1. Пуля попадает в блок (TurretScript.Shoot → Postfix)
-    /// 2. Делаем raycast по направлению выстрела
+    /// 2. Raycast по направлению выстрела
     /// 3. Если попали в металлический блок → 1-3 мелких осколка
     /// 4. Осколки летят от точки попадания + рандомный разброс
     /// 
     /// Ограничения производительности:
-    /// - Макс 1 спавн за MinFramesBetweenSpawns кадров
-    /// - Макс 3 осколка за спавн
+    /// - Throttle по кадрам (конфигурируемый)
+    /// - Макс осколков за спавн (конфигурируемый)
     /// - Только metallic блоки
-    /// - Raycast макс RaycastDistance единиц
+    /// - Raycast макс 200 единиц
     /// </summary>
     public static class BulletShrapnelLogic
     {
-        //  Константы 
-
         /// <summary>Дистанция raycast. Совпадает с TurretScript.Shoot (200f).</summary>
         private const float RaycastDistance = 200f;
 
         /// <summary>Имя слоя Ground в Unity.</summary>
         private const string GroundLayerName = "Ground";
 
-        /// <summary>Минимальный интервал между спавнами (кадры).</summary>
-        private const int MinFramesBetweenSpawns = 3;
-
-        /// <summary>Базовая скорость осколков от пуль (м/с).</summary>
-        private const float BaseSpeed = 25;
-
-        /// <summary>Количество осколков: min inclusive.</summary>
-        private const int MinFragments = 1;
-
-        /// <summary>Количество осколков: max exclusive.</summary>
-        private const int MaxFragmentsExclusive = 4;
-
-        /// <summary>Искры: min inclusive.</summary>
-        private const int MinSparks = 4;
-
-        /// <summary>Искры: max exclusive.</summary>
-        private const int MaxSparksExclusive = 8;
-
-        /// <summary>Множитель масштаба (мельче чем от взрыва).</summary>
-        private const float ScaleMultiplier = 0.72f;
-
-        /// <summary>Множитель нагрева (менее горячие).</summary>
-        private const float HeatMultiplier = 0.5f;
-
         /// <summary>Шанс что осколок Hot vs Medium.</summary>
         private const float HotWeightChance = 0.6f;
 
@@ -72,23 +48,22 @@ private static int GroundMask
 
         /// <summary>
         /// Точка входа. Вызывается из Postfix патча TurretScript.Shoot.
+        /// Параметры читаются из конфига.
         /// </summary>
         public static void TrySpawnFromBullet(FireInfo info)
         {
             try
             {
-                // Throttle
                 int frame = Time.frameCount;
-                if (frame - _lastSpawnFrame < MinFramesBetweenSpawns) return;
+                if (frame - _lastSpawnFrame < ShrapnelConfig.BulletMinFramesBetweenSpawns.Value)
+                    return;
 
                 Vector2 origin = info.pos;
                 Vector2 direction = info.dir;
 
-                // Raycast по Ground
                 RaycastHit2D hit = Physics2D.Raycast(origin, direction, RaycastDistance, GroundMask);
                 if (!hit.collider) return;
 
-                // Проверка металлического блока
                 Vector2 blockSamplePos = hit.point + direction * 0.1f;
                 Vector2Int blockPos;
                 try
@@ -105,18 +80,22 @@ public static void TrySpawnFromBullet(FireInfo info)
 
                 _lastSpawnFrame = frame;
 
-                // Детерминированный RNG
                 int seed = unchecked(
                     (int)(hit.point.x * 10000f) * 397 ^
                     (int)(hit.point.y * 10000f) ^
                     frame);
                 System.Random rng = new System.Random(seed);
 
-                int fragmentCount = rng.Range(MinFragments, MaxFragmentsExclusive);
+                int fragmentCount = rng.Range(
+                    ShrapnelConfig.BulletFragmentsMin.Value,
+                    ShrapnelConfig.BulletFragmentsMax.Value);
+
+                // Применяем глобальный множитель количества
+                fragmentCount = Mathf.Max(1,
+                    Mathf.RoundToInt(fragmentCount * ShrapnelConfig.SpawnCountMultiplier.Value));
+
                 for (int i = 0; i < fragmentCount; i++)
-                {
                     SpawnBulletFragment(hit.point, hit.normal, rng, i);
-                }
 
                 SpawnBulletSparks(hit.point, hit.normal, rng);
             }
@@ -128,13 +107,19 @@ public static void TrySpawnFromBullet(FireInfo info)
 
         /// <summary>
         /// Спавнит один мелкий осколок от попадания пули.
+        /// Регистрирует в <see cref="DebrisTracker"/>.
         /// </summary>
         private static void SpawnBulletFragment(Vector2 hitPoint, Vector2 hitNormal,
             System.Random rng, int index)
         {
             Material litMat = ShrapnelVisuals.LitMaterial;
             if (litMat == null) return;
 
+            float scaleMultiplier = ShrapnelConfig.BulletScaleMultiplier.Value;
+            float heatMultiplier = ShrapnelConfig.BulletHeatMultiplier.Value;
+            float baseSpeed = ShrapnelConfig.BulletBaseSpeed.Value;
+            float globalMaxSpeed = ShrapnelConfig.GlobalMaxSpeed.Value;
+
             ShrapnelWeight weight = rng.NextFloat() < HotWeightChance
                 ? ShrapnelWeight.Hot
                 : ShrapnelWeight.Medium;
@@ -149,15 +134,15 @@ private static void SpawnBulletFragment(Vector2 hitPoint, Vector2 hitNormal,
             obj.transform.position = hitPoint + rng.InsideUnitCircle() * 0.1f;
             obj.layer = 0;
 
-            float scale = ShrapnelFactory.ScaleForWeight(weight, rng) * ScaleMultiplier;
+            float scale = ShrapnelFactory.ScaleForWeight(weight, rng) * scaleMultiplier;
             obj.transform.localScale = Vector3.one * scale;
 
             SpriteRenderer sr = obj.AddComponent<SpriteRenderer>();
             sr.sprite = sprite;
             sr.sortingOrder = 10;
             sr.sharedMaterial = litMat;
 
-            float heat = ShrapnelFactory.HeatForWeight(weight) * HeatMultiplier;
+            float heat = ShrapnelFactory.HeatForWeight(weight) * heatMultiplier;
             sr.color = Color.Lerp(
                 ShrapnelVisuals.GetColdColor(ShrapnelProjectile.ShrapnelType.Metal),
                 ShrapnelVisuals.GetHotColor(), heat);
@@ -185,19 +170,24 @@ private static void SpawnBulletFragment(Vector2 hitPoint, Vector2 hitNormal,
             dir.Normalize();
 
             float speed = Mathf.Min(
-                BaseSpeed * rng.Range(0.5f, 1.5f),
-                ShrapnelSpawnLogic.GlobalMaxSpeed);
+                baseSpeed * rng.Range(0.5f, 1.5f),
+                globalMaxSpeed);
 
             rb.AddForce(dir * speed * rb.mass, ForceMode2D.Impulse);
             rb.AddTorque(rng.Range(-200f, 200f));
+
+            DebrisTracker.Register(obj);
         }
 
         /// <summary>
         /// Спавнит визуальные искры при попадании пули в металл.
+        /// Количество берётся из конфига.
         /// </summary>
         private static void SpawnBulletSparks(Vector2 hitPoint, Vector2 hitNormal, System.Random rng)
         {
-            int sparkCount = rng.Range(MinSparks, MaxSparksExclusive);
+            int sparkCount = rng.Range(
+                ShrapnelConfig.BulletSparksMin.Value,
+                ShrapnelConfig.BulletSparksMax.Value);
 
             for (int i = 0; i < sparkCount; i++)
             {

DebrisTracker.cs

@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace ScavShrapnelMod
+{
+    /// <summary>
+    /// Глобальный трекер живых debris/stuck объектов.
+    /// 
+    /// При превышении лимита (<see cref="ShrapnelConfig.MaxAliveDebris"/>)
+    /// удаляет старейшие объекты (FIFO).
+    /// 
+    /// Предотвращает неограниченный рост GameObject'ов при серии взрывов.
+    /// 
+    /// Реализация: List с удалением с начала.
+    /// Для 800 элементов O(n) RemoveAt(0) приемлемо (~0.01ms).
+    /// </summary>
+    public static class DebrisTracker
+    {
+        /// <summary>
+        /// Список живых debris. Новые добавляются в конец, старые удаляются с начала.
+        /// Null-элементы (уничтоженные Unity) очищаются периодически.
+        /// </summary>
+        private static readonly List<GameObject> _alive = new List<GameObject>();
+
+        /// <summary>Счётчик для периодической очистки null-ов.</summary>
+        private static int _cleanupCounter;
+
+        /// <summary>Очистка null каждые N регистраций.</summary>
+        private const int CleanupInterval = 50;
+
+        /// <summary>
+        /// Регистрирует новый debris-объект.
+        /// Если лимит превышен — удаляет старейший.
+        /// </summary>
+        /// <param name="obj">GameObject осколка/debris.</param>
+        public static void Register(GameObject obj)
+        {
+            if (obj == null) return;
+
+            _alive.Add(obj);
+            _cleanupCounter++;
+
+            // Периодическая очистка мёртвых ссылок
+            if (_cleanupCounter >= CleanupInterval)
+            {
+                _cleanupCounter = 0;
+                PurgeNulls();
+            }
+
+            int max = ShrapnelConfig.MaxAliveDebris.Value;
+            while (_alive.Count > max)
+            {
+                // Удаляем старейший (с начала списка)
+                GameObject oldest = _alive[0];
+                _alive.RemoveAt(0);
+
+                // Unity может уже уничтожить объект
+                if (oldest != null)
+                    Object.Destroy(oldest);
+            }
+        }
+
+        /// <summary>
+        /// Удаляет все null-ссылки из списка.
+        /// Unity уничтожает GameObject, но наша ссылка остаётся.
+        /// 
+        /// Итерация с конца для безопасного удаления.
+        /// </summary>
+        private static void PurgeNulls()
+        {
+            for (int i = _alive.Count - 1; i >= 0; i--)
+            {
+                // Unity overloads == null for destroyed objects
+                if (_alive[i] == null)
+                    _alive.RemoveAt(i);
+            }
+        }
+
+        /// <summary>
+        /// Текущее количество отслеживаемых объектов (включая потенциальные null).
+        /// </summary>
+        public static int Count => _alive.Count;
+
+        /// <summary>
+        /// Принудительно очищает все отслеживаемые объекты.
+        /// Полезно при перезагрузке сцены.
+        /// </summary>
+        public static void Clear()
+        {
+            for (int i = 0; i < _alive.Count; i++)
+            {
+                if (_alive[i] != null)
+                    Object.Destroy(_alive[i]);
+            }
+            _alive.Clear();
+            _cleanupCounter = 0;
+        }
+    }
+}