設計思路

具體玩法：音頻的高度不同，顏色不同，根據提示點擊相同顏色的音頻，點擊范圍有對應顏色加分，沒有對應顏色時，減分或者斷Combo，連續點對加分翻倍，要求顏色會隨機變化，
效果圖：

簡易特效

新建一個粒子系統，將Mode變為Sprites，
添加自己的UI圖片（本體白色，背景透明），因為看不見所以我這里用的黑底，

修改粒子的引數達到想要的效果，start color會使發出的星星隨機獲得顏色，

由于前面的全是由UI做的，粒子效果為3D的，兩個無法同時顯示，
需要Ugui demo中的方法，就是利用相機，創建Render Texture，實作混排，
1：首先在你的project視圖中右鍵點擊create Render Texture
2：然后在新建一個攝像機，對準，新攝像機需要洗掉Audio Listener，
3：給攝像機target texuure賦予Render Texture，
4:在你的canvas 畫布下面新建一個Raw Image，調整好大小，再將render texture拖入到texture中，

如果顯示出現背景，需要隱藏背景，解決方法：更改相機引數ClearFlags為Soild Color，

游戲視頻

鏈接: 游戲視頻.

源代碼

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;


public class AudioDate : MonoBehaviour
{

    private AudioSource _audio;//聲源
    private float[] samples = new float[512];//存放頻譜資料的陣列長度(64-8192)
    public Transform sc;
    public float late;
    private float time;
                            // Use this for initialization
    private void Start()
    {
        time = 0;
        _audio = GetComponent<AudioSource>();//獲取聲源組件
        _audio.clip = SceneLink.Instance.audioClip;
        _audio.Play();
    }
    private void Update()
    {
        if (!_audio.isPlaying)
        {
            SceneLink.Instance.scores = GameRule.Instance.GetScores();
            SceneManager.LoadScene(0, LoadSceneMode.Single);
        }
        time += Time.deltaTime;
        if (time >= late)
        {
            //獲取頻譜
            _audio.GetSpectrumData(samples, 0, FFTWindow.BlackmanHarris);
            /* 因為子物體排列規律為0，1，-1，2，-2，所以，需要在賦予頻率密度時也需要重新排 */
            int mapIndex;         //映射對應的頻率塊，
            if ((sc.childCount-1) % 2 == 0)   
                mapIndex = sc.childCount - 1;
            else
                mapIndex = sc.childCount - 2;
            
            for (int i = 0; i < sc.childCount ; i++)
            {

                HeightChange hg = sc.GetChild(mapIndex).GetComponent<HeightChange>();
                hg.SetHeigth(samples[i]);
                hg.SetIndex(i);
                /*賦予規律為 6，4，2，0，1，3，5， */
                if (mapIndex % 2 == 0 && mapIndex != 0)
                    mapIndex -= 2;
                else if (mapIndex == 0)
                    mapIndex ++;
                else if (mapIndex % 2 != 0)
                    mapIndex += 2;

            };
            time = 0;
        }
    }
}

引數Late決定重繪速度

GetSpectrumData決議

其中GetSpectrumData為關鍵API
以下為官方解釋
FFTWindow
enumerationLeave feedback
Description
Spectrum analysis windowing types.

Use this to reduce leakage of signals across frequency bands.

Properties
Rectangular W[n] = 1.0.
Triangle W[n] = TRI(2n/N).
Hamming W[n] = 0.54 - (0.46 * COS(n/N) ).
Hanning W[n] = 0.5 * (1.0 - COS(n/N) ).
Blackman W[n] = 0.42 - (0.5 * COS(n/N) ) + (0.08 * COS(2.0 * n/N) ).
BlackmanHarris W[n] = 0.35875 - (0.48829 * COS(1.0 * n/N)) + (0.14128 * COS(2.0 * n/N)) - (0.01168 * COS(3.0 * n/N)).

public void GetSpectrumData(float[] samples, int channel, FFTWindow window);
Parameters
samples The array to populate with audio samples. Its length must be a power of 2.
channel The channel to sample from.
window The FFTWindow type to use when sampling.
Description
Provides a block of the currently playing audio source’s spectrum data.

The array given in the samples parameter will be filled with the requested data.

Number of values (the length of the samples array provided) must be a power of 2. (ie 128/256/512 etc). Min = 64. Max = 8192. Use window to reduce leakage between frequency bins/bands. Note, the more complex window type, the better the quality, but reduced speed.

This function will use the sampling rate specified in AudioSettings.outputSampleRate, and NOT the sampling rate specified for the audio clip.

See Also: AudioSource.GetOutputData, AudioListener.GetSpectrumData, AudioListener.GetOutputData.

對于GetSpectrumData的引數：

Channel 0在這里是一個安全的選擇，因為如果我們有立體聲音頻，我們需要單獨處理2個通道的樣本資料， Channel 0包含立體聲樣本的平均值，將每2個立體聲樣本組合成1個單聲道樣本， 這使我們能夠更簡單地決定音頻中發生的事情，我們可以從眾多FFT視窗中選擇視窗并縮放我們的光譜資料， 我發現BlackmanHarris非常出色地向我們展示了每個頻率箱的不同動作，而箱之間沒有太多泄漏，

我們提供的陣列將填充到我們提供的陣列的長度，以及最近播放的音頻樣本的頻譜資料， 這意味著我們不必在GetSpectrumData之前呼叫GetOutputData， 陣列長度必須是2的冪，FFT分析對于2的冪的樣本大小最有效，Unity使用GetSpectrumData強制執行該建議，

我發現1024的頻譜陣列大小給了我們很好的粒度， 同樣，這意味著Unity引擎將采集2048個音頻樣本， 如果我們知道音頻采樣率，我們可以找到支持的頻譜資料頻率范圍，然后，使用我們的陣列大小，我們可以快速找出陣列的每個索引所代表的頻率范圍，

快速傅里葉變換（FFT）以將時域上的幅度轉換到頻域，僅回傳從FFT回傳的復數資料的相對幅度部分，雖然FFT通常在從0Hz到采樣率的整個頻率范圍內執行（在本例中讓我們使用48kHz），0Hz - 采樣率的一半（24kHz）是范圍后半部分的鏡像（24kHz-48kHz） ，該中點稱為奈奎斯特頻率（Nyquist frequency），因此，GetSpectrumData和其他一些基于FFT的助手僅回傳分析前半部分的相對幅度，這意味著執行FFT所需的音頻樣本數量是GetSpectrumData回傳的頻率倉數量的兩倍，因此，要分析的頻率粒度越高，生成該粒度所需的時間范圍就越大，如果你想要1024個頻率箱（frequency bins），每箱的粒度為23.43Hz，則需要2048個音頻樣本，

float[] samples：float型別的陣列來存放取到的頻譜資料，此陣列長度必須是2的n次方，最小64，最大8192，

int channel：采樣的聲道，一般用0，

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

public class AutoClose : MonoBehaviour
{
    public float closeTime;
    private float time;
    void Start()
    {
        time = 0;
    }

    // Update is called once per frame
    void Update()
    {
        time += Time.deltaTime;
        if(time>=closeTime)
        {
            time = 0;
            this.gameObject.SetActive(false);
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class ButtonTriggers : MonoBehaviour
{
    public string key;
    public int index;
    public ParticleSystem start;

    private Button button;


    private void Start()
    {
        button = this.GetComponent<Button>();
        button.onClick.AddListener(OnClick);
        index = this.transform.GetSiblingIndex();

    }

    public void OnClick()
    {
        if ( ColorDivider.CheckColor(GameRule.Instance.currentColor, index))
        {
            GameRule.Instance.Add(1*ScoresRatio());
            GameRule.Instance.AddCombo();
            ParticleSystem ps=Instantiate(this.start, Input.mousePosition, new Quaternion());
            ps.transform.localPosition = PositionMap(Input.mousePosition);
            ps.Play();
            Destroy(ps.gameObject,0.5f);
        }
        else
        {
            GameRule.Instance.ClearCombo();
            if(GameRule.Instance.mode==GameMode.hand)
                GameRule.Instance.Add(-1);
        }
        int ScoresRatio()
        {
            if (GameRule.Instance.Get() >= 2 && GameRule.Instance.Get() < 4 )
            {
                GameRule.Instance.SetRatio(2);
                return 2;
            }
            if (GameRule.Instance.Get() >= 4 && GameRule.Instance.Get() < 8)
            {
                GameRule.Instance.SetRatio(4);
                return 4;
            }
            if (GameRule.Instance.Get() >= 8)
            {
                GameRule.Instance.SetRatio(8);
                return 8;
            }
            GameRule.Instance.SetRatio(0);
            return 1;
        }
    }

    private Vector3 PositionMap(Vector3 vector3)
    {
        return new Vector3((vector3.x - 540f) * 10.3f / 540f, (vector3.y - 303.75f) * 5.8f / 303.75f + 0.95f, 0);
    }

    private void Update()
    {
        ColorBlock cb = button.colors;
        cb.pressedColor = UnityEngine.Color.HSVToRGB((float)GameRule.Instance.currentColor / 360, 1f, 1f);
        button.colors = cb;
        if (Input.GetKeyDown( (KeyCode)Enum.Parse(typeof(KeyCode), key)))
        {
            button.onClick.Invoke();
            cb.normalColor = UnityEngine.Color.HSVToRGB((float)GameRule.Instance.currentColor / 360, 1f, 1f);
            button.colors = cb;
        }
        if(Input.GetKeyUp((KeyCode)Enum.Parse(typeof(KeyCode), key)))
        {
            ColorBlock cb2 = button.colors;
            cb2.normalColor = new Color32(255, 255, 255, 55);
            button.colors = cb2;
        }
    }
}

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

public enum Color : int
{ 
    red=360,     //紅色0-20,312-360
    purple=295,  //紫色271-311
    blue=195,    //藍色156-270
    green=118,   //綠色70-154
    yellow=58,   //黃色52-69
    other=28
}

public class ColorDivider : MonoBehaviour
{
    public static ColorDivider Instance;
    public float[] colors;
    public CreateSlice createSlice;
    private static int length;
    void Start()
    {
        Instance = this;
        colors = new float[createSlice.sliceCount];
        length = createSlice.sliceCount / 8;
    }
    public static bool CheckColor(Color color,int index)
    {
        for(int i=index*length;i<length*(index+1);i++)
        {
            float colorValue= Instance.colors[i];
            switch (color)
            {
                case Color.red:if (colorValue > 312 && colorValue <= 360) return true; else break;
                case Color.purple: if (colorValue > 270 && colorValue <= 312) return true; else break;
                case Color.blue: if (colorValue > 156 && colorValue <= 270) return true; else break;
                case Color.green: if (colorValue > 70 && colorValue <= 156) return true; else break;
                case Color.yellow: if (colorValue > 52 && colorValue <= 70) return true; else break;
                default:break;
            }
        }
        return false;
    }
}

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using UnityEngine;

[RequireComponent(typeof(CreateSlice))]
public class CreateButtons : MonoBehaviour
{
    public Transform buttons;
    private CreateSlice createSlice;
    private float length;
    private float num;
    private void Start()
    {
        createSlice = this.GetComponent<CreateSlice>();
        num = createSlice.sliceCount / 8;
        length = 28 * num * 0.8f;

        for (int i= 0;i<buttons.childCount;i++)
        {
            buttons.GetChild(i).GetComponent<RectTransform>().sizeDelta = new Vector2(length,612.9f);
            buttons.GetChild(i).transform.localPosition = new Vector3((i-num/2)*length-56.3f,0,0);
        }
    }
}

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

public class CreateSlice : MonoBehaviour
{
    public GameObject slice;
    public int sliceCount;
    void Start()
    {
        int x=0;
        for (int i = 0; i < sliceCount; i++)
        {
            /* 子物體排列規律為0，1，-1，2，-2  */
            GameObject gameObject = Instantiate(slice, this.transform.parent.Find("SliceCenter"));
            gameObject.transform.localPosition = new Vector3(x*28,0,0);
            if (i == 0 || i % 2 == 0)
            {
                x *= -1;
                x++;
            }
            else
                x *= -1;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public enum GameMode:int
{
    easy,
    medium,
    hand
}

public class GameRule : MonoBehaviour
{
    public Color currentColor;
    public Text color;
    public Transform scores;
    [Space]
    public GameMode mode;
    public float changeTime;
    [Space]
    public Transform colorChange;
    public Text Combo;
    private int combo;

    public static GameRule Instance;

    private int score;
    private Dictionary<int, Action> dic;
    private IEnumerator conroutine;

    private void Start()
    {
        mode = SceneLink.Instance.gameMode;
        conroutine = AutoChangeColor();
        currentColor = Color.blue;
        dic = new Dictionary<int, Action>()
        {
            {(int)GameMode.easy,()=>StopAllCoroutines()},
            {(int)GameMode.medium,()=>StartCoroutine(conroutine)},
            {(int)GameMode.hand,()=>StartCoroutine(conroutine)},
         };
        if (dic.TryGetValue((int)mode, out Action action))
            action.Invoke();
        Instance = this;
        score = 0;
        time = 0;
        combo = 0;
    }
    private float time;
    private IEnumerator AutoChangeColor()
    {
        while (true)
        {
            time += Time.deltaTime;
            if(changeTime<=time)
            {
                ColorSet(RandomColor());
                time = 0;
            }
            yield return null;
        }
        Color RandomColor()
        {
            int max = 5;
            int min = 1;
            switch (UnityEngine.Random.Range(min, max))
            {
                case 1:return Color.red;
                case 2: return Color.purple;
                case 3: return Color.blue;
                case 4: return Color.green;
                case 5: return Color.yellow;
            }
            return Color.other;
        }
    }

    public void Add(int score)
    {
        this.score += score;
        scores.GetComponent<Text>().text=string.Format("scores:{0}",this.score);
    }
    public void ColorSet(Color color)
    {
        currentColor = color;
        this.color.text = string.Format("color:{0}", currentColor.ToString());
        this.color.GetComponent<Outline>().effectColor = UnityEngine.Color.HSVToRGB((float)color/360, 1f, 1f);
        colorChange.gameObject.SetActive(true);
        colorChange.GetComponent<Text>().color = UnityEngine.Color.HSVToRGB((float)color / 360, 0.47f, 1f);
        colorChange.GetComponent<Outline>().effectColor = UnityEngine.Color.HSVToRGB((float)color / 360, 1f, 1f);
    }


    #region Combo
    public void AddCombo()
    {
        if(combo==1)
            this.Combo.text = string.Format("Combo:{0}", combo);
        this.combo++;
    }
    public void ClearCombo()
    {
        combo = 0;
    }
    public int Get()
    {
        return combo;
    }
    public void SetRatio(int num)
    {
        if (num <= 0)
            this.Combo.text = string.Empty;
        else
            this.Combo.text = string.Format("Combo:{1}\nx{0}", num, combo);
    }
    public int GetScores()
    {
        return score;
    }
    #endregion
}

using System.Collections;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using UnityEngine;
using UnityEngine.UI;

public class HeightChange : MonoBehaviour
{
    //public float lateTime;
    public float speed;
    public float range;
    public float O_height;

    private int index;
    private float t;
    private float height;

    private Rect rect;
    private RectTransform rectTransform;
    private void Start()
    {
        rectTransform = this.GetComponent<RectTransform>();
        height= O_height;
        t = 0f;
        index = -1;
    }
    public void SetHeigth(float height)
    {
        this.height = height;
        t = 0f;
    }
    public void SetIndex(int i)
    {
        if(index<0)
        this.index = i;
    }
    private void Update()
    {
        if (index < 0)
            return;
        rect = this.GetComponent<RectTransform>().rect;
        if (t <= 1f)
        {
            t += speed* (1+t)/2 * Time.deltaTime;    //變速 初始速度為0.5v,最大速度為1v
        }
        else
            t = 1f;
        if(rect.height> height * range)
            Move(Mathf.Lerp(height * range, rect.height, t));
        else
            Move(Mathf.Lerp(rect.height, height * range, t));//換向
    }
    private void Move(float L)
    {
        rectTransform.sizeDelta = new Vector2(rect.width, L + O_height);
        this.transform.localPosition = new Vector3(this.transform.localPosition.x, L / 2, this.transform.localPosition.z);
        float color;
        if (L > 100)
            color = 1f;
        else
            color = L / 100;
        this.GetComponent<Image>().color = UnityEngine.Color.HSVToRGB(color, 1f, 1f);
        ColorDivider.Instance.colors[index] = color * 360;
    }
}

speed小方塊移動速度
range頻率密度放大倍數
O_height最低（原始）高度

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

public class SceneLink : MonoBehaviour
{
    public static SceneLink Instance;
    public GameMode gameMode;
    public AudioClip audioClip;
    public int scores;
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(this.gameObject);
        }
        else if (Instance != this)
        {
            Destroy(this.gameObject);
            return;
        }
    }

}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class Begin : MonoBehaviour
{
    
    void Start()
    {
        this.transform.GetComponent<Button>().onClick.AddListener(OnClick);
    }
    private void  OnClick()
    {
        SceneLink.Instance.gameMode = Mode.Instance.mode;
        SceneLink.Instance.audioClip = Music.Instance.clips[Music.GetIndex()];
        SceneManager.LoadScene(1, LoadSceneMode.Single);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Mode : MonoBehaviour
{
    public static Mode Instance;
    public Text text;
    public GameMode mode;
    void Start()
    {
        Instance = this;
        text.text = mode.ToString();
    }
    private void R()
    {
        if (mode == GameMode.hand)
        {
            mode = GameMode.easy;
        }
        else
        {
            mode++;
        }
        Show();
    }
    private void L()
    {
        if (mode == GameMode.easy)
        {
            mode = GameMode.hand;
        }
        else
        {
            mode--;
        }
        Show();
    }
    private void Show()
    {
        text.text = mode.ToString();
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Music : MonoBehaviour
{
    public static Music Instance;
    public Text text;
    public List<AudioClip> clips;
    [SerializeField]
    private int index;
    void Start()
    {
        index = 0;
        text.text = clips[0].name;
        Instance = this;
    }
    public static int  GetIndex()
    {
        return Instance.index;
    }
    private void R()
    {
        if (index==clips.Count-1)
        {
            index = 0;
        }
        else
        {
            index ++;
        }
        text.text = clips[index].name;
    }
    private void L()
    {
        if (index == 0)
        {
            index = clips.Count - 1;
        }
        else
        {
            index--;
        }
        text.text = clips[index].name;
    }

}