Префабы в Unity: Использование, хранение, управление

GameObject enemyInstance = Instantiate(enemyPrefab, position, rotation);

// Пример доступа к компоненту вложенного префаба
EnemyController controller = enemyInstance.transform.Find("WeaponSystem").GetComponent<WeaponController>();

Prefabs/
  Characters/
    Enemies/
    NPCs/
  Environment/
    Props/
    Terrain/
  UI/
    Buttons/
    Panels/

git commit -m "Update Enemy_Goblin prefab: adjusted movement speed and attack range for better gameplay balance"

// Сброс всех переопределений и применение значений из префаба
PrefabUtility.RevertPrefabInstance(gameObject, InteractionMode.UserAction);

public GameObject enemyBasePrefab;
public ScriptableObject[] enemyDataSet;
 
public GameObject CreateEnemyFromData(ScriptableObject enemyData, Vector3 position)
{
    GameObject enemy = Instantiate(enemyBasePrefab, position, Quaternion.identity);
    enemy.GetComponent<EnemyController>().Initialize(enemyData);
    return enemy;
}

private void OnValidate()
{
    // Проверяем, что все необходимые компоненты присутствуют
    if (GetComponent<Rigidbody>() == null)
    {
        Debug.LogWarning("This prefab requires a Rigidbody component!");
    }
    
    // Проверяем зависимости между компонентами
    Animator animator = GetComponent<Animator>();
    AnimationController controller = GetComponent<AnimationController>();
    
    if (animator != null && controller != null)
    {
        if (controller.animatorParameters.Length == 0)
        {
            Debug.LogWarning("AnimationController doesn't have any parameters set!");
        }
    }
}

#if UNITY_EDITOR
using UnityEditor;
 
public class PrefabBatchEditor : EditorWindow
{
    private float newMovementSpeed = 5.0f;
    
    [MenuItem("Tools/Prefab Batch Editor")]
    public static void ShowWindow()
    {
        GetWindow<PrefabBatchEditor>("Prefab Editor");
    }
    
    private void OnGUI()
    {
        GUILayout.Label("Batch Edit Enemy Movement Speed", EditorStyles.boldLabel);
        newMovementSpeed = EditorGUILayout.FloatField("New Speed", newMovementSpeed);
        
        if (GUILayout.Button("Apply to All Enemy Prefabs"))
        {
            string[] prefabPaths = AssetDatabase.FindAssets("t:Prefab Enemy_");
            foreach (string guid in prefabPaths)
            {
                string path = AssetDatabase.GUIDToAssetPath(guid);
                GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
                EnemyController controller = prefab.GetComponent<EnemyController>();
                
                if (controller != null)
                {
                    controller.movementSpeed = newMovementSpeed;
                    EditorUtility.SetDirty(prefab);
                }
            }
            AssetDatabase.SaveAssets();
        }
    }
}
#endif

IEnumerator LoadPrefabsAsync(string[] prefabPaths)
{
    foreach (string path in prefabPaths)
    {
        ResourceRequest request = Resources.LoadAsync<GameObject>(path);
        yield return request;
        
        if (request.asset != null)
        {
            loadedPrefabs.Add(path, request.asset as GameObject);
        }
        else
        {
            Debug.LogError($"Failed to load prefab at path: {path}");
        }
    }
    
    Debug.Log("All prefabs loaded successfully");
}

GameObject prefab = Resources.Load<GameObject>("Enemies/Goblin");
GameObject instance = Instantiate(prefab, position, rotation);

[CreateAssetMenu(menuName = "Database/PrefabsDatabase")]
public class PrefabsDatabase : ScriptableObject
{
    public GameObject playerPrefab;
    public GameObject[] enemyPrefabs;
    public GameObject bulletPrefab;
    public GameObject explosionVFX;
    // Другие префабы
}

[CreateAssetMenu(menuName = "Database/DynamicPrefabRegistry")]
public class DynamicPrefabRegistry : ScriptableObject
{
    [Serializable]
    public class PrefabEntry
    {
        public string id;
        public GameObject prefab;
    }
 
    public List<PrefabEntry> entries = new List<PrefabEntry>();
    private Dictionary<string, GameObject> lookupTable;
 
    public void Initialize()
    {
        lookupTable = new Dictionary<string, GameObject>();
        foreach (var entry in entries)
        {
            if (!lookupTable.ContainsKey(entry.id))
            {
                lookupTable.Add(entry.id, entry.prefab);
            }
        }
    }
 
    public GameObject GetPrefab(string id)
    {
        if (lookupTable == null) Initialize();
        
        if (lookupTable.TryGetValue(id, out GameObject prefab))
        {
            return prefab;
        }
        
        Debug.LogWarning($"Prefab with ID {id} not found in registry!");
        return null;
    }
}

public class PrefabCache
{
    private static Dictionary<int, GameObject> _prefabCache = new Dictionary<int, GameObject>();
 
    public static void RegisterPrefab(int hashKey, GameObject prefab)
    {
        if (!_prefabCache.ContainsKey(hashKey))
        {
            _prefabCache.Add(hashKey, prefab);
        }
    }
 
    public static GameObject GetPrefab(int hashKey)
    {
        if (_prefabCache.TryGetValue(hashKey, out GameObject prefab))
        {
            return prefab;
        }
        return null;
    }
}

[Serializable]
public class PrefabModificationData
{
    public string prefabId;
    public Vector3 scale;
    public Color color;
    public float health;
    // Другие модифицируемые параметры
    
    public void ApplyTo(GameObject instance)
    {
        instance.transform.localScale = scale;
        
        Renderer renderer = instance.GetComponent<Renderer>();
        if (renderer != null)
        {
            renderer.material.color = color;
        }
        
        HealthComponent healthComp = instance.GetComponent<HealthComponent>();
        if (healthComp != null)
        {
            healthComp.maxHealth = health;
        }
    }
}

[CreateAssetMenu(menuName = "Database/AdvancedPrefabSystem")]
public class PrefabSystem : ScriptableObject
{
    [Serializable]
    public class PrefabCategory
    {
        public string categoryName;
        public List<PrefabEntry> prefabs = new List<PrefabEntry>();
    }
    
    [Serializable]
    public class PrefabEntry
    {
        public string id;
        public GameObject prefab;
        public string[] tags;
        [TextArea] public string description;
    }
    
    public List<PrefabCategory> categories = new List<PrefabCategory>();
    private Dictionary<string, GameObject> _idLookup;
    private Dictionary<string, List<PrefabEntry>> _tagLookup;
    
    public void Initialize()
    {
        _idLookup = new Dictionary<string, GameObject>();
        _tagLookup = new Dictionary<string, List<PrefabEntry>>();
        
        foreach (var category in categories)
        {
            foreach (var entry in category.prefabs)
            {
                // ID lookup
                if (!_idLookup.ContainsKey(entry.id))
                {
                    _idLookup.Add(entry.id, entry.prefab);
                }
                
                // Tag lookup
                foreach (var tag in entry.tags)
                {
                    if (!_tagLookup.ContainsKey(tag))
                    {
                        _tagLookup.Add(tag, new List<PrefabEntry>());
                    }
                    _tagLookup[tag].Add(entry);
                }
            }
        }
    }
    
    public GameObject GetPrefabById(string id)
    {
        if (_idLookup == null) Initialize();
        
        if (_idLookup.TryGetValue(id, out GameObject prefab))
        {
            return prefab;
        }
        return null;
    }
    
    public List<GameObject> GetPrefabsByTag(string tag)
    {
        if (_tagLookup == null) Initialize();
        
        if (_tagLookup.TryGetValue(tag, out List<PrefabEntry> entries))
        {
            return entries.Select(e => e.prefab).ToList();
        }
        return new List<GameObject>();
    }
}

// Пример использования SQLite для хранения информации о префабах
// Требуется подключение библиотеки SQLite
 
public class SQLitePrefabDatabase
{
    private SQLiteConnection _connection;
    private Dictionary<int, GameObject> _prefabCache = new Dictionary<int, GameObject>();
    
    public void Initialize(string dbPath)
    {
        // Открытие или создание БД
        _connection = new SQLiteConnection($"Data Source={dbPath};Version=3;");
        _connection.Open();
        
        // Создание таблиц, если они не существуют
        string createTableQuery = @"
            CREATE TABLE IF NOT EXISTS Prefabs (
                Id INTEGER PRIMARY KEY,
                Name TEXT NOT NULL,
                Path TEXT NOT NULL,
                Category TEXT,
                LastModified TEXT
            );
            
            CREATE TABLE IF NOT EXISTS PrefabTags (
                PrefabId INTEGER,
                Tag TEXT,
                PRIMARY KEY (PrefabId, Tag),
                FOREIGN KEY (PrefabId) REFERENCES Prefabs(Id)
            );";
            
        SQLiteCommand command = new SQLiteCommand(createTableQuery, _connection);
        command.ExecuteNonQuery();
    }
    
    public void RegisterPrefab(string name, string path, string category, string[] tags)
    {
        // Добавление префаба в БД
        string insertQuery = "INSERT INTO Prefabs (Name, Path, Category, LastModified) VALUES (@name, @path, @category, @date)";
        SQLiteCommand command = new SQLiteCommand(insertQuery, _connection);
        command.Parameters.AddWithValue("@name", name);
        command.Parameters.AddWithValue("@path", path);
        command.Parameters.AddWithValue("@category", category);
        command.Parameters.AddWithValue("@date", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
        command.ExecuteNonQuery();
        
        // Получение ID добавленного префаба
        long prefabId = _connection.LastInsertRowId;
        
        // Добавление тегов
        foreach (var tag in tags)
        {
            string tagQuery = "INSERT INTO PrefabTags (PrefabId, Tag) VALUES (@id, @tag)";
            SQLiteCommand tagCommand = new SQLiteCommand(tagQuery, _connection);
            tagCommand.Parameters.AddWithValue("@id", prefabId);
            tagCommand.Parameters.AddWithValue("@tag", tag);
            tagCommand.ExecuteNonQuery();
        }
    }
    
    public GameObject LoadPrefabById(int id)
    {
        // Проверка кэша
        if (_prefabCache.TryGetValue(id, out GameObject cachedPrefab))
        {
            return cachedPrefab;
        }
        
        // Загрузка из БД
        string query = "SELECT Path FROM Prefabs WHERE Id = @id";
        SQLiteCommand command = new SQLiteCommand(query, _connection);
        command.Parameters.AddWithValue("@id", id);
        
        string path = (string)command.ExecuteScalar();
        if (string.IsNullOrEmpty(path)) return null;
        
        // Загрузка префаба и добавление в кэш
        GameObject prefab = Resources.Load<GameObject>(path);
        if (prefab != null)
        {
            _prefabCache[id] = prefab;
        }
        
        return prefab;
    }
    
    public List<GameObject> LoadPrefabsByTag(string tag)
    {
        List<GameObject> result = new List<GameObject>();
        
        string query = @"
            SELECT p.Id, p.Path 
            FROM Prefabs p
            JOIN PrefabTags pt ON p.Id = pt.PrefabId
            WHERE pt.Tag = @tag";
            
        SQLiteCommand command = new SQLiteCommand(query, _connection);
        command.Parameters.AddWithValue("@tag", tag);
        
        using (SQLiteDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                int id = reader.GetInt32(0);
                string path = reader.GetString(1);
                
                GameObject prefab;
                if (_prefabCache.TryGetValue(id, out prefab))
                {
                    result.Add(prefab);
                }
                else
                {
                    prefab = Resources.Load<GameObject>(path);
                    if (prefab != null)
                    {
                        _prefabCache[id] = prefab;
                        result.Add(prefab);
                    }
                }
            }
        }
        
        return result;
    }
}

public class AssetLoader : MonoBehaviour
{
    private Dictionary<string, GameObject> _prefabCache = new Dictionary<string, GameObject>();
 
    public IEnumerator LoadPrefabAsync(string path, Action<GameObject> onComplete)
    {
        // Проверяем кэш перед загрузкой
        if (_prefabCache.TryGetValue(path, out GameObject cachedPrefab))
        {
            onComplete?.Invoke(cachedPrefab);
            yield break;
        }
 
        ResourceRequest request = Resources.LoadAsync<GameObject>(path);
        yield return request;
 
        if (request.asset != null)
        {
            GameObject prefab = request.asset as GameObject;
            _prefabCache[path] = prefab;
            onComplete?.Invoke(prefab);
        }
        else
        {
            Debug.LogError($"Failed to load prefab at path: {path}");
            onComplete?.Invoke(null);
        }
    }
}

public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject _prefab;
    [SerializeField] private int _initialSize = 10;
    
    private Queue<GameObject> _pool = new Queue<GameObject>();
    private Transform _poolParent;
    
    private void Awake()
    {
        _poolParent = new GameObject($"Pool_{_prefab.name}").transform;
        
        // Предварительное создание объектов
        for (int i = 0; i < _initialSize; i++)
        {
            GameObject obj = CreateNewInstance();
            ReturnToPool(obj);
        }
    }
    
    private GameObject CreateNewInstance()
    {
        GameObject obj = Instantiate(_prefab, _poolParent);
        obj.SetActive(false);
        return obj;
    }
    
    public GameObject GetFromPool(Vector3 position, Quaternion rotation)
    {
        GameObject obj;
        
        if (_pool.Count == 0)
        {
            // Если пул пуст, создаём новый экземпляр
            obj = CreateNewInstance();
        }
        else
        {
            // Берём существующий объект из пула
            obj = _pool.Dequeue();
        }
        
        obj.transform.SetPositionAndRotation(position, rotation);
        obj.SetActive(true);
        
        return obj;
    }
    
    public void ReturnToPool(GameObject obj)
    {
        obj.SetActive(false);
        _pool.Enqueue(obj);
    }
}

public class GenericObjectPool : MonoBehaviour
{
    private static Dictionary<GameObject, Queue<GameObject>> _poolDictionary = 
        new Dictionary<GameObject, Queue<GameObject>>();
    
    public static GameObject Get(GameObject prefab, Vector3 position, Quaternion rotation)
    {
        if (!_poolDictionary.TryGetValue(prefab, out Queue<GameObject> queue))
        {
            queue = new Queue<GameObject>();
            _poolDictionary[prefab] = queue;
        }
        
        GameObject obj;
        
        if (queue.Count > 0)
        {
            obj = queue.Dequeue();
            obj.transform.SetPositionAndRotation(position, rotation);
        }
        else
        {
            obj = Instantiate(prefab, position, rotation);
            
            // Добавляем компонент для автоматического возврата в пул
            PooledObject pooledObj = obj.AddComponent<PooledObject>();
            pooledObj.Prefab = prefab;
        }
        
        obj.SetActive(true);
        return obj;
    }
    
    public static void ReturnToPool(GameObject obj, GameObject prefab)
    {
        if (!_poolDictionary.TryGetValue(prefab, out Queue<GameObject> queue))
        {
            queue = new Queue<GameObject>();
            _poolDictionary[prefab] = queue;
        }
        
        obj.SetActive(false);
        queue.Enqueue(obj);
    }
    
    // Вспомогательный компонент для автоматического пулинга
    private class PooledObject : MonoBehaviour
    {
        public GameObject Prefab;
        
        public void ReturnToPool()
        {
            GenericObjectPool.ReturnToPool(gameObject, Prefab);
        }
    }
}

public class ResourceManager : MonoBehaviour
{
    private Dictionary<string, UnloadableResource> _loadedResources = 
        new Dictionary<string, UnloadableResource>();
    
    private class UnloadableResource
    {
        public Object Resource;
        public float LastUsedTime;
        
        public UnloadableResource(Object resource)
        {
            Resource = resource;
            UpdateUsageTime();
        }
        
        public void UpdateUsageTime()
        {
            LastUsedTime = Time.realtimeSinceStartup;
        }
    }
    
    public T LoadResource<T>(string path) where T : Object
    {
        if (_loadedResources.TryGetValue(path, out UnloadableResource resource))
        {
            resource.UpdateUsageTime();
            return resource.Resource as T;
        }
        
        T loadedResource = Resources.Load<T>(path);
        if (loadedResource != null)
        {
            _loadedResources[path] = new UnloadableResource(loadedResource);
        }
        
        return loadedResource;
    }
    
    public void UnloadUnusedResources(float unusedThreshold = 300f)
    {
        float currentTime = Time.realtimeSinceStartup;
        List<string> keysToRemove = new List<string>();
        
        foreach (var pair in _loadedResources)
        {
            if (currentTime - pair.Value.LastUsedTime > unusedThreshold)
            {
                keysToRemove.Add(pair.Key);
            }
        }
        
        foreach (string key in keysToRemove)
        {
            _loadedResources.Remove(key);
        }
        
        // Запускаем сборку мусора для освобождения памяти
        Resources.UnloadUnusedAssets();
    }
}

public class PrefabLODSystem : MonoBehaviour
{
    [SerializeField] private List<GameObject> _lodPrefabs = new List<GameObject>();
    [SerializeField] private float[] _lodDistances = new float[] { 10f, 30f, 60f };
    
    private GameObject _currentInstance;
    private int _currentLODLevel = 0;
    private Transform _playerCamera;
    
    private void Start()
    {
        _playerCamera = Camera.main.transform;
        // Начинаем с самого детализированного LOD-уровня
        _currentInstance = Instantiate(_lodPrefabs[0], transform);
        _currentLODLevel = 0;
    }
    
    private void Update()
    {
        float distanceToCamera = Vector3.Distance(transform.position, _playerCamera.position);
        int requiredLODLevel = 0;
        
        // Определяем требуемый уровень детализации на основе дистанции
        for (int i = 0; i < _lodDistances.Length; i++)
        {
            if (distanceToCamera > _lodDistances[i])
            {
                requiredLODLevel = i + 1;
            }
        }
        
        // Ограничиваем максимальным уровнем
        requiredLODLevel = Mathf.Min(requiredLODLevel, _lodPrefabs.Count - 1);
        
        // Если нужен другой уровень детализации, меняем модель
        if (requiredLODLevel != _currentLODLevel)
        {
            Destroy(_currentInstance);
            _currentInstance = Instantiate(_lodPrefabs[requiredLODLevel], transform);
            _currentLODLevel = requiredLODLevel;
        }
    }
}

public class DynamicWeaponGenerator : MonoBehaviour
{
    [SerializeField] private GameObject _baseWeaponPrefab;
    [SerializeField] private List<GameObject> _barrelPrefabs;
    [SerializeField] private List<GameObject> _gripPrefabs;
    [SerializeField] private List<GameObject> _scopePrefabs;
    [SerializeField] private List<Material> _materialVariants;
    
    public GameObject GenerateRandomWeapon()
    {
        // Создаём базовый префаб
        GameObject weapon = Instantiate(_baseWeaponPrefab);
        
        // Находим точки крепления модулей
        Transform barrelPoint = weapon.transform.Find("BarrelAttachPoint");
        Transform gripPoint = weapon.transform.Find("GripAttachPoint");
        Transform scopePoint = weapon.transform.Find("ScopeAttachPoint");
        
        // Добавляем случайные компоненты
        if (barrelPoint != null && _barrelPrefabs.Count > 0)
        {
            GameObject barrel = Instantiate(_barrelPrefabs[Random.Range(0, _barrelPrefabs.Count)], barrelPoint);
        }
        
        if (gripPoint != null && _gripPrefabs.Count > 0)
        {
            GameObject grip = Instantiate(_gripPrefabs[Random.Range(0, _gripPrefabs.Count)], gripPoint);
        }
        
        if (scopePoint != null && _scopePrefabs.Count > 0 && Random.value > 0.3f) // 70% шанс получить прицел
        {
            GameObject scope = Instantiate(_scopePrefabs[Random.Range(0, _scopePrefabs.Count)], scopePoint);
        }
        
        // Меняем материал оружия
        if (_materialVariants.Count > 0)
        {
            Material randomMaterial = _materialVariants[Random.Range(0, _materialVariants.Count)];
            MeshRenderer[] renderers = weapon.GetComponentsInChildren<MeshRenderer>();
            foreach (MeshRenderer renderer in renderers)
            {
                renderer.material = randomMaterial;
            }
        }
        
        // Добавляем компонент с характеристиками оружия
        WeaponStats stats = weapon.AddComponent<WeaponStats>();
        stats.GenerateRandomStats();
        
        return weapon;
    }
}

public class PrefabBaker : MonoBehaviour
{
    [SerializeField] private GameObject _complexPrefab;
    [SerializeField] private string _bakedPrefabPath = "Assets/BakedPrefabs/";
    
    public void BakePrefab()
    {
        #if UNITY_EDITOR
        // Создаём экземпляр комплексного префаба
        GameObject instance = Instantiate(_complexPrefab);
        
        // Объединяем меши для снижения батчей
        MeshCombiner.CombineMeshes(instance);
        
        // Запекаем освещение
        LightmapBaker.BakeLightmapsForObject(instance);
        
        // Сохраняем результат как новый префаб
        string newPrefabPath = _bakedPrefabPath + _complexPrefab.name + "_Baked.prefab";
        PrefabUtility.SaveAsPrefabAsset(instance, newPrefabPath);
        
        // Удаляем временный экземпляр
        DestroyImmediate(instance);
        #endif
    }
}

public class BackgroundPrefabProcessor : MonoBehaviour
{
    [SerializeField] private List<GameObject> _prefabsToProcess;
    private Queue<GameObject> _processingQueue = new Queue<GameObject>();
    private List<GameObject> _processedPrefabs = new List<GameObject>();
    private bool _isProcessing = false;
    
    private void Start()
    {
        foreach (GameObject prefab in _prefabsToProcess)
        {
            _processingQueue.Enqueue(prefab);
        }
        
        StartCoroutine(ProcessPrefabsInBackground());
    }
    
    private IEnumerator ProcessPrefabsInBackground()
    {
        while (_processingQueue.Count > 0)
        {
            _isProcessing = true;
            GameObject prefab = _processingQueue.Dequeue();
            
            // Запускаем обработку в отдельном потоке через ThreadPool
            System.Threading.ThreadPool.QueueUserWorkItem(state => 
            {
                // Производим тяжелые вычисления в отдельном потоке
                // Например, расчет навигационных данных, физических свойств и т.д.
                ProcessPrefabData(prefab);
                
                // После завершения обработки добавляем в список завершенных
                lock (_processedPrefabs)
                {
                    _processedPrefabs.Add(prefab);
                }
            });
            
            // Пауза между запуском новых задач для снижения нагрузки
            yield return new WaitForSeconds(0.1f);
        }
        
        _isProcessing = false;
    }
    
    private void ProcessPrefabData(GameObject prefab)
    {
        // Симуляция длительной обработки
        System.Threading.Thread.Sleep(500);
        
        // В реальном коде здесь выполняется тяжелая обработка данных
        // Например, расчет запеченных карт освещения, навигационных сеток
        // или других данных, не требующих прямого доступа к Unity API
    }
}

using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
 
public class AddressablePrefabLoader : MonoBehaviour
{
    [SerializeField] private string prefabAddress;
    private GameObject spawnedInstance;
    
    public async void LoadAndSpawnPrefab()
    {
        AsyncOperationHandle<GameObject> handle = Addressables.LoadAssetAsync<GameObject>(prefabAddress);
        await handle.Task;
        
        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            spawnedInstance = Instantiate(handle.Result);
        }
        else
        {
            Debug.LogError($"Failed to load prefab at address: {prefabAddress}");
        }
    }
    
    private void OnDestroy()
    {
        if (spawnedInstance != null)
        {
            Destroy(spawnedInstance);
            Addressables.Release(spawnedInstance);
        }
    }
}

[merge]
    tool = unityyamlmerge
 
[mergetool "unityyamlmerge"]
    trustExitCode = false
    cmd = 'C:/Program Files/Unity/Hub/Editor/[Version]/Editor/Data/Tools/UnityYAMLMerge.exe' merge -p "$BASE" "$REMOTE" "$LOCAL" "$MERGED"

[Serializable]
public class LocalizedPrefabVariant
{
    public string regionCode;
    public GameObject prefabVariant;
}
 
[CreateAssetMenu(fileName = "LocalizedPrefab", menuName = "Game/Localized Prefab")]
public class LocalizedPrefab : ScriptableObject
{
    public GameObject defaultPrefab;
    public List<LocalizedPrefabVariant> variants = new List<LocalizedPrefabVariant>();
    
    public GameObject GetPrefabForRegion(string region)
    {
        var variant = variants.Find(v => v.regionCode == region);
        return variant != null ? variant.prefabVariant : defaultPrefab;
    }
}

public class PrefabVariantManager : MonoBehaviour
{
    [SerializeField] private GameObject basePrefab;
    [SerializeField] private List<GameObject> prefabVariants;
    
    public GameObject GetRandomVariant()
    {
        if (prefabVariants.Count > 0)
        {
            int randomIndex = Random.Range(0, prefabVariants.Count);
            return prefabVariants[randomIndex];
        }
        return basePrefab;
    }
    
    public GameObject GetVariantByIndex(int index)
    {
        if (index >= 0 && index < prefabVariants.Count)
        {
            return prefabVariants[index];
        }
        return basePrefab;
    }
}

public class PrefabDependencyManager : MonoBehaviour
{
    [Serializable]
    public class PrefabDependency
    {
        public GameObject mainPrefab;
        public List<GameObject> dependencies;
    }
    
    [SerializeField] private List<PrefabDependency> dependencyMap;
    private Dictionary<GameObject, List<GameObject>> _dependencyLookup;
    
    private void Awake()
    {
        _dependencyLookup = new Dictionary<GameObject, List<GameObject>>();
        foreach (var dep in dependencyMap)
        {
            _dependencyLookup[dep.mainPrefab] = dep.dependencies;
        }
    }
    
    public void PreloadDependencies(GameObject prefab)
    {
        if (_dependencyLookup.TryGetValue(prefab, out List<GameObject> dependencies))
        {
            foreach (var dependency in dependencies)
            {
                // Загружаем зависимости в память или инстанцируем их
                Instantiate(dependency).SetActive(false);
            }
        }
    }
}

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
using System.Collections.Generic;
 
public class PrefabReplaceTool : EditorWindow
{
    private GameObject sourcePrefab;
    private GameObject targetPrefab;
    private bool maintainPositions = true;
    private bool maintainRotations = true;
    private bool maintainScale = true;
    
    [MenuItem("Tools/Prefab Replace Tool")]
    public static void ShowWindow()
    {
        GetWindow<PrefabReplaceTool>("Prefab Replace");
    }
    
    private void OnGUI()
    {
        GUILayout.Label("Replace Prefab Instances", EditorStyles.boldLabel);
        
        sourcePrefab = EditorGUILayout.ObjectField("Source Prefab", sourcePrefab, typeof(GameObject), false) as GameObject;
        targetPrefab = EditorGUILayout.ObjectField("Target Prefab", targetPrefab, typeof(GameObject), false) as GameObject;
        
        GUILayout.Space(10);
        GUILayout.Label("Maintain Transform", EditorStyles.boldLabel);
        maintainPositions = EditorGUILayout.Toggle("Position", maintainPositions);
        maintainRotations = EditorGUILayout.Toggle("Rotation", maintainRotations);
        maintainScale = EditorGUILayout.Toggle("Scale", maintainScale);
        
        GUILayout.Space(10);
        if (GUILayout.Button("Replace All in Scene"))
        {
            ReplaceAllPrefabsInScene();
        }
    }
    
    private void ReplaceAllPrefabsInScene()
    {
        if (sourcePrefab == null || targetPrefab == null)
        {
            EditorUtility.DisplayDialog("Error", "Both source and target prefabs must be assigned", "OK");
            return;
        }
        
        GameObject[] allObjects = GameObject.FindObjectsOfType<GameObject>();
        List<GameObject> objectsToReplace = new List<GameObject>();
        
        foreach (GameObject obj in allObjects)
        {
            if (PrefabUtility.GetPrefabAssetType(obj) == PrefabAssetType.Regular)
            {
                GameObject prefabParent = PrefabUtility.GetCorrespondingObjectFromSource(obj);
                if (prefabParent == sourcePrefab)
                {
                    objectsToReplace.Add(obj);
                }
            }
        }
        
        foreach (GameObject obj in objectsToReplace)
        {
            Vector3 position = obj.transform.position;
            Quaternion rotation = obj.transform.rotation;
            Vector3 scale = obj.transform.localScale;
            Transform parent = obj.transform.parent;
            
            GameObject newObj = PrefabUtility.InstantiatePrefab(targetPrefab) as GameObject;
            newObj.transform.SetParent(parent);
            
            if (maintainPositions) newObj.transform.position = position;
            if (maintainRotations) newObj.transform.rotation = rotation;
            if (maintainScale) newObj.transform.localScale = scale;
            
            Undo.RegisterCreatedObjectUndo(newObj, "Replace Prefab");
            Undo.DestroyObjectImmediate(obj);
        }
        
        EditorUtility.DisplayDialog("Complete", $"Replaced {objectsToReplace.Count} instances", "OK");
    }
}
#endif

// Класс для описания правил бандлинга префабов
[CreateAssetMenu(fileName = "PrefabBundlingRules", menuName = "Game/Prefab Bundling Rules")]
public class PrefabBundlingRules : ScriptableObject
{
    [Serializable]
    public class BundleDefinition
    {
        public string bundleName;
        public List<GameObject> prefabs = new List<GameObject>();
        public BundlePriority priority;
        public BundleCompressionType compression;
    }
 
    public enum BundlePriority
    {
        Critical,    // Необходимо для запуска
        Important,   // Загружать сразу после запуска
        Optional,    // Загружать по требованию
        Background   // Загружать в фоновом режиме при наличии ресурсов
    }
 
    public enum BundleCompressionType
    {
        None,        // Без сжатия - быстрая загрузка
        LZ4,         // Оптимальное соотношение скорость/размер
        LZMA         // Максимальное сжатие, медленная распаковка
    }
 
    public List<BundleDefinition> bundles = new List<BundleDefinition>();
}

#if UNITY_EDITOR
using UnityEditor;
using System.Collections.Generic;
using System.Linq;
 
public class PrefabBundleOptimizer : EditorWindow
{
    private List<GameObject> prefabsToAnalyze = new List<GameObject>();
    private Dictionary<GameObject, HashSet<Object>> dependencyMap = new Dictionary<GameObject, HashSet<Object>>();
    
    [MenuItem("Tools/Prefab Bundle Optimizer")]
    public static void ShowWindow()
    {
        GetWindow<PrefabBundleOptimizer>("Bundle Optimizer");
    }
    
    private void OnGUI()
    {
        EditorGUILayout.BeginVertical();
        
        EditorGUILayout.LabelField("Prefab Dependencies Analysis", EditorStyles.boldLabel);
        
        if (GUILayout.Button("Add Selected Prefabs"))
        {
            AddSelectedPrefabs();
        }
        
        EditorGUILayout.Space();
        
        // Отображаем список выбранных префабов
        for (int i = 0; i < prefabsToAnalyze.Count; i++)
        {
            EditorGUILayout.BeginHorizontal();
            prefabsToAnalyze[i] = EditorGUILayout.ObjectField(prefabsToAnalyze[i], typeof(GameObject), false) as GameObject;
            if (GUILayout.Button("X", GUILayout.Width(20)))
            {
                prefabsToAnalyze.RemoveAt(i);
                i--;
            }
            EditorGUILayout.EndHorizontal();
        }
        
        if (GUILayout.Button("Analyze Dependencies"))
        {
            AnalyzeDependencies();
        }
        
        if (GUILayout.Button("Generate Optimal Bundles"))
        {
            GenerateOptimalBundles();
        }
        
        EditorGUILayout.EndVertical();
    }
    
    private void AddSelectedPrefabs()
    {
        foreach (GameObject obj in Selection.gameObjects)
        {
            if (PrefabUtility.IsPartOfPrefabAsset(obj) && !prefabsToAnalyze.Contains(obj))
            {
                prefabsToAnalyze.Add(obj);
            }
        }
    }
    
    private void AnalyzeDependencies()
    {
        dependencyMap.Clear();
        
        foreach (GameObject prefab in prefabsToAnalyze)
        {
            // Находим все зависимости префаба
            Object[] dependencies = EditorUtility.CollectDependencies(new Object[] { prefab });
            dependencyMap[prefab] = new HashSet<Object>(dependencies);
            
            // Убираем сам префаб из своих зависимостей
            dependencyMap[prefab].Remove(prefab);
        }
        
        Debug.Log($"Analyzed {prefabsToAnalyze.Count} prefabs for dependencies");
    }
    
    private void GenerateOptimalBundles()
    {
        // Здесь реализуется алгоритм группировки префабов в бандлы
        // на основе их взаимных зависимостей
        // Можно использовать алгоритмы кластеризации для оптимальной группировки
        
        // После группировки создаём новый ассет с правилами бандлинга
        PrefabBundlingRules bundlingRules = CreateInstance<PrefabBundlingRules>();
        
        // Пример простой группировки по взаимным зависимостям
        Dictionary<GameObject, List<GameObject>> bundleGroups = GroupPrefabsBySharedDependencies();
        
        foreach (var group in bundleGroups)
        {
            PrefabBundlingRules.BundleDefinition bundle = new PrefabBundlingRules.BundleDefinition
            {
                bundleName = $"Bundle_{group.Key.name}",
                prefabs = group.Value,
                priority = PrefabBundlingRules.BundlePriority.Important,
                compression = PrefabBundlingRules.BundleCompressionType.LZ4
            };
            
            bundlingRules.bundles.Add(bundle);
        }
        
        // Сохраняем правила бандлинга как ассет
        AssetDatabase.CreateAsset(bundlingRules, "Assets/PrefabBundlingRules.asset");
        AssetDatabase.SaveAssets();
        
        EditorUtility.FocusProjectWindow();
        Selection.activeObject = bundlingRules;
    }
    
    private Dictionary<GameObject, List<GameObject>> GroupPrefabsBySharedDependencies()
    {
        // Упрощённый алгоритм группировки для примера
        Dictionary<GameObject, List<GameObject>> groups = new Dictionary<GameObject, List<GameObject>>();
        
        List<GameObject> processedPrefabs = new List<GameObject>();
        
        foreach (GameObject primaryPrefab in prefabsToAnalyze)
        {
            if (processedPrefabs.Contains(primaryPrefab)) continue;
            
            List<GameObject> group = new List<GameObject> { primaryPrefab };
            processedPrefabs.Add(primaryPrefab);
            
            foreach (GameObject secondaryPrefab in prefabsToAnalyze)
            {
                if (primaryPrefab == secondaryPrefab || processedPrefabs.Contains(secondaryPrefab)) continue;
                
                // Проверяем пересечение зависимостей
                var primaryDeps = dependencyMap[primaryPrefab];
                var secondaryDeps = dependencyMap[secondaryPrefab];
                
                int sharedDepsCount = primaryDeps.Intersect(secondaryDeps).Count();
                float sharedRatio = (float)sharedDepsCount / primaryDeps.Count;
                
                // Если префабы имеют более 30% общих зависимостей, группируем их
                if (sharedRatio > 0.3f)
                {
                    group.Add(secondaryPrefab);
                    processedPrefabs.Add(secondaryPrefab);
                }
            }
            
            groups[primaryPrefab] = group;
        }
        
        return groups;
    }
}
#endif

// Скрипт для автоматического тестирования префабов в CI/CD пайплайнах
using UnityEngine;
using UnityEngine.TestTools;
using NUnit.Framework;
using System.Collections;
using System.Collections.Generic;
using System.IO;
 
public class PrefabValidationTests
{
    // Список потенциальных проблем с префабами, которые нужно проверить
    enum PrefabIssue
    {
        MissingReference,      // Потерянные ссылки
        InvalidComponent,      // Отсутствие обязательных компонентов
        PerformanceWarning,    // Слишком много вложенных объектов или материалов
        ScriptErrors           // Ошибки в скриптах компонентов
    }
    
    [UnityTest]
    public IEnumerator ValidateAllPrefabs()
    {
        string[] prefabPaths = Directory.GetFiles("Assets/Prefabs", "*.prefab", SearchOption.AllDirectories);
        List<string> issues = new List<string>();
        
        foreach (string path in prefabPaths)
        {
            GameObject prefab = UnityEditor.AssetDatabase.LoadAssetAtPath<GameObject>(path);
            List<PrefabIssue> prefabIssues = ValidatePrefab(prefab);
            
            if (prefabIssues.Count > 0)
            {
                issues.Add($"Prefab {path} has issues: {string.Join(", ", prefabIssues)}");
            }
            
            // Даем возможность другим процессам выполняться
            yield return null;
        }
        
        // Если найдены проблемы, добавляем их в отчет CI и провоцируем падение теста
        Assert.IsEmpty(issues, "Found issues in prefabs:\n" + string.Join("\n", issues));
    }
    
    private List<PrefabIssue> ValidatePrefab(GameObject prefab)
    {
        List<PrefabIssue> issues = new List<PrefabIssue>();
        
        // Проверка на потерянные ссылки
        if (HasMissingReferences(prefab))
        {
            issues.Add(PrefabIssue.MissingReference);
        }
        
        // Проверка необходимых компонентов
        if (!HasRequiredComponents(prefab))
        {
            issues.Add(PrefabIssue.InvalidComponent);
        }
        
        // Проверка производительности
        if (HasPerformanceIssues(prefab))
        {
            issues.Add(PrefabIssue.PerformanceWarning);
        }
        
        // Проверка на ошибки в скриптах
        if (HasScriptErrors(prefab))
        {
            issues.Add(PrefabIssue.ScriptErrors);
        }
        
        return issues;
    }
    
    // Имитация методов проверки
    private bool HasMissingReferences(GameObject prefab) => false;
    private bool HasRequiredComponents(GameObject prefab) => true;
    private bool HasPerformanceIssues(GameObject prefab) => false;
    private bool HasScriptErrors(GameObject prefab) => false;
}