Unity翻牌对对碰

本项目工程是用Unity2018.3.0f2，亲测可用，工程在附件链接里。
资源均来源于网络，仅供学习和参考使用，版权归原作者所有，勿作商业用途，请在下载后24小时之内自觉删除。
本站发布的内容若无意中侵犯到您的权益，请联系我们，本站将在看到后立即删除。

1. using System.Collections.Generic;
   
2. using UnityEngine;
   
3. using UnityEngine.UI;
   
4. 
   
5. public class GameMain : MonoBehaviour {
   
6. 
   
7.     public Button btnLevel1;
   
8.     public Button btnLevel2;
   
9.     public Button btnLevel3;
   
10. 
    
11.     public Transform panelStart;
    
12.     public Transform panelCard;
    
13.     public Transform panelOver;
    
14. 
    
15.     // Use this for initialization
    
16.     void Start () {
    
17.         btnLevel1.onClick.AddListener(()=> {
    
18.             panelStart.gameObject.SetActive(false);
    
19.             panelCard.gameObject.SetActive(true);
    
20.             LoadLevelCard(3, 2);
    
21.         });
    
22.         btnLevel2.onClick.AddListener(() => {
    
23.             panelStart.gameObject.SetActive(false);
    
24.             panelCard.gameObject.SetActive(true);
    
25.             LoadLevelCard(4, 2);
    
26.         });
    
27.         btnLevel3.onClick.AddListener(() => {
    
28.             panelStart.gameObject.SetActive(false);
    
29.             panelCard.gameObject.SetActive(true);
    
30.             LoadLevelCard(5, 2);
    
31.         });
    
32.         Button btnToStart = panelOver.Find("Button_to_start").GetComponent<Button>();
    
33.         btnToStart.onClick.RemoveAllListeners();
    
34.         btnToStart.onClick.AddListener(ToGameStartPage);
    
35.     }
    
36. 
    
37.     void LoadLevelCard(int width , int height)
    
38.     {
    
39.         //1加载卡牌图片
    
40.         Sprite [] sps = Resources.LoadAll<Sprite>("Sprite");
    
41.          
    
42.         //2计算需要加载卡牌的数量
    
43.         int totalCount = width * height/2;
    
44.         //3计算加载卡牌的索引
    
45.         List<Sprite> spsList = new List<Sprite>();
    
46.         for( int i = 0; i < sps.Length; i++)
    
47.         {
    
48.             spsList.Add(sps[i]);
    
49.         }
    
50. 
    
51.         List<Sprite> needShowCardList = new List<Sprite>();
    
52.         while (totalCount > 0)
    
53.         {
    
54.             int randomIndex = Random.Range(0,spsList.Count);
    
55.             needShowCardList.Add(spsList[randomIndex]);
    
56.             needShowCardList.Add(spsList[randomIndex]);
    
57.             spsList.RemoveAt(randomIndex);
    
58.             totalCount--;
    
59.         }
    
60.         //自加打散
    
61.         for (int i = 0; i < needShowCardList.Count; i++)
    
62.         {
    
63.             int num = Random.Range(0, needShowCardList.Count);
    
64.             if (num != i)
    
65.             {
    
66.                 Sprite temp = needShowCardList[i];
    
67.                 needShowCardList[i] = needShowCardList[num];
    
68.                 needShowCardList[num] = temp;
    
69.             }
    
70.         }
    
71.         //4显示卡牌到UI上
    
72.         Transform contentRoot = panelCard.Find("Panel");
    
73.         int maxCount = Mathf.Max( contentRoot.childCount,needShowCardList.Count);
    
74.         GameObject itemPrefab = contentRoot.GetChild(0).gameObject;
    
75.         for (int i = 0; i < maxCount; i++)
    
76.         {
    
77.             GameObject itemObject = null;
    
78.             if (i < contentRoot.childCount)
    
79.             {
    
80.                 itemObject = contentRoot.GetChild(i).gameObject;
    
81.             }
    
82.             else
    
83.             {
    
84.                 //clone
    
85.                 itemObject = GameObject.Instantiate<GameObject>(itemPrefab);
    
86.                 itemObject.transform.SetParent(contentRoot, false);
    
87.             }
    
88.             itemObject.transform.Find("Image_front").GetComponent<Image>().sprite = needShowCardList[i];
    
89.             CardFlipAnimationCtrl cardAniCtrl = itemObject.GetComponent<CardFlipAnimationCtrl>();
    
90.             cardAniCtrl.SetDefaultState();
    
91.         }
    
92. 
    
93.         GridLayoutGroup glg = contentRoot.GetComponent<GridLayoutGroup>();
    
94. 
    
95.         float panelWidth = width * glg.cellSize.x+glg.padding.left+
    
96.             glg.padding.right+(width-1)*glg.spacing.x;
    
97.         float panelHeight = height * glg.cellSize.y+glg.padding.top+
    
98.             glg.padding.bottom+(width-1)*glg.spacing.y;
    
99.         contentRoot.GetComponent<RectTransform>().sizeDelta = new Vector2(panelWidth, panelHeight);
    
100.     }
     
101. 
     
102. 
     
103.     public void CheckIsGameOver()
     
104.     {
     
105.         CardFlipAnimationCtrl[] allCards =  GameObject.FindObjectsOfType<CardFlipAnimationCtrl>();
     
106.         if( allCards != null && allCards.Length > 0)
     
107.         {
     
108.             List<CardFlipAnimationCtrl> cardInFront = new List<CardFlipAnimationCtrl>();
     
109. 
     
110.             for( int i = 0; i < allCards.Length; i++)
     
111.             {
     
112.                 CardFlipAnimationCtrl cardTem = allCards[i];
     
113.                 if( cardTem.isInFront && !cardTem.isOver)
     
114.                 {
     
115.                     cardInFront.Add(cardTem);
     
116.                 }
     
117. 
     
118.                 if(cardInFront.Count >= 2)
     
119.                 {
     
120.                     string cardImageName1 = cardInFront[0].GetCardImageName();
     
121.                     string cardImageName2 = cardInFront[1].GetCardImageName();
     
122.                     if( cardImageName1 == cardImageName2)
     
123.                     {
     
124.                         cardInFront[0].MachSucess();
     
125.                         cardInFront[1].MachSucess();
     
126.                     }
     
127.                     else
     
128.                     {
     
129.                         cardInFront[0].MachFail();
     
130.                         cardInFront[1].MachFail();
     
131.                     }
     
132.                     allCards = GameObject.FindObjectsOfType<CardFlipAnimationCtrl>();
     
133.                     bool isAllOver = true;
     
134.                     for( int o = 0; o < allCards.Length; o++)
     
135.                     {
     
136.                         isAllOver &= allCards[o].isOver;
     
137.                     }
     
138.                     if( isAllOver)
     
139.                     {
     
140.                         ToGameOverPanel();
     
141.                     }  
     
142.                     break;
     
143.                 }
     
144.             }
     
145.         }
     
146.     }
     
147. 
     
148.     // Update is called once per frame
     
149.     public void ToGameOverPanel ()
     
150.     {
     
151.         panelStart.gameObject.SetActive(false);
     
152.         panelCard.gameObject.SetActive(false);
     
153.         panelOver.gameObject.SetActive(true);
     
154.     }
     
155. 
     
156.     public void ToGameStartPage()
     
157.     {
     
158.         panelStart.gameObject.SetActive(true);
     
159.         panelCard.gameObject.SetActive(false);
     
160.         panelOver.gameObject.SetActive(false);
     
161.     }
     
162. }

复制代码

1. using System;
   
2. using System.Collections;
   
3. using UnityEngine;
   
4. using UnityEngine.EventSystems;
   
5. using UnityEngine.UI;
   
6. 
   
7. /***
   
8. *
   
9. * 卡牌功能类
   
10. *
    
11. * **/
    
12. public class CardFlipAnimationCtrl : MonoBehaviour,IPointerClickHandler {
    
13. 
    
14.     public Transform cardFront;
    
15.     public Transform cardBack;
    
16. 
    
17.     public float flipDuaration = 0.2f;
    
18. 
    
19.     public bool isInFront = false;
    
20.     public bool isOver = false;
    
21.    
    
22.     void Awake () {
    
23.         cardFront = transform.Find("Image_front");
    
24.         cardBack = transform.Find("Image_back");
    
25.         }
    
26. 
    
27. 
    
28.     public void OnPointerClick(PointerEventData eventData)
    
29.     {
    
30.         if(!isInFront)
    
31.         {
    
32.             StartCoroutine(FlipCardToFront());
    
33.         }
    
34.         else
    
35.         {
    
36.             StartCoroutine(FlipCardToBack());
    
37.         }
    
38.               
    
39.     }
    
40. 
    
41.     IEnumerator FlipCardToFront()
    
42.     {
    
43.         //1.翻转反面到90度
    
44.         cardFront.gameObject.SetActive(false);
    
45.         cardBack.gameObject.SetActive(true);
    
46.         cardFront.rotation = Quaternion.identity;
    
47.         while( cardBack.rotation.eulerAngles.y>90)
    
48.         {
    
49.             cardBack.rotation *= Quaternion.Euler(0, Time.deltaTime*90f*(1f/flipDuaration), 0);
    
50.             if (cardBack.rotation.eulerAngles.y > 90)
    
51.             {
    
52.                 cardBack.rotation = Quaternion.Euler( 0, 90 , 0 );
    
53.                 break;
    
54.             }
    
55.             yield return new WaitForFixedUpdate();
    
56.         }
    
57. 
    
58.         //2.翻转正面到0度
    
59.         cardFront.gameObject.SetActive(true);
    
60.         cardBack.gameObject.SetActive(false);
    
61.         cardFront.rotation = Quaternion.Euler(0,90,0);
    
62.         while (cardFront.rotation.eulerAngles.y > 0)
    
63.         {
    
64.             cardFront.rotation *= Quaternion.Euler(0, -Time.deltaTime * 90f * (1f / flipDuaration), 0);
    
65.             if (cardFront.rotation.eulerAngles.y > 90)
    
66.             {
    
67.                 cardFront.rotation = Quaternion.Euler(0, 0, 0);
    
68.                 break;
    
69.             }
    
70.             yield return new WaitForFixedUpdate();
    
71.         }
    
72.         isInFront = true;
    
73. 
    
74.         Camera.main.gameObject.GetComponent<GameMain>().CheckIsGameOver();
    
75.     }
    
76. 
    
77.     IEnumerator FlipCardToBack()
    
78.     {
    
79.         //1.翻转正面到90度
    
80.         cardFront.gameObject.SetActive(true);
    
81.         cardBack.gameObject.SetActive(false);
    
82.         cardFront.rotation = Quaternion.identity;
    
83.         while (cardFront.rotation.eulerAngles.y < 90)
    
84.         {
    
85.             cardFront.rotation *= Quaternion.Euler(0, Time.deltaTime * 90f * (1f / flipDuaration), 0);
    
86.             if (cardFront.rotation.eulerAngles.y > 90)
    
87.             {
    
88.                 cardFront.rotation = Quaternion.Euler(0, 90, 0);
    
89.                 break;
    
90.             }
    
91.             yield return new WaitForFixedUpdate();
    
92.         }
    
93. 
    
94.         //2.翻转正面到0度
    
95.         cardFront.gameObject.SetActive(false);
    
96.         cardBack.gameObject.SetActive(true);
    
97.         cardBack.rotation = Quaternion.Euler(0, 90, 0);
    
98.         while (cardBack.rotation.eulerAngles.y > 0)
    
99.         {
    
100.             cardBack.rotation *= Quaternion.Euler(0, -Time.deltaTime * 90f * (1f / flipDuaration), 0);
     
101.             if (cardBack.rotation.eulerAngles.y > 90)
     
102.             {
     
103.                 cardBack.rotation = Quaternion.Euler(0, 0, 0);
     
104.                 break;
     
105.             }
     
106.             yield return new WaitForFixedUpdate();
     
107.         }
     
108.         isInFront = false;
     
109.     }
     
110. 
     
111.     internal void SetDefaultState()
     
112.     {
     
113.         cardFront.gameObject.SetActive(false);
     
114.         cardBack.gameObject.SetActive(true);
     
115.         isOver = false;
     
116.         isInFront = false;
     
117.         cardFront.rotation = Quaternion.identity;
     
118.         cardBack.rotation = Quaternion.identity;
     
119.     }
     
120. 
     
121.     internal string GetCardImageName()
     
122.     {
     
123.         return cardFront.GetComponent<Image>().sprite.name;
     
124.     }
     
125. 
     
126.     internal void MachSucess()
     
127.     {
     
128.         isOver = true;
     
129.         cardFront.gameObject.SetActive(false);
     
130.         cardBack.gameObject.SetActive(false);
     
131.     }
     
132. 
     
133.     internal void MachFail()
     
134.     {
     
135.         StartCoroutine(FlipCardToBack());
     
136.     }
     
137. }

复制代码