Звук в Unity: Рандомизация с Audio Random Container

using UnityEngine;
 
public class FootstepController : MonoBehaviour
{
    private AudioSource audioSource;
 
    void Start()
    {
        audioSource = GetComponent<AudioSource>();
    }
 
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            if (!audioSource.isPlaying)
            {
                audioSource.Play();
            }
            else
            {
                // Если звук уже играет, но мы хотим запустить новый
                audioSource.PlayOneShot(audioSource.clip);
            }
        }
    }
}

using UnityEngine;
 
public class CharacterAudio : MonoBehaviour
{
    public AudioSource footstepSource;
    
    // Этот метод будет вызываться из Animation Event
    public void PlayFootstep()
    {
        if (footstepSource != null && !footstepSource.isPlaying)
        {
            footstepSource.Play();
        }
    }
}

using UnityEngine;
 
public class SurfaceFootstepSystem : MonoBehaviour
{
    public AudioSource footstepSource;
    public AudioContainer metalFootsteps;
    public AudioContainer woodFootsteps;
    public AudioContainer grassFootsteps;
    
    private string currentSurface = "Concrete"; // По умолчанию
    
    void OnControllerColliderHit(ControllerColliderHit hit)
    {
        // Определяем тип поверхности по тегу
        if (hit.gameObject.CompareTag("Metal"))
            currentSurface = "Metal";
        else if (hit.gameObject.CompareTag("Wood"))
            currentSurface = "Wood";
        else if (hit.gameObject.CompareTag("Grass"))
            currentSurface = "Grass";
        else
            currentSurface = "Concrete";
    }
    
    // Вызывается из Animation Event
    public void PlayFootstep()
    {
        // Выбираем правильный контейнер в зависимости от поверхности
        switch (currentSurface)
        {
            case "Metal":
                footstepSource.clip = metalFootsteps;
                break;
            case "Wood":
                footstepSource.clip = woodFootsteps;
                break;
            case "Grass":
                footstepSource.clip = grassFootsteps;
                break;
            default:
                // Используем бетон как стандартный вариант
                break;
        }
        
        footstepSource.Play();
    }
}

// Скрипт для мониторинга количества активных аудиоканалов
using UnityEngine;
 
public class AudioMonitor : MonoBehaviour
{
    private AudioSource[] allSources;
    private int activeChannelsCount;
 
    void Update()
    {
        allSources = FindObjectsOfType<AudioSource>();
        activeChannelsCount = 0;
        
        foreach (AudioSource source in allSources)
        {
            if (source.isPlaying)
                activeChannelsCount++;
        }
        
        Debug.Log($"Активных аудиоканалов: {activeChannelsCount}");
    }
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class AudioPreloader : MonoBehaviour
{
    public List<AudioClip> highPriorityClips = new List<AudioClip>();
    public List<AudioClip> mediumPriorityClips = new List<AudioClip>();
    public List<AudioClip> lowPriorityClips = new List<AudioClip>();
    
    void Start()
    {
        StartCoroutine(LoadAudioSequentially());
    }
    
    IEnumerator LoadAudioSequentially()
    {
        // Сразу загружаем высокоприоритетные звуки
        foreach (AudioClip clip in highPriorityClips)
        {
            // Здесь может быть код для предварительной загрузки клипа
            // В большинстве случаев просто обращение к клипу заставляет Unity загрузить его
            float length = clip.length;
            yield return null; // Даём один кадр для обработки
        }
        
        // Загружаем среднеприоритетные звуки с паузами
        foreach (AudioClip clip in mediumPriorityClips)
        {
            float length = clip.length;
            yield return new WaitForSeconds(0.1f); // Небольшая пауза между загрузками
        }
        
        // Низкоприоритетные звуки загружаем в последнюю очередь
        foreach (AudioClip clip in lowPriorityClips)
        {
            float length = clip.length;
            yield return new WaitForSeconds(0.2f);
        }
    }
}

using UnityEngine;
using System.Collections.Generic;
 
[System.Serializable]
public class DialogueVoiceLine
{
    public AudioClip clip;
    public float friendlyWeight = 1.0f; // Вес для дружественных отношений
    public float hostileWeight = 1.0f;   // Вес для враждебных отношений
    public float morningWeight = 1.0f;   // Вес для утреннего времени
    public float eveningWeight = 1.0f;   // Вес для вечернего времени
}
 
public class ContextualDialoguePlayer : MonoBehaviour
{
    public List<DialogueVoiceLine> greetingLines = new List<DialogueVoiceLine>();
    public AudioSource dialogueSource;
    
    // Параметры контекста (могут меняться в игре)
    [Range(-1f, 1f)] public float playerRelationship = 0f; // От враждебного (-1) до дружественного (1)
    [Range(0f, 24f)] public float timeOfDay = 12f; // Время суток в часах
    
    public void PlayGreeting()
    {
        if (greetingLines.Count == 0 || dialogueSource == null)
            return;
            
        // Рассчитываем веса для каждой реплики на основе контекста
        List<float> weights = new List<float>();
        float totalWeight = 0f;
        
        foreach (DialogueVoiceLine line in greetingLines)
        {
            // Определяем отношение (дружественное или враждебное)
            float relationshipFactor = (playerRelationship >= 0) ? 
                line.friendlyWeight * playerRelationship :
                line.hostileWeight * (-playerRelationship);
                
            // Определяем время суток (утро или вечер)
            float timeFactor = (timeOfDay >= 6 && timeOfDay <= 18) ?
                line.morningWeight * (1 - Mathf.Abs((timeOfDay - 12) / 6)) :
                line.eveningWeight * (1 - (Mathf.Min(timeOfDay, 24 - timeOfDay) / 6));
                
            // Комбинируем факторы
            float weight = relationshipFactor * timeFactor;
            
            weights.Add(weight);
            totalWeight += weight;
        }
        
        // Выбираем реплику на основе весов
        float randomValue = Random.Range(0, totalWeight);
        float cumulativeWeight = 0f;
        
        for (int i = 0; i < weights.Count; i++)
        {
            cumulativeWeight += weights[i];
            if (randomValue <= cumulativeWeight)
            {
                dialogueSource.clip = greetingLines[i].clip;
                dialogueSource.Play();
                break;
            }
        }
    }
}

using UnityEngine;
 
public class ModularWeaponAudio : MonoBehaviour
{
    public AudioSource mainSource;
    public AudioSource mechanicalSource;
    public AudioSource echoSource;
    public AudioSource shellSource;
    
    // Различные Audio Random Container для разных компонентов звука
    public AudioClip mainShotContainer;
    public AudioClip mechanicalActionContainer;
    public AudioClip echoContainer;
    public AudioClip shellDropContainer;
    
    public float echoDelay = 0.1f;
    public float shellDropDelay = 0.3f;
    
    public void Fire()
    {
        // Основной звук выстрела
        mainSource.clip = mainShotContainer;
        mainSource.Play();
        
        // Механический звук оружия
        mechanicalSource.clip = mechanicalActionContainer;
        mechanicalSource.Play();
        
        // Запускаем эхо и звук падения гильзы с задержкой
        Invoke("PlayEcho", echoDelay);
        Invoke("PlayShellDrop", shellDropDelay);
    }
    
    private void PlayEcho()
    {
        echoSource.clip = echoContainer;
        echoSource.Play();
    }
    
    private void PlayShellDrop()
    {
        shellSource.clip = shellDropContainer;
        shellSource.Play();
    }
}

using UnityEngine;
using UnityEngine.Audio;
 
public class DynamicAudioEffects : MonoBehaviour
{
    public AudioMixer audioMixer;
    public AudioSource environmentSource;
    
    // Имена параметров, настроенных в Audio Mixer
    private const string ReverbAmountParam = "ReverbAmount";
    private const string LowPassParam = "LowPassCutoff";
    
    public void EnterCave()
    {
        // Увеличиваем реверберацию для создания эффекта пещеры
        audioMixer.SetFloat(ReverbAmountParam, 0.8f);
    }
    
    public void ExitCave()
    {
        // Уменьшаем реверберацию на открытом пространстве
        audioMixer.SetFloat(ReverbAmountParam, 0.1f);
    }
    
    public void EnterUnderwater()
    {
        // Применяем низкочастотный фильтр для эффекта погружения под воду
        audioMixer.SetFloat(LowPassParam, 500f);
    }
    
    public void ExitUnderwater()
    {
        // Убираем низкочастотный фильтр
        audioMixer.SetFloat(LowPassParam, 22000f);
    }
}

using UnityEngine;
using System.Collections.Generic;
using System.IO;
 
public class AudioDebugger : MonoBehaviour
{
    [System.Serializable]
    public class AudioPlaybackRecord
    {
        public string clipName;
        public float volume;
        public float pitch;
        public float timestamp;
    }
    
    public bool enableLogging = true;
    public int maxRecords = 1000;
    
    private List<AudioPlaybackRecord> playbackHistory = new List<AudioPlaybackRecord>();
    private AudioSource[] trackedSources;
    
    void Start()
    {
        trackedSources = FindObjectsOfType<AudioSource>();
    }
    
    void Update()
    {
        if (!enableLogging) return;
        
        foreach (AudioSource source in trackedSources)
        {
            if (source.isPlaying && source.clip != null && 
                source.clip.loadState == AudioDataLoadState.Loaded)
            {
                // Создаём запись только в момент начала воспроизведения
                if (source.time < Time.deltaTime)
                {
                    RecordPlayback(source);
                }
            }
        }
    }
    
    void RecordPlayback(AudioSource source)
    {
        AudioPlaybackRecord record = new AudioPlaybackRecord
        {
            clipName = source.clip.name,
            volume = source.volume,
            pitch = source.pitch,
            timestamp = Time.time
        };
        
        playbackHistory.Add(record);
        
        // Ограничиваем размер истории
        if (playbackHistory.Count > maxRecords)
        {
            playbackHistory.RemoveAt(0);
        }
    }
    
    public void SaveDebugLogToFile()
    {
        string path = Path.Combine(Application.persistentDataPath, "audio_debug_log.txt");
        using (StreamWriter writer = new StreamWriter(path))
        {
            writer.WriteLine("=== Audio Playback History ===");
            foreach (var record in playbackHistory)
            {
                writer.WriteLine($"Time: {record.timestamp:F2}s | Clip: {record.clipName} | " +
                                 $"Volume: {record.volume:F2} | Pitch: {record.pitch:F2}");
            }
        }
        
        Debug.Log($"Audio debug log saved to: {path}");
    }
}

// Пример контроллера оружия с комбинированными звуками
public class WeaponAudioController : MonoBehaviour
{
    [SerializeField] private AudioSource mainShotSource;
    [SerializeField] private AudioSource mechanicalSource;
    [SerializeField] private AudioSource environmentSource; // для эха и реверберации
    
    [SerializeField] private bool isIndoors = false;
    
    public void Fire()
    {
        // Основной звук выстрела
        mainShotSource.Play();
        
        // Механические звуки
        mechanicalSource.Play();
        
        // Эхо в зависимости от окружения
        if (!isIndoors)
        {
            // Отложенное воспроизведение эха для открытых пространств
            StartCoroutine(PlayDelayedEnvironmentalSound(0.1f));
        }
    }
    
    private IEnumerator PlayDelayedEnvironmentalSound(float delay)
    {
        yield return new WaitForSeconds(delay);
        environmentSource.Play();
    }
}

public class ForestAmbientController : MonoBehaviour
{
    [SerializeField] private AudioSource leavesSource;
    [SerializeField] private AudioSource birdsSource;
    [SerializeField] private AudioSource insectsSource;
    [SerializeField] private AudioSource randomEventsSource;
    
    [Range(0f, 1f)] public float dayNightCycle = 0.5f; // 0 - ночь, 1 - день
    [Range(0f, 1f)] public float weatherIntensity = 0f; // 0 - ясно, 1 - шторм
    
    private void Update()
    {
        // Птицы активнее днём и тише в плохую погоду
        birdsSource.volume = Mathf.Clamp(dayNightCycle * (1 - weatherIntensity), 0.1f, 1f);
        
        // Насекомые активны вечером и ночью, тише в плохую погоду
        insectsSource.volume = Mathf.Clamp((1 - dayNightCycle) * (1 - weatherIntensity), 0, 0.8f);
        
        // Шелест листвы усиливается с ухудшением погоды
        leavesSource.volume = Mathf.Lerp(0.2f, 0.8f, weatherIntensity);
        
        // Случайные звуки (падающие ветки) чаще в плохую погоду
        if (randomEventsSource.GetComponent<AudioRandomContainerPlayer>() != null)
        {
            float interval = Mathf.Lerp(60f, 15f, weatherIntensity);
            randomEventsSource.GetComponent<AudioRandomContainerPlayer>().SetAverageInterval(interval);
        }
    }
}

public class SoundPoolManager : MonoBehaviour
{
    [System.Serializable]
    public class SoundGroup
    {
        public string groupName;
        public int maxConcurrentSounds = 3;
        private List<AudioSource> activeSources = new List<AudioSource>();
        
        public bool CanPlay(AudioSource source)
        {
            // Удаляем из списка источники, которые больше не воспроизводятся
            activeSources.RemoveAll(s => s == null || !s.isPlaying);
            
            // Проверяем, не превышен ли лимит
            if (activeSources.Count < maxConcurrentSounds)
            {
                activeSources.Add(source);
                return true;
            }
            
            return false;
        }
    }
    
    public List<SoundGroup> soundGroups = new List<SoundGroup>();
    private Dictionary<string, SoundGroup> groupLookup = new Dictionary<string, SoundGroup>();
    
    private void Awake()
    {
        foreach (var group in soundGroups)
        {
            groupLookup[group.groupName] = group;
        }
    }
    
    public bool CanPlaySound(string groupName, AudioSource source)
    {
        if (groupLookup.TryGetValue(groupName, out SoundGroup group))
        {
            return group.CanPlay(source);
        }
        
        // Если группа не найдена, разрешаем воспроизведение
        return true;
    }
}

public class EnvironmentTransitionController : MonoBehaviour
{
    [SerializeField] private AudioSource forestSource;
    [SerializeField] private AudioSource caveSource;
    
    [Range(0f, 1f)] public float transitionProgress = 0f; // 0 - лес, 1 - пещера
    [SerializeField] private float transitionSpeed = 0.5f; // скорость перехода
    
    private float targetProgress = 0f;
    
    private void Update()
    {
        // Плавно изменяем прогресс перехода
        transitionProgress = Mathf.MoveTowards(transitionProgress, targetProgress, transitionSpeed * Time.deltaTime);
        
        // Обновляем громкость источников
        forestSource.volume = 1f - transitionProgress;
        caveSource.volume = transitionProgress;
    }
    
    // Вызывается триггерами при входе в пещеру
    public void EnterCave()
    {
        targetProgress = 1f;
    }
    
    // Вызывается триггерами при выходе из пещеры
    public void ExitCave()
    {
        targetProgress = 0f;
    }
}

public class NPCDialogueSystem : MonoBehaviour
{
    [SerializeField] private AudioSource dialogueSource;
    
    // Контейнеры для разных типов диалогов и контекстов
    [SerializeField] private AudioClip greetingsFriendly;
    [SerializeField] private AudioClip greetingsNeutral;
    [SerializeField] private AudioClip greetingsHostile;
    [SerializeField] private AudioClip farewellContainer;
    [SerializeField] private AudioClip combatTauntsContainer;
    
    [SerializeField] private float playerReputation = 50f; // 0-100, репутация игрока
    
    public void Greet()
    {
        // Выбираем контейнер приветствий в зависимости от репутации
        if (playerReputation >= 75f)
        {
            dialogueSource.clip = greetingsFriendly;
        }
        else if (playerReputation >= 30f)
        {
            dialogueSource.clip = greetingsNeutral;
        }
        else
        {
            dialogueSource.clip = greetingsHostile;
        }
        
        dialogueSource.Play();
    }
    
    public void Farewell()
    {
        dialogueSource.clip = farewellContainer;
        dialogueSource.Play();
    }
    
    public void CombatTaunt()
    {
        dialogueSource.clip = combatTauntsContainer;
        dialogueSource.Play();
    }
}

public class AdaptiveMusicSystem : MonoBehaviour
{
    [SerializeField] private AudioSource rhythmSource;    // Базовый ритм
    [SerializeField] private AudioSource melodySource;    // Мелодические элементы
    [SerializeField] private AudioSource accentSource;    // Акценты и напряжение
    
    [Range(0f, 1f)] public float combatIntensity = 0f;    // Интенсивность боя
    
    void Update()
    {
        // Базовый ритм всегда играет, но может стать чуть громче в бою
        rhythmSource.volume = Mathf.Lerp(0.7f, 0.9f, combatIntensity);
        
        // Мелодия усиливается с нарастанием боя
        melodySource.volume = Mathf.Lerp(0.2f, 0.8f, combatIntensity);
        
        // Акценты почти не слышны в спокойном состоянии 
        // и становятся заметными в напряжённых моментах
        accentSource.volume = Mathf.Pow(combatIntensity, 2f) * 0.9f;
    }
    
    public void OnEnemyDetected()
    {
        // Плавно увеличиваем интенсивность при обнаружении врага
        StartCoroutine(FadeCombatIntensity(0.6f, 2f));
    }
    
    public void OnPlayerTakeDamage()
    {
        // Резко увеличиваем интенсивность при получении урона
        StartCoroutine(FadeCombatIntensity(1f, 0.5f));
    }
    
    public void OnCombatEnd()
    {
        // Плавно снижаем интенсивность при завершении боя
        StartCoroutine(FadeCombatIntensity(0f, 4f));
    }
    
    private IEnumerator FadeCombatIntensity(float target, float duration)
    {
        float startIntensity = combatIntensity;
        float elapsedTime = 0f;
        
        while (elapsedTime < duration)
        {
            elapsedTime += Time.deltaTime;
            combatIntensity = Mathf.Lerp(startIntensity, target, elapsedTime / duration);
            yield return null;
        }
        
        combatIntensity = target;
    }
}

public class HorizontalMusicSequencer : MonoBehaviour
{
    [System.Serializable]
    public class MusicSection
    {
        public string sectionName;
        public AudioClip musicContainer;
        public float crossfadeDuration = 2f;
        public bool loopable = true;
    }
    
    [SerializeField] private AudioSource sourceA;
    [SerializeField] private AudioSource sourceB;
    [SerializeField] private List<MusicSection> musicSections = new List<MusicSection>();
    
    private AudioSource activeSource;
    private AudioSource inactiveSource;
    private int currentSectionIndex = -1;
    
    void Start()
    {
        activeSource = sourceA;
        inactiveSource = sourceB;
        
        if (musicSections.Count > 0)
        {
            PlaySection(0);
        }
    }
    
    public void PlaySection(int index)
    {
        if (index < 0 || index >= musicSections.Count || index == currentSectionIndex)
            return;
        
        MusicSection newSection = musicSections[index];
        currentSectionIndex = index;
        
        // Подготавливаем неактивный источник для следующей секции
        inactiveSource.clip = newSection.musicContainer;
        inactiveSource.loop = newSection.loopable;
        inactiveSource.volume = 0f;
        inactiveSource.Play();
        
        // Запускаем кроссфейд
        StartCoroutine(CrossfadeToNewSection(newSection.crossfadeDuration));
    }
    
    private IEnumerator CrossfadeToNewSection(float duration)
    {
        float elapsedTime = 0f;
        
        while (elapsedTime < duration)
        {
            elapsedTime += Time.deltaTime;
            float t = elapsedTime / duration;
            
            activeSource.volume = 1f - t;
            inactiveSource.volume = t;
            
            yield return null;
        }
        
        // Завершаем кроссфейд и переключаем источники
        activeSource.Stop();
        
        AudioSource temp = activeSource;
        activeSource = inactiveSource;
        inactiveSource = temp;
    }
    
    // Метод для последовательного перехода к следующей секции
    public void PlayNextSection()
    {
        int nextIndex = (currentSectionIndex + 1) % musicSections.Count;
        PlaySection(nextIndex);
    }
}

public class DynamicAudioLoader : MonoBehaviour
{
    [System.Serializable]
    public class AudioZone
    {
        public string zoneName;
        public List<AudioClip> requiredAudioClips = new List<AudioClip>();
        public List<AudioSource> zoneAudioSources = new List<AudioSource>();
    }
    
    [SerializeField] private List<AudioZone> audioZones = new List<AudioZone>();
    [SerializeField] private string currentZone = "";
    [SerializeField] private string previousZone = "";
    
    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("AudioZoneTrigger"))
        {
            string newZone = other.GetComponent<AudioZoneTrigger>().zoneName;
            SwitchToZone(newZone);
        }
    }
    
    void SwitchToZone(string newZone)
    {
        if (newZone == currentZone)
            return;
            
        previousZone = currentZone;
        currentZone = newZone;
        
        StartCoroutine(LoadZoneAudio(newZone));
    }
    
    IEnumerator LoadZoneAudio(string zoneName)
    {
        AudioZone newZone = audioZones.Find(z => z.zoneName == zoneName);
        if (newZone == null)
            yield break;
            
        // Активируем источники звука для новой зоны
        foreach (AudioSource source in newZone.zoneAudioSources)
        {
            source.gameObject.SetActive(true);
        }
        
        // Загружаем требуемые клипы
        foreach (AudioClip clip in newZone.requiredAudioClips)
        {
            if (clip is AudioContainerClip container)
            {
                // Для загрузки Audio Container
                // Здесь может потребоваться специальная логика в зависимости 
                // от реализации контейнера
            }
            else
            {
                // Стандартные клипы загружаются автоматически при первом обращении
                float length = clip.length; // Просто обращение к клипу инициирует загрузку
            }
            
            yield return null; // Даём движку обработать каждую загрузку
        }
        
        // Деактивируем источники звука предыдущей зоны
        if (!string.IsNullOrEmpty(previousZone))
        {
            AudioZone prevZone = audioZones.Find(z => z.zoneName == previousZone);
            if (prevZone != null)
            {
                foreach (AudioSource source in prevZone.zoneAudioSources)
                {
                    source.gameObject.SetActive(false);
                }
                
                // Выгружаем неиспользуемые ресурсы
                if (Application.isPlaying)
                {
                    Resources.UnloadUnusedAssets();
                }
            }
        }
    }
}

public class AudioStreamer : MonoBehaviour
{
    [SerializeField] private List<AudioClip> streamedClips = new List<AudioClip>();
    [SerializeField] private AudioSource streamingSource;
    
    void Awake()
    {
        foreach (AudioClip clip in streamedClips)
        {
            // В идеале эта конфигурация должна быть настроена 
            // в импортере ассетов, но для справки:
            AudioImporter importer = clip as AudioImporter;
            if (importer != null)
            {
                SerializedObject serializedImporter = new SerializedObject(importer);
                serializedImporter.FindProperty("m_LoadType").intValue = 2; // Streaming
                serializedImporter.ApplyModifiedProperties();
            }
        }
    }
    
    public void PlayStreamedSound(int index)
    {
        if (index >= 0 && index < streamedClips.Count)
        {
            streamingSource.clip = streamedClips[index];
            streamingSource.Play();
        }
    }
}

public class VehicleEngineAudio : MonoBehaviour
{
    [SerializeField] private AudioSource idleSource;         // Звук холостого хода
    [SerializeField] private AudioSource lowRPMSource;       // Низкие обороты
    [SerializeField] private AudioSource mediumRPMSource;    // Средние обороты
    [SerializeField] private AudioSource highRPMSource;      // Высокие обороты
    
    [SerializeField] private float maxRPM = 8000f;
    [SerializeField] private float currentRPM = 1000f;
    
    void Update()
    {
        // Нормализуем обороты в диапазон 0-1
        float normalizedRPM = Mathf.Clamp01(currentRPM / maxRPM);
        
        // Настраиваем кривые громкости для разных диапазонов оборотов
        idleSource.volume = Mathf.Clamp01(1.0f - normalizedRPM * 2.0f);
        lowRPMSource.volume = GetBellCurve(normalizedRPM, 0.2f, 0.3f);
        mediumRPMSource.volume = GetBellCurve(normalizedRPM, 0.5f, 0.3f);
        highRPMSource.volume = Mathf.Clamp01(normalizedRPM * 2.0f - 1.0f);
        
        // Эффект изменения высоты звука в зависимости от оборотов
        float pitchFactor = Mathf.Lerp(0.8f, 1.2f, normalizedRPM);
        
        lowRPMSource.pitch = pitchFactor;
        mediumRPMSource.pitch = pitchFactor;
        highRPMSource.pitch = pitchFactor;
    }
    
    // Функция "колокол" для плавного перехода между аудиослоями
    private float GetBellCurve(float x, float peak, float width)
    {
        return Mathf.Exp(-((x - peak) * (x - peak)) / (2f * width * width));
    }
    
    public void SetRPM(float rpm)
    {
        currentRPM = rpm;
    }
}

public class WeatherSoundSystem : MonoBehaviour
{
    [SerializeField] private AudioSource rainLightSource;
    [SerializeField] private AudioSource rainHeavySource;
    [SerializeField] private AudioSource windSource;
    [SerializeField] private AudioSource thunderSource;
    
    [Range(0f, 1f)] public float rainIntensity = 0f;
    [Range(0f, 1f)] public float windIntensity = 0f;
    [Range(0f, 1f)] public float stormIntensity = 0f;
    
    private float thunderTimer = 0f;
    private float nextThunderTime = 15f;
    
    private void Update()
    {
        // Обновляем громкость на основе интенсивности
        rainLightSource.volume = Mathf.Clamp01(rainIntensity * 2.0f - stormIntensity);
        rainHeavySource.volume = Mathf.Clamp01(rainIntensity * stormIntensity * 2.0f);
        windSource.volume = Mathf.Clamp01(windIntensity);
        
        // Обрабатываем таймер для грома
        if (stormIntensity > 0.4f)
        {
            thunderTimer += Time.deltaTime;
            if (thunderTimer >= nextThunderTime)
            {
                PlayThunder();
                // Следующий гром через случайный интервал
                nextThunderTime = Mathf.Lerp(25f, 5f, stormIntensity) * (1f + Random.Range(-0.3f, 0.3f));
                thunderTimer = 0f;
            }
        }
    }
    
    private void PlayThunder()
    {
        thunderSource.Play();
    }
    
    public void TransitionToRainy(float duration = 10f)
    {
        StartCoroutine(TransitionWeather(0.8f, 0.3f, 0f, duration));
    }
    
    public void TransitionToStormy(float duration = 15f)
    {
        StartCoroutine(TransitionWeather(1f, 0.7f, 0.9f, duration));
    }
    
    public void TransitionToClear(float duration = 20f)
    {
        StartCoroutine(TransitionWeather(0f, 0.1f, 0f, duration));
    }
    
    private IEnumerator TransitionWeather(float targetRain, float targetWind, float targetStorm, float duration)
    {
        float startRain = rainIntensity;
        float startWind = windIntensity;
        float startStorm = stormIntensity;
        float elapsed = 0f;
        
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            float t = elapsed / duration;
            
            rainIntensity = Mathf.Lerp(startRain, targetRain, t);
            windIntensity = Mathf.Lerp(startWind, targetWind, t);
            stormIntensity = Mathf.Lerp(startStorm, targetStorm, t);
            
            yield return null;
        }
        
        rainIntensity = targetRain;
        windIntensity = targetWind;
        stormIntensity = targetStorm;
    }
}

public class ImpactSoundController : MonoBehaviour
{
    [SerializeField] private AudioSource impactSource;
    [SerializeField] private AudioClip woodImpactContainer;
    [SerializeField] private AudioClip metalImpactContainer;
    [SerializeField] private AudioClip stoneImpactContainer;
    
    [SerializeField] private float minImpactForce = 1f;
    [SerializeField] private float maxImpactForce = 10f;
    [SerializeField] private string currentMaterial = "Wood";
    
    private Rigidbody rb;
    
    private void Start()
    {
        rb = GetComponent<Rigidbody>();
    }
    
    private void OnCollisionEnter(Collision collision)
    {
        // Измеряем силу удара
        float impactForce = collision.impulse.magnitude;
        
        if (impactForce >= minImpactForce)
        {
            // Определяем тип материала для звука
            if (collision.gameObject.CompareTag("Metal"))
                currentMaterial = "Metal";
            else if (collision.gameObject.CompareTag("Stone"))
                currentMaterial = "Stone";
            else
                currentMaterial = "Wood";
                
            // Выбираем соответствующий контейнер
            switch (currentMaterial)
            {
                case "Metal":
                    impactSource.clip = metalImpactContainer;
                    break;
                case "Stone":
                    impactSource.clip = stoneImpactContainer;
                    break;
                default:
                    impactSource.clip = woodImpactContainer;
                    break;
            }
            
            // Нормализуем силу удара для громкости
            float normalizedForce = Mathf.Clamp01((impactForce - minImpactForce) / (maxImpactForce - minImpactForce));
            impactSource.volume = Mathf.Lerp(0.3f, 1.0f, normalizedForce);
            
            // Немного варьируем высоту в зависимости от силы удара
            impactSource.pitch = Mathf.Lerp(0.9f, 1.1f, normalizedForce);
            
            impactSource.Play();
        }
    }
}

public class MobileAudioOptimizer : MonoBehaviour
{
    [System.Serializable]
    public class SoundCategory
    {
        public string name;
        public List<AudioSource> sources = new List<AudioSource>();
        public int maxSimultaneousSounds = 3;
        public int priority = 1; // Чем выше, тем важнее
    }
    
    [SerializeField] private List<SoundCategory> categories = new List<SoundCategory>();
    [SerializeField] private int maxTotalSounds = 12;
    [SerializeField] private bool isMobilePlatform = false;
    
    private List<AudioSource> currentlyPlaying = new List<AudioSource>();
    
    private void Awake()
    {
        #if UNITY_ANDROID || UNITY_IOS
        isMobilePlatform = true;
        #endif
        
        // На мобильных устройствах снижаем лимиты
        if (isMobilePlatform)
        {
            maxTotalSounds = 8;
            foreach (var category in categories)
            {
                category.maxSimultaneousSounds = Mathf.Max(1, category.maxSimultaneousSounds / 2);
            }
        }
    }
    
    public bool RequestPlayback(AudioSource source)
    {
        // Удаляем из списка те источники, которые уже не играют
        currentlyPlaying.RemoveAll(s => s == null || !s.isPlaying);
        
        // Находим категорию для данного источника
        SoundCategory sourceCategory = null;
        foreach (var category in categories)
        {
            if (category.sources.Contains(source))
            {
                sourceCategory = category;
                break;
            }
        }
        
        if (sourceCategory == null)
            return true; // Не управляемый источник, разрешаем воспроизведение
            
        // Считаем, сколько звуков этой категории уже играет
        int categoryCount = 0;
        foreach (var playingSource in currentlyPlaying)
        {
            if (sourceCategory.sources.Contains(playingSource))
                categoryCount++;
        }
        
        // Проверяем, не превышен ли лимит для категории
        if (categoryCount >= sourceCategory.maxSimultaneousSounds)
            return false;
            
        // Проверяем общий лимит
        if (currentlyPlaying.Count >= maxTotalSounds)
        {
            // Если достигнут общий лимит, можно остановить звук с меньшим приоритетом
            AudioSource lowestPrioritySource = FindLowestPrioritySource(sourceCategory.priority);
            if (lowestPrioritySource != null)
            {
                lowestPrioritySource.Stop();
                currentlyPlaying.Remove(lowestPrioritySource);
            }
            else
            {
                return false; // Нет звуков с меньшим приоритетом
            }
        }
        
        currentlyPlaying.Add(source);
        return true;
    }
    
    private AudioSource FindLowestPrioritySource(int minPriority)
    {
        AudioSource result = null;
        int lowestPriority = minPriority;
        
        foreach (var source in currentlyPlaying)
        {
            // Находим категорию для этого источника
            foreach (var category in categories)
            {
                if (category.sources.Contains(source) && category.priority < lowestPriority)
                {
                    lowestPriority = category.priority;
                    result = source;
                }
            }
        }
        
        return result;
    }
}

public class BasicRandomSound : MonoBehaviour
{
    public AudioClip[] sounds;
    public AudioSource source;
    
    public void PlayRandomSound()
    {
        if (sounds.Length == 0) return;
        
        int randomIndex = Random.Range(0, sounds.Length);
        source.clip = sounds[randomIndex];
        source.Play();
    }
}