Unity3D_(游戲)甜品消消樂03_游戲UI設計


 

 

甜品消消樂01_游戲基礎界面  傳送門

甜品消消樂02_游戲核心算法  傳送門

甜品消消樂03_游戲UI設計     傳送門

 

 

  (源碼在文章最下面~) 

 

 

實現過程

 

游戲界面UI

 

 

 

 

分數與時間的UI顯示

 

  有關游戲UI顯示的內容

    public Text timeText;

    private float gameTime=60;

 

  判斷游戲是否失敗

    private bool gameOver;

 

  游戲刷新的時候對游戲是否結束進行判斷

void Update () {
        if (gameOver)
        {
            return;
        }
        gameTime -= Time.deltaTime;
        if (gameTime <= 0)
        {
            gameTime = 0;
            //顯示我們的失敗面板
            //播放失敗面板的動畫
            gameOver = true;
            return;
        }
        timeText.text = gameTime.ToString("0");
    }

 

  游戲結束時,無法再對甜甜圈進行點擊

  so,當gameOver = false 時對鼠標按鍵進行return

 public void PressSweet(GameSweet sweet)
    {
        if (gameOver)
        {
            return;
        }
        pressedSweet = sweet;
    }

    public void EnterSweet(GameSweet sweet)
    {
        if (gameOver)
        {
            return;
        }
        enteredSweet = sweet;
    }

    public void ReleaseSweet()
    {
        if (gameOver)
        {
            return;
        }
        if (IsFriend(pressedSweet, enteredSweet))
        {
            ExchangeSweets(pressedSweet, enteredSweet);
        }
    }

 

 

 

,  定義游戲時間

   public int playerScore;

    public Text playerScoreText;

 

  private IEnumerator ClearCoroutine()
    {
        Animator animator = GetComponent<Animator>();

        if (animator!=null)
        {
            animator.Play(clearAnimation.name);
            //玩家得分+1,播放清除聲音

            GameManager.Instance.playerScore++;
            AudioSource.PlayClipAtPoint(destoryAudio,transform.position);
            yield return new WaitForSeconds(clearAnimation.length);
            Destroy(gameObject);
        }
    }

 

    void Update () {
        if (gameOver)
        {
            return;
        }
        gameTime -= Time.deltaTime;
        if (gameTime <= 0)
        {
            gameTime = 0;
            //顯示我們的失敗面板
            //播放失敗面板的動畫
            gameOver = true;
            return;
        }
        timeText.text = gameTime.ToString("0");

        playerScoreText.text = playerScore.ToString();
    }

 

  GameObject中添加游戲腳本

 

  NormalSweetPrefab預設提加上消除聲音

 

 

 

  此時甜品消除是有聲音的,並且消除一個甜品分數+1,為了追求玩家對消除分數欲望,下一步可以對消除甜品獲得分數進行逐級增加

 

 

時間跳動動畫

 

  添加時間動畫TimeAnimation,並綁定到Tex_time上

 

  設置不同時間點,Tex_Time動畫效果

  相應數值如下

 

  動畫縮放第一個位置

  

 

  動畫縮放第二個位置

  

 

  動畫縮放第三個位置

  

 

  動畫縮放第四個位置

  

 

 

 

 

游戲結算界面

 

  新建一個Plane作為游戲結束的畫面

  將游戲結束界面重命名為Panel_GameOver

    給游戲結束畫面添加文本,按鈕,圖片背景

 

  給結束畫面添加動畫,復制甜品消失動畫

  

 

 

 

 

控制結算界面的彈跳與加載場景

 

  為了游戲讓游戲結束才跳出Panel_GameOver面板,定義一個GameObject引用

    public GameObject gameOverPanel;

 

        if (gameTime <= 0)
        {
            gameTime = 0;
            //顯示我們的失敗面板
            //播放失敗面板的動畫
            gameOverPanel.SetActive(true);
            gameOver = true;
            return;
        }

 

  返回主菜單界面

    public void ReturnToMain()
    {
        SceneManager.LoadScene(0);
    }

 

  重玩游戲

    public void Replay()
    {
        SceneManager.LoadScene(1);
    }

 

  給But_Replay按鈕綁定重玩方法

 

  創建一個引用對游戲最終得分進行控制

    public Text finalScoreText;

 

  游戲結束的時候顯示游戲結算分數

        if (gameTime <= 0)
        {
            gameTime = 0;
            //顯示我們的失敗面板
            //播放失敗面板的動畫
            gameOverPanel.SetActive(true);
            finalScoreText.text = playerScore.ToString();
            gameOver = true;
            return;
        }

 

  在游戲管理器中掛在最終分數

  

  

  新建一個主界面場景

  並在Unity中對場景進行注冊

 

  

餅干清除的算法

 

  給餅干添加銷毀動畫

 

  給餅干動畫設置屬性,主要在於餅干的Color下的透明度

 

  給餅干掛在清除腳本

 

 

消除餅干算法

 

  坐標是被清除掉的甜品對象的坐標

private void ClearBarrier(int x,int y)
    {
        //左右清除
        for(int fiendX = x-1;fiendX <= x + 1; fiendX++)
        {
            if (fiendX!=x && fiendX>0 && fiendX<xColumn)
            {
                if (sweets[fiendX, y].Type == SweetsType.BARRIER && sweets[fiendX, y].CanClear())
                {
                    sweets[fiendX, y].ClearedCompent.Clear();
                    CreateNewSweet(fiendX,y,SweetsType.EMPTY);
                }
            }
        }

        //上下清除
        for (int fiendY = y - 1; fiendY <= y + 1; fiendY++)
        {
            if (fiendY != y && fiendY >= 0 && fiendY < yRow)
            {
                if (sweets[x, fiendY].Type == SweetsType.BARRIER && sweets[x, fiendY].CanClear())
                {
                    sweets[x, fiendY].ClearedCompent.Clear();
                    CreateNewSweet(x,fiendY, SweetsType.EMPTY);
                }
            }
        }

    }

 

  清除方法

    public bool ClearSweet(int x,int y)
    {
        if (sweets[x, y].CanClear()&&!sweets[x,y].ClearedCompent.IsClearing)
        {
            sweets[x, y].ClearedCompent.Clear();
            CreateNewSweet(x,y,SweetsType.EMPTY);


            ClearBarrier(x,y);
            return true;
        }
        return false;
    }

 

 

 

游戲UI動畫制作

 

  給游戲場景添加一些圖片按鈕,文字

  發現給文字添加一個Outline(Scrript)控件還挺好看的 

 

  添加游戲場景腳本LoadGame

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

public class LoadGame : MonoBehaviour {

    public void LoadTheGame()
    {
        SceneManager.LoadScene(1);
    }
    
    public void ExitGame()
    {
        Application.Quit();
    }

}
LoadGame.cs

 

  注冊點擊按鈕進入游戲事件

 

  注冊點擊按鈕離開游戲事件

 

 

 

 

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

public class GameManager : MonoBehaviour {

    /*甜品相關的成員變量*/
    #region
    //甜品的種類
    public enum SweetsType
    {
        EMPTY,
        NORMAL,
        BARRIER,
        ROE_CLEAR,
        COLUMN_CLEAR,
        RAINBOWCANDY,
        COUNT   //標記類型
    }

    //甜品預制體的字典,我們可以通過甜品的種類來得到對應的甜品游戲物體
    public Dictionary<SweetsType, GameObject> sweetPrefabDict;

    [System.Serializable]
    public struct SweetPrefab
    {
        public SweetsType type;
        public GameObject prefab;
    }

    public SweetPrefab[] sweetPrefabs;

    #endregion

    //單例實例化
    private static GameManager _instance;
    public static GameManager Instance
    {
        get
        {
            return _instance;
        }

        set
        {
            _instance = value;
        }
    }

    //大網格的行列數
    public int xColumn;
    public int yRow;

    //填充時間
    public float fillTime;

    public GameObject gridPrefab;

    public int playerScore;

    public Text playerScoreText;

    private float addScoreTime;
    private float currentScore;

    //甜品數組
    private GameSweet[,] sweets;

    //要交換的兩個甜品對象
    private GameSweet pressedSweet;
    private GameSweet enteredSweet;

    //有關游戲UI顯示的內容
    public Text timeText;

    private float gameTime=60;

    //判斷游戲是否失敗
    private bool gameOver;

    public GameObject gameOverPanel;

    public Text finalScoreText;

    private void Awake()
    {
        _instance = this;
    }

    // Use this for initialization
    void Start() {

        //字典的實例化
        sweetPrefabDict = new Dictionary<SweetsType, GameObject>();

        for(int i=0;i<sweetPrefabs.Length;i++)
        {
            if (!sweetPrefabDict.ContainsKey(sweetPrefabs[i].type))
            {
                sweetPrefabDict.Add(sweetPrefabs[i].type,sweetPrefabs[i].prefab);
            }
        }

       for(int x = 0; x < xColumn; x++)
        {
            for (int y=0;y<yRow;y++)
            {
                GameObject chocolate = Instantiate(gridPrefab,CorrectPosition(x,y),Quaternion.identity);
                chocolate.transform.SetParent(transform);
            }
        }

        sweets = new GameSweet[xColumn, yRow];
        for (int x = 0; x < xColumn; x++)
        {
            for (int y = 0; y < yRow; y++)
            {
                CreateNewSweet(x, y, SweetsType.EMPTY);
            }
        }

        //在(4,4)這個坐標點生成障礙物
        Destroy(sweets[4, 4].gameObject);
        CreateNewSweet(4, 4, SweetsType.BARRIER);
        Destroy(sweets[4, 3].gameObject);
        CreateNewSweet(4, 3, SweetsType.BARRIER);
        Destroy(sweets[1, 1].gameObject);
        CreateNewSweet(1, 1, SweetsType.BARRIER);
        Destroy(sweets[1, 1].gameObject);
        CreateNewSweet(1, 1, SweetsType.BARRIER);
        Destroy(sweets[7, 1].gameObject);
        CreateNewSweet(7, 1, SweetsType.BARRIER);
        Destroy(sweets[1, 6].gameObject);
        CreateNewSweet(1, 6, SweetsType.BARRIER);
        Destroy(sweets[7, 6].gameObject);
        CreateNewSweet(7, 6, SweetsType.BARRIER);

        StartCoroutine(AllFill());
    }
    
    // Update is called once per frame
    void Update () {

        gameTime -= Time.deltaTime;
        if (gameTime <= 0)
        {
            gameTime = 0;
            //顯示我們的失敗面板
            //播放失敗面板的動畫
            gameOverPanel.SetActive(true);
            finalScoreText.text = playerScore.ToString();
            gameOver = true;
        }

        timeText.text = gameTime.ToString("0");
        if (addScoreTime<=0.05f)
        {
            addScoreTime += Time.deltaTime;
        }
        else
        {
            if (currentScore < playerScore)
            {
                currentScore++;
                playerScoreText.text = currentScore.ToString();
                addScoreTime = 0;
            }
        }
    }

    public Vector3 CorrectPosition(int x ,int y)
    {
        //實際需要實例化巧克力的X位置 = GameManager位置的X坐標-大網格長度的一半+行列對應的X坐標
        // 實際需要實例化巧克力的Y位置 = GameManager位置的Y坐標-大網格長度的一半+行列對應的Y坐標
        return new Vector3(transform.position.x-xColumn/2f+x,transform.position.y+yRow/2f-y);
    }

    //產生甜品的方法
    public GameSweet CreateNewSweet(int x,int y,SweetsType type)
    {
        GameObject newSweet =  Instantiate(sweetPrefabDict[type], CorrectPosition(x, y), Quaternion.identity);
        newSweet.transform.parent = transform;

        sweets[x, y] = newSweet.GetComponent<GameSweet>();
        sweets[x, y].Init(x,y,this,type);

        return sweets[x, y];
    }

    //填充甜品的方法
    public IEnumerator AllFill()
    {
        bool needRefill = true;

        while(needRefill)
        {
            //完成上次填充動畫
            yield return new WaitForSeconds(fillTime);
            while (Fill())
            {
                yield return new WaitForSeconds(fillTime);
            }

            //清除所有我們意見匹配好的甜品
            needRefill = ClearAllMatchedSweet();
        }

    }

    //分布填充
    public bool Fill()
    {
        bool FilledNotFinshed = false;  //用來判斷本次是否完成

        //行遍歷
        for(int y=yRow-2;y>=0;y--)
        {
            for(int x=0;x<xColumn;x++)
            {
                GameSweet sweet = sweets[x, y]; //得到當前元素位置

                //如果無法移動,則無法往下填充
                if (sweet.CanMove())
                {
                    GameSweet sweetBelow = sweets[x, y + 1]; 

                    if(sweetBelow.Type == SweetsType.EMPTY)//垂直填充
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponet.Move(x,y+1,fillTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetsType.EMPTY);
                        FilledNotFinshed = true;
                    }
                    else
                    {
                        //-1代表左,1代表右
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;
                                //排除邊界的時候
                                //左下方
                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true;    //用來判斷垂直填充是否可以滿足填充要求
                                        for (int aboutY = y; aboutY >= 0; aboutY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboutY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }

                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponet.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            FilledNotFinshed = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
               
            }

        }
        //最上排的特殊情況
        for (int x = 0; x < xColumn; x++)
           {
               GameSweet sweet = sweets[x, 0];

              if(sweet.Type == SweetsType.EMPTY)
              {
                    GameObject newSweet = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(x,-1), Quaternion.identity);
                    newSweet.transform.parent = transform;

                    sweets[x, 0] = newSweet.GetComponent<GameSweet>();
                    sweets[x, 0].Init(x, -1,this,SweetsType.NORMAL);
                    sweets[x, 0].MovedComponet.Move(x, 0,fillTime);
                    sweets[x, 0].ColorComponet.SetColor((ColorSweet.ColorType)Random.Range(0,sweets[x,0].ColorComponet.NumColors));
                FilledNotFinshed = true;      
              }
        }
        return FilledNotFinshed;
    }

    //甜品是否相鄰的判斷方法
    private bool IsFriend(GameSweet sweet1,GameSweet sweet2)
    {
        return (sweet1.X == sweet2.X && Mathf.Abs(sweet1.Y-sweet2.Y)==1)||(sweet1.Y==sweet2.Y&&Mathf.Abs(sweet1.X-sweet2.X)==1);
    }

    //交換兩個甜品
    private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null)
            {
                int tempX = sweet1.X;
                int tempY = sweet1.Y;


                sweet1.MovedComponet.Move(sweet2.X, sweet2.Y, fillTime);
                sweet2.MovedComponet.Move(tempX, tempY, fillTime);

                ClearAllMatchedSweet();
                //消除甜品時兩側甜品進行填充
                StartCoroutine(AllFill());

            }
            else 
            {
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
            }

        }
    }

    /*玩家對甜品操作進行處理的方法*/
    #region
    public void PressSweet(GameSweet sweet)
    {
        if (gameOver)
        {
            return;
        }
        pressedSweet = sweet;
    }

    public void EnterSweet(GameSweet sweet)
    {
        if (gameOver)
        {
            return;
        }
        enteredSweet = sweet;
    }

    public void ReleaseSweet()
    {
        if (gameOver)
        {
            return;
        }
        if (IsFriend(pressedSweet, enteredSweet))
        {
            ExchangeSweets(pressedSweet, enteredSweet);
        }
    }
    #endregion

    /*清除匹配的方法*/
    #region
    //匹配方法
    public List<GameSweet> MatchSweets(GameSweet sweet, int newX, int newY)
    {
        if (sweet.CanColor())
        {
            ColorSweet.ColorType color = sweet.ColorComponet.Color;
            List<GameSweet> matchRowSweets = new List<GameSweet>();
            List<GameSweet> matchLineSweets = new List<GameSweet>();
            List<GameSweet> finishedMatchingSweets = new List<GameSweet>();

            //行匹配
            matchRowSweets.Add(sweet);

            //i=0代表往左,i=1代表往右
            for (int i = 0; i <= 1; i++)
            {
                for (int xDistance = 1; xDistance < xColumn; xDistance++)
                {
                    int x;
                    if (i == 0)
                    {
                        x = newX - xDistance;
                    }
                    else
                    {
                        x = newX + xDistance;
                    }
                    if (x < 0 || x >= xColumn)
                    {
                        break;
                    }

                    if (sweets[x, newY].CanColor() && sweets[x, newY].ColorComponet.Color == color)
                    {
                        matchRowSweets.Add(sweets[x, newY]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (matchRowSweets.Count >= 3)
            {
                for (int i = 0; i < matchRowSweets.Count; i++)
                {
                    finishedMatchingSweets.Add(matchRowSweets[i]);
                }
            }

            //L T型匹配
            //檢查一下當前行遍歷列表中的元素數量是否大於3
            if (matchRowSweets.Count >= 3)
            {
                for (int i = 0; i < matchRowSweets.Count; i++)
                {
                    //行匹配列表中滿足匹配條件的每個元素上下依次進行列遍歷
                    // 0代表上方 1代表下方
                    for (int j = 0; j <= 1; j++)
                    {
                        for (int yDistance = 1; yDistance < yRow; yDistance++)
                        {
                            int y;
                            if (j == 0)
                            {
                                y = newY - yDistance;
                            }
                            else
                            {
                                y = newY + yDistance;
                            }
                            if (y < 0 || y >= yRow)
                            {
                                break;
                            }

                            if (sweets[matchRowSweets[i].X, y].CanColor() && sweets[matchRowSweets[i].X, y].ColorComponet.Color == color)
                            {
                                matchLineSweets.Add(sweets[matchRowSweets[i].X, y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    if (matchLineSweets.Count < 2)
                    {
                        matchLineSweets.Clear();
                    }
                    else
                    {
                        for (int j = 0; j < matchLineSweets.Count; j++)
                        {
                            finishedMatchingSweets.Add(matchLineSweets[j]);
                        }
                        break;
                    }
                }
            }

            if (finishedMatchingSweets.Count >= 3)
            {
                return finishedMatchingSweets;
            }

            matchRowSweets.Clear();
            matchLineSweets.Clear();

            matchLineSweets.Add(sweet);

            //列匹配

            //i=0代表往左,i=1代表往右
            for (int i = 0; i <= 1; i++)
            {
                for (int yDistance = 1; yDistance < yRow; yDistance++)
                {
                    int y;
                    if (i == 0)
                    {
                        y = newY - yDistance;
                    }
                    else
                    {
                        y = newY + yDistance;
                    }
                    if (y < 0 || y >= yRow)
                    {
                        break;
                    }

                    if (sweets[newX, y].CanColor() && sweets[newX, y].ColorComponet.Color == color)
                    {
                        matchLineSweets.Add(sweets[newX, y]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (matchLineSweets.Count >= 3)
            {
                for (int i = 0; i < matchLineSweets.Count; i++)
                {
                    finishedMatchingSweets.Add(matchLineSweets[i]);
                }
            }

            //L T型匹配
            //檢查一下當前行遍歷列表中的元素數量是否大於3
            if (matchLineSweets.Count >= 3)
            {
                for (int i = 0; i < matchLineSweets.Count; i++)
                {
                    //行匹配列表中滿足匹配條件的每個元素上下依次進行列遍歷
                    // 0代表上方 1代表下方
                    for (int j = 0; j <= 1; j++)
                    {
                        for (int xDistance = 1; xDistance < xColumn; xDistance++)
                        {
                            int x;
                            if (j == 0)
                            {
                                x = newY - xDistance;
                            }
                            else
                            {
                                x = newY + xDistance;
                            }
                            if (x < 0 || x >= xColumn)
                            {
                                break;
                            }

                            if (sweets[x, matchLineSweets[i].Y].CanColor() && sweets[x, matchLineSweets[i].Y].ColorComponet.Color == color)
                            {
                                matchRowSweets.Add(sweets[x, matchLineSweets[i].Y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    if (matchRowSweets.Count < 2)
                    {
                        matchRowSweets.Clear();
                    }
                    else
                    {
                        for (int j = 0; j < matchRowSweets.Count; j++)
                        {
                            finishedMatchingSweets.Add(matchRowSweets[j]);
                        }
                        break;
                    }
                }
            }

            if (finishedMatchingSweets.Count >= 3)
            {
                return finishedMatchingSweets;
            }
        }

        return null;
    }


    //清除方法
    public bool ClearSweet(int x,int y)
    {
        if (sweets[x, y].CanClear()&&!sweets[x,y].ClearedCompent.IsClearing)
        {
            sweets[x, y].ClearedCompent.Clear();
            CreateNewSweet(x,y,SweetsType.EMPTY);


            ClearBarrier(x,y);
            return true;
        }
        return false;
    }

    //清除餅干的方法
    //坐標是被清除掉的甜品對象的坐標
    private void ClearBarrier(int x,int y)
    {
        //左右清除
        for(int fiendX = x-1;fiendX <= x + 1; fiendX++)
        {
            if (fiendX!=x && fiendX>0 && fiendX<xColumn)
            {
                if (sweets[fiendX, y].Type == SweetsType.BARRIER && sweets[fiendX, y].CanClear())
                {
                    sweets[fiendX, y].ClearedCompent.Clear();
                    CreateNewSweet(fiendX,y,SweetsType.EMPTY);
                }
            }
        }

        //上下清除
        for (int fiendY = y - 1; fiendY <= y + 1; fiendY++)
        {
            if (fiendY != y && fiendY >= 0 && fiendY < yRow)
            {
                if (sweets[x, fiendY].Type == SweetsType.BARRIER && sweets[x, fiendY].CanClear())
                {
                    sweets[x, fiendY].ClearedCompent.Clear();
                    CreateNewSweet(x,fiendY, SweetsType.EMPTY);
                }
            }
        }

    }

    //清除全部完成匹配的甜品
    private bool ClearAllMatchedSweet()
    {
        bool needRefill = false;

        for(int y = 0; y < yRow; y++)
        {
            for (int x=0;x<xColumn;x++)
            {
                if (sweets[x, y].CanClear())
                {
                     List<GameSweet> matchList = MatchSweets(sweets[x,y],x,y);

                    if (matchList != null)
                    {
                        for (int i=0;i<matchList.Count;i++)
                        {
                            if (ClearSweet(matchList[i].X, matchList[i].Y))
                            {
                                needRefill = true;
                            }
                        }
                    }
                }
            }
        }
        return needRefill;
    }
    #endregion

    //
    public void ReturnToMain()
    {
        SceneManager.LoadScene(0);
    }

    public void Replay()
    {
        SceneManager.LoadScene(1);
    }

}
GameManager.cs 游戲管理器腳本

 

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

public class ClearedSweet : MonoBehaviour {

    //清除腳本的動畫
    public AnimationClip clearAnimation;

    private bool isClearing;

    public AudioClip destoryAudio;

    public bool IsClearing
    {
        get
        {
            return isClearing;
        }
    }

    //為了方便后期做拓展,設置成protected
    protected GameSweet sweet;

    public virtual void Clear()
    {
        isClearing = true;
        StartCoroutine(ClearCoroutine());
    }

    private IEnumerator ClearCoroutine()
    {
        Animator animator = GetComponent<Animator>();

        if (animator!=null)
        {
            animator.Play(clearAnimation.name);
            //玩家得分+1,播放清除聲音

            GameManager.Instance.playerScore++;
            AudioSource.PlayClipAtPoint(destoryAudio,transform.position);
            yield return new WaitForSeconds(clearAnimation.length);
            Destroy(gameObject);
        }
    }

}
ClearedSweet.cs 清除腳本

 

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

public class ColorSweet : MonoBehaviour {

    public enum ColorType
    {
        YELLOW,
        PUPLE,
        RED,
        BLUE,
        GREEN,
        PNGK,
        ANY,
        COUNT
    }

    [System.Serializable]
    public struct ColorSprite
    {
        public ColorType color;
        public Sprite sprite;
    }

    public ColorSprite[] ColorSprites;

    private Dictionary<ColorType, Sprite> colorSpriteDict;

    private SpriteRenderer sprite;

    public int NumColors
    {
        get{ return ColorSprites.Length; }
    }

    public ColorType Color
    {
        get
        {
            return color;
        }

        set
        {
            SetColor(value);
        }
    }

    private ColorType color;



    public void Awake()
    {
        sprite = transform.Find("Sweet").GetComponent<SpriteRenderer>();

        colorSpriteDict = new Dictionary<ColorType, Sprite>();

        for(int i = 0; i < ColorSprites.Length; i++)
        {
            if (!colorSpriteDict.ContainsKey(ColorSprites[i].color))
            {
                colorSpriteDict.Add(ColorSprites[i].color,ColorSprites[i].sprite);
            }
        }
    }

    public void SetColor(ColorType newColor)
    {
        color = newColor;
        if (colorSpriteDict.ContainsKey(newColor))
        {
            sprite.sprite = colorSpriteDict[newColor];
        }
    }


}
ColorSweet.cs 隨機生成甜品腳本

 

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

public class GameSweet : MonoBehaviour {

    private int x;
    private int y;
    public int X
    {
        get
        {
            return x;
        }

        set
        {
            if (CanMove())
            {
                x = value;
            }
        }
    }
    public int Y
    {
        get
        {
            return y;
        }

        set
        {
            if (CanMove())
            {
                y = value;
            }
        }
    }

    private GameManager.SweetsType type;
    public GameManager.SweetsType Type
    {
        get
        {
            return type;
        }
    }


    [HideInInspector]
    public GameManager gameManager;

    public MovedSweet MovedComponet
    {
        get
        {
            return movedComponet;
        }
    }
    private MovedSweet movedComponet;


    public ColorSweet ColorComponet
    {
        get
        {
            return coloredCompent;
        }
    }

    public ClearedSweet ClearedCompent
    {
        get
        {
            return clearedCompent;
        }
    }

    private ColorSweet coloredCompent;

    private ClearedSweet clearedCompent;


    //判斷甜品是否可以移動
    public bool CanMove()
    {
        return movedComponet != null;
    }

    //判斷是否可以着色
    public bool CanColor()
    {
        return coloredCompent != null;
    }

    //判斷是否可以清除
    public bool CanClear()
    {
        return clearedCompent != null;
    }

    private void Awake()
    {
        movedComponet = GetComponent<MovedSweet>();
        coloredCompent = GetComponent<ColorSweet>();
        clearedCompent = GetComponent<ClearedSweet>();
    }

    public void Init(int _x,int _y,GameManager _gameManager,GameManager.SweetsType _type)
    {
        x = _x;
        y = _y;
        gameManager = _gameManager;
        type = _type;
    }

    //鼠標點擊
    private void OnMouseEnter()
    {
        gameManager.EnterSweet(this);
    }

    //鼠標按下
    private void OnMouseDown()
    {
        gameManager.PressSweet(this);
    }

    //鼠標抬起
    private void OnMouseUp()
    {
        gameManager.ReleaseSweet();
    }
}
GameSweet.cs 點擊甜品響應腳本

 

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

public class LoadGame : MonoBehaviour {

    public void LoadTheGame()
    {
        SceneManager.LoadScene(1);
    }
    
    public void ExitGame()
    {
        Application.Quit();
    }

}
LoadGame.cs 加載游戲場景腳本

 

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

public class MovedSweet : MonoBehaviour {

    private GameSweet sweet;

    private IEnumerator moveCoroutine;

    private void Awake()
    {
        sweet = GetComponent<GameSweet>();
    }

    //開啟或者結束一個協成
    public void Move(int newX,int newY,float time)
    {
        if(moveCoroutine!=null)
        {
            StopCoroutine(moveCoroutine);
        }

        moveCoroutine = MoveCoroutine(newX,newY,time);
        StartCoroutine(moveCoroutine);
    }

    //負責移動的協成
    private IEnumerator MoveCoroutine(int newX,int newY,float time)
    {
        sweet.X = newX;
        sweet.Y = newY;

        //每一幀移動一點點
        Vector3 startPos = transform.position;
        Vector3 endPos = sweet.gameManager.CorrectPosition(newX,newY);

        for(float t=0;t<time;t+=Time.deltaTime)
        {
            sweet.transform.position = Vector3.Lerp(startPos,endPos,t/time);
            yield return 0;
        }

        sweet.transform.position = endPos;
    }
}
MovedSweet.cs 移動甜品腳本

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM