garden_client/Assets/Script/Manage/AudioManager.cs

using UnityEngine;

using System.Collections;
using System.Collections.Generic;

public class AudioLabel
{
    public static string ClickButton = "BtnClip";
    public static string UseSkill = "SkillClip";
    public static string Error = "ErrorClip";
    public static string Minigame_DropAward = "DropClip";
    public static string Close = "CloseClip";
    public static string PlantFlower = "FlowerClip";
    public static string Bubble = "BubbleClip";
    public static string GetCurrent = "CurrentClip";
    public static string MinigameEnd = "MiniEndClip";
}

public class AudioManager : Regist
{
    #region Config

    public static AudioManager Instance;

    public static bool AudioOn = true;
    public static bool MusicOn = true;
    public static Coroutine CoroThemeMusic;
    public static Coroutine CoroMiniGameMusic;
    public static Coroutine CoroPartyThemeMusic;

    public static AudioSource ClipAudioSource;
    public static AudioSource MinigameAudio;
    public static AudioSource GardenThemeAudio;
    public static AudioSource PartyThemeAudio;

    #endregion

    public override bool InitAtOnce()
    {
        if (base.InitAtOnce())
        {
            return true;
        }

        Instance = this;

        return false;
    }

    public override void FirstInit()
    {
        #region MusicMini

        TweenAudio tween = MinigameAudio.CreateTweenAudio(1, 2f, true, true, Curve.EaseOutQuad);

        tween.OnForwardStart += () =>
        {
            if (MusicOn)
            {
                MinigameAudio.Play();

                CoroMiniGameMusic = StartCoroutine(LoopPlayback(MinigameAudio));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (MusicOn)
            {
                StopCoroutine(CoroThemeMusic);
            }
        };

        #endregion

        #region MusicTheme

        tween = GardenThemeAudio.CreateTweenAudio(1, 2f, true, true, Curve.EaseOutQuad);

        tween.OnForwardStart += () =>
        {
            if (MusicOn)
            {
                GardenThemeAudio.Play();

                CoroThemeMusic = StartCoroutine(LoopPlayback(GardenThemeAudio));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (MusicOn)
            {
                StopCoroutine(CoroThemeMusic);
            }
        };

        #endregion

        #region MusicPartyTheme

        tween = PartyThemeAudio.CreateTweenAudio(1, 2f, true, true, Curve.EaseOutQuad);

        tween.OnForwardStart += () =>
        {
            if (MusicOn)
            {
                PartyThemeAudio.Play();

                CoroPartyThemeMusic = StartCoroutine(LoopPlayback(PartyThemeAudio));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (MusicOn)
            {
                StopCoroutine(CoroPartyThemeMusic);
            }
        };

        #endregion

        if (!MusicOn)
        {
            ResourceManager.SetActive(CanvasLabel.L_MusicOn, false);
            ResourceManager.SetActive(CanvasLabel.L_MusicOff, true);
        }

        if (!AudioOn)
        {
            ResourceManager.SetActive(CanvasLabel.L_AudioOn, false);
            ResourceManager.SetActive(CanvasLabel.L_AudioOff, true);
        }
    }

    public static bool Initd;
    public static void Init()
    {
        if (Initd)
        {
            return;
        }
        else
        {
            Initd = true;
        }
        
        ResourceManager.Get(ResourceLabel.Music, Folder.Audio, true, Instance.transform, true, ObjType.Music);
        AudioSource[] audioSources = ResourceManager.Gets<AudioSource>(ResourceLabel.Music);

        ClipAudioSource = audioSources[2];
        MinigameAudio = audioSources[1];
        GardenThemeAudio = audioSources[0];
        PartyThemeAudio = audioSources[3];
    }

    public static void LoadPrefs()
    {
        AudioOn = PlayerPrefs.GetInt(Lib.AudioPrefs, 1).ToBool();
        MusicOn = PlayerPrefs.GetInt(Lib.MusicPrefs, 1).ToBool();
    }

    public static void SetLogoVolume()
    {
        if (!AudioOn || !MusicOn)
        {
            GameObject.Find(ResourceLabel.LOGO0005).GetComponent<AudioSource>().volume = 0;
        }
    }


    public static void PlayClip(string clipName)
    {
        if (AudioOn)
        {
            AudioClip audioClip = ResourceManager.Load<AudioClip>(clipName, Folder.Audio);

            ClipAudioSource.PlayOneShot(audioClip);
        }
    }


    public void MusicSwitch()
    {
        if (MusicOn)
        {
            MusicOn = false;

            ResourceManager.SetActive(CanvasLabel.L_MusicOn, false);
            ResourceManager.SetActive(CanvasLabel.L_MusicOff, true);
            
            MinigameAudio.Pause();
            GardenThemeAudio.Pause();
            PartyThemeAudio.Pause();

            PlayerPrefs.SetInt(Lib.MusicPrefs, 0);
        }
        else
        {
            MusicOn = true;

            ResourceManager.SetActive(CanvasLabel.L_MusicOn, true);
            ResourceManager.SetActive(CanvasLabel.L_MusicOff, false);

            MinigameAudio.UnPause();
            PartyThemeAudio.UnPause();

            if (GardenThemeAudio.isPlaying)
            {
                GardenThemeAudio.UnPause();
            }
            else
            {
                GardenThemeAudio.TweenReForAudio();
            }

            PlayerPrefs.SetInt(Lib.MusicPrefs, 1);
        }
    }

    public void AudioSwitch()
    {
        if (AudioOn)
        {
            AudioOn = false;

            ResourceManager.SetActive(CanvasLabel.L_AudioOn, false);
            ResourceManager.SetActive(CanvasLabel.L_AudioOff, true);

            PlayerPrefs.SetInt(Lib.AudioPrefs, 0);
        }
        else
        {
            AudioOn = true;

            ResourceManager.SetActive(CanvasLabel.L_AudioOn, true);
            ResourceManager.SetActive(CanvasLabel.L_AudioOff, false);

            PlayerPrefs.SetInt(Lib.AudioPrefs, 1);
        }
    }


    private float LoopDelay = 1.5f;
    public IEnumerator LoopPlayback(AudioSource audioSource)
    {
        while (true)
        {
            Mark: yield return null;

            while (Manager.InBackground)
            {
                goto Mark;
            }

            while (!audioSource.enabled)
            {
                goto Mark;
            }
            
            while (audioSource.isPlaying)
            {
                goto Mark;
            }

            while (!MusicOn)
            {
                goto Mark;
            }

            yield return new WaitForSeconds(LoopDelay);

            audioSource.Play();
        }
    }
}