garden_client/Assets/Script/Manage/AudioManager.cs

using UnityEngine;

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

public enum Clip
{
    BtnClip,
    SkillClip,
    ErrorClip,
    DropClip,
    CloseClip,
    FlowerClip,
    BubbleClip,
    CurrentClip,
    MiniEndClip,
}

public class AudioManager : Regist
{
    #region 变量

    public static bool Audio = true;
    public static bool Music = true;
    public static Coroutine CoroTheme;
    public static Coroutine CoroMiniGame;
    public static Coroutine CoroPartyTheme;
    public static AudioManager Instance;

    public static AudioClip BtnClip;
    public static AudioClip SkillClip;
    public static AudioClip ErrorClip;
    public static AudioClip DropClip;
    public static AudioClip CloseClip;
    public static AudioClip FlowerClip;
    public static AudioClip BubbleClip;
    public static AudioClip CurrentClip;
    public static AudioClip MiniEndClip;
    public static AudioSource MusicClip;
    public static AudioSource MusicMini;
    public static AudioSource MusicTheme;
    public static AudioSource MusicPartyTheme;

    public static Dictionary<Clip, AudioClip> ClipDic = new Dictionary<Clip, AudioClip>();

    #endregion

    public override void InstantiatePrefabs()
    {
        BtnClip = ResourceManager.Load<AudioClip>("BtnClip", Folder.Audio);
        SkillClip = ResourceManager.Load<AudioClip>("SkillClip", Folder.Audio);
        ErrorClip = ResourceManager.Load<AudioClip>("ErrorClip", Folder.Audio);
        DropClip = ResourceManager.Load<AudioClip>("DropClip", Folder.Audio);
        CloseClip = ResourceManager.Load<AudioClip>("CloseClip", Folder.Audio);
        FlowerClip = ResourceManager.Load<AudioClip>("FlowerClip", Folder.Audio);
        BubbleClip = ResourceManager.Load<AudioClip>("BubbleClip", Folder.Audio);
        CurrentClip = ResourceManager.Load<AudioClip>("CurrentClip", Folder.Audio);
        MiniEndClip = ResourceManager.Load<AudioClip>("MiniEndClip", Folder.Audio);

        ResourceManager.Get("Music", Folder.Audio, true, transform, true, ObjType.Music);
    }

    public override void FirstInit()
    {
        Instance = this;
        
        #region ClipDic

        ClipDic.Add(Clip.BtnClip, BtnClip);
        ClipDic.Add(Clip.SkillClip, SkillClip);
        ClipDic.Add(Clip.ErrorClip, ErrorClip);
        ClipDic.Add(Clip.DropClip, DropClip);
        ClipDic.Add(Clip.CloseClip, CloseClip);
        ClipDic.Add(Clip.FlowerClip, FlowerClip);
        ClipDic.Add(Clip.BubbleClip, BubbleClip);
        ClipDic.Add(Clip.CurrentClip, CurrentClip);
        ClipDic.Add(Clip.MiniEndClip, MiniEndClip);

        #endregion

        #region MusicMini

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

        tween.OnForwardStart += () =>
        {
            if (Music)
            {
                MusicMini.Play();

                CoroMiniGame = StartCoroutine(Loop(MusicMini));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (Music)
            {
                StopCoroutine(CoroTheme);
            }
        };

        #endregion

        #region MusicTheme

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

        tween.OnForwardStart += () =>
        {
            if (Music)
            {
                MusicTheme.Play();

                CoroTheme = StartCoroutine(Loop(MusicTheme));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (Music)
            {
                StopCoroutine(CoroTheme);
            }
        };

        #endregion

        #region MusicPartyTheme

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

        tween.OnForwardStart += () =>
        {
            if (Music)
            {
                MusicPartyTheme.Play();

                CoroPartyTheme = StartCoroutine(Loop(MusicPartyTheme));
            }
        };

        tween.OnBackwardStart += () =>
        {
            if (Music)
            {
                StopCoroutine(CoroPartyTheme);
            }
        };

        #endregion

        if (!Music)
        {
            ResourceManager.SetActive(ObjectLabel.L_MusicOn, false);
            ResourceManager.SetActive(ObjectLabel.L_MusicOff, true);
        }

        if (!Audio)
        {
            ResourceManager.SetActive(ObjectLabel.L_AudioOn, false);
            ResourceManager.SetActive(ObjectLabel.L_AudioOff, true);
        }
    }

    public override void RegistReference()
    {
        AudioSource[] audioSources = ResourceManager.Gets<AudioSource>("Music");

        MusicClip = audioSources[2];
        MusicMini = audioSources[1];
        MusicTheme = audioSources[0];
        MusicPartyTheme = audioSources[3];
    }


    public static void PlayClip(Clip clip)
    {
        if (Audio)
        {
            AudioClip audioClip = ClipDic[clip];

            MusicClip.PlayOneShot(audioClip);
        }
    }


    public static void InitAudioSettingFromPlayerPrefs()
    {
        Audio = PlayerPrefs.GetInt(Lib.AudioPrefs, 1).ToBool();
        Music = PlayerPrefs.GetInt(Lib.MusicPrefs, 1).ToBool();
    }

    public static void SetLogoVolume()
    {
        if (!Audio || !Music)
        {
            GameObject.Find("LOGO0005").GetComponent<AudioSource>().volume = 0;
        }
    }


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

            ResourceManager.SetActive(ObjectLabel.L_MusicOn, false);
            ResourceManager.SetActive(ObjectLabel.L_MusicOff, true);
            
            MusicMini.Pause();
            MusicTheme.Pause();
            MusicPartyTheme.Pause();

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

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

            MusicMini.UnPause();
            MusicPartyTheme.UnPause();

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

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

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

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

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

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

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


    public IEnumerator Loop(AudioSource audioSource)
    {
        while (true)
        {
            Mark: yield return null;

            while (Manager.Background)
            {
                goto Mark;
            }

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

            while (!Music)
            {
                goto Mark;
            }

            yield return new WaitForSeconds(1.5f);

            audioSource.Play();
        }
    }
}