一、框架视图
二、关键代码
Card
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;
public class Card : MonoBehaviour
{
public Button btnCard;
public Image imgCard;
public Sprite[] clickSprites;
public Sprite[] coveredSprites;
public int id;
public RectTransform rtf;
public List<Card> aboveCardList = new List<Card>();//覆盖当前卡牌的其他卡牌
public List<Card> coverCardList = new List<Card>();//当前卡牌覆盖的其他卡牌
// Start is called before the first frame update
void Start()
{
btnCard.onClick.AddListener(CardClickEvent);
}
// Update is called once per frame
void Update()
{
}
/// <summary>
/// 设置卡牌纹理图案与ID
/// </summary>
public void SetCardSprite()
{
id = Random.Range(1,15);
imgCard.sprite = clickSprites[id - 1];
SpriteState ss= btnCard.spriteState;
ss.disabledSprite = coveredSprites[id - 1];
btnCard.spriteState=ss;
}
/// <summary>
/// 设置当前卡牌与其他卡牌的覆盖关系
/// </summary>
/// <param name="targetCard">目标卡牌</param>
public void SetCoverCardState(Card targetCard)
{
//本身卡牌屏幕的坐标点
Vector2 cardPos= GUIUtility.GUIToScreenPoint(rtf.anchoredPosition);
//目标卡牌屏幕的坐标点
Vector2 targetCardPos= GUIUtility.GUIToScreenPoint(targetCard.rtf.anchoredPosition);
if (Mathf.Abs(cardPos.x-targetCardPos.x)<Deck.Instance.cardWidth
&&Mathf.Abs(cardPos.y-targetCardPos.y)<Deck.Instance.cardHeight)
{
//覆盖上了目标卡牌
targetCard.AddAboveCard(this);
targetCard.CloseButtonClickState();
coverCardList.Add(targetCard);
}
}
/// <summary>
/// 关闭按钮交互状态
/// </summary>
public void CloseButtonClickState()
{
btnCard.interactable = false;
}
/// <summary>
/// 卡牌点击事件
/// </summary>
public void CardClickEvent()
{
Deck.Instance.PlayClickSound();
transform.SetSiblingIndex(500);
//需要移除所有被我们覆盖的卡牌持有的我们自身卡牌引用(我们当前自身)
for (int i = 0; i < coverCardList.Count; i++)
{
coverCardList[i].RemoveAboveCard(this);
coverCardList[i].JudgeCanClickState();
}
int posID = -1;
Transform targetTrans= Deck.Instance.GetPickDeckTargetTrans(id,out posID);
transform.DOMove(targetTrans.position,0.5f).OnComplete
(
() =>
{
if (targetTrans.childCount>0)
{
transform.SetParent(Deck.Instance.GetEmptyPickDeckTargetTrans(posID));
}
else
{
transform.SetParent(targetTrans);
}
transform.localPosition = Vector3.zero;
Deck.Instance.JudgeClearCard();
}
);
}
/// <summary>
/// 目标卡牌覆盖了当前卡牌（我们自身去调用目标卡牌的方法）
/// </summary>
public void AddAboveCard(Card targetCard)
{
aboveCardList.Add(targetCard);
}
/// <summary>
/// 移除当前卡牌被目标卡牌覆盖的引用（我们自身被其他覆盖到我们的卡牌(目标卡牌)去调用）
/// </summary>
/// <param name="aboveCard"></param>
public void RemoveAboveCard(Card aboveCard)
{
aboveCardList.Remove(aboveCard);
}
/// <summary>
/// 判断当前是否可以点击
/// </summary>
public void JudgeCanClickState()
{
btnCard.interactable = aboveCardList.Count <= 0;
}
}
Deck
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using UnityEngine.SceneManagement;
public class Deck : MonoBehaviour
{
public static Deck Instance { get; set; }
public int cardWidth = 213;
public int cardHeight = 213;
public GameObject cardGo;
private int row = 7;
private int column = 7;
private int layer = 8;
private List<Card> cards = new List<Card>();
public RectTransform deckTrans;//卡牌需要生成到的位置的transform引用
public Transform[] pickDeckPosTrans;//捡牌堆的格子位置
public RectTransform centerDeckTrans;//中间牌堆的基础位置（原点）
public RectTransform leftColumnDeckTrans;
public RectTransform rightColumnDeckTrans;
public RectTransform leftDownDeckTrans;
public RectTransform rightDownDeckTrans;
public int[] pickDeckCardIDs;//存放当前选中卡牌堆里的卡牌ID（跟当前位置一一对应）
private int totalCardNum = 168;
private int createCardNum = 0;
public GameObject gameOverPanelGo;
public AudioSource audioSource;
public AudioClip clickSound;
private int[,,] centerDeck = new int[,,]//层 行 列
{
//后5层
{
{0,0,0,0},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,0,0,0}
},
{
{0,0,0,0},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,0,0,0}
},
{
{0,0,0,0},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,0,0,0}
},
{
{0,0,0,0},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,0,0,0}
},
{
{0,0,0,0},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,2,2,2},
{0,0,0,0}
},
//上两层
{
{0,0,0,0},
{0,1,1,1},
{0,0,1,1},
{0,0,1,1},
{0,1,2,2},
{0,2,2,1},
{0,0,0,0}
},
{
{0,0,0,0},
{0,1,1,3},
{0,0,2,2},
{3,3,3,3},
{0,0,0,3},
{0,0,3,3},
{0,0,0,0}
},
//最上层
{
{0,3,1,2},
{0,0,0,0},
{3,2,2,2},
{3,3,3,3},
{0,0,2,2},
{0,0,0,0},
{0,0,1,3}
}
};
private void Awake()
{
Instance = this;
}
// Start is called before the first frame update
void Start()
{
pickDeckCardIDs = new int[7] { -1,-1,-1,-1,-1,-1,-1};
//生成中间的一叠
//层
for (int k = 0; k < layer; k++)
{
//行
for (int j = 0; j < row; j++)
{
//随机当前列是否偏移
bool ifMoveX = Convert.ToBoolean(UnityEngine.Random.Range(0, 2));
int dirX = 0;
if (ifMoveX)
{
//偏移方向是左还是右
dirX = UnityEngine.Random.Range(0, 2) == 0 ? 1 : -1;
}
//随机当前行是否偏移
bool ifMoveY = Convert.ToBoolean(UnityEngine.Random.Range(0, 2));
int dirY = 0;
if (ifMoveY)
{
//偏移方向是上还是下
dirY = UnityEngine.Random.Range(0, 2) == 0 ? 1 : -1;
}
//准备临时数组存贮前半部分随机到的卡牌状态，以对称生成后半部分状态
CREATESTATE[] halfState = new CREATESTATE[column / 2];
//列
for (int i = 0; i < column; i++)
{
GameObject go = null;
CREATESTATE cs;
if (i<=column/2)
{
//前半部分直接从三维数组取1 2 3 4 5 6 7
// 2 1 0 0 1 2
cs = (CREATESTATE)centerDeck[k, j, i];
if (i!=column/2)
{
halfState[column / 2 - i - 1] = cs;
}
}
else
{
cs = halfState[i - column / 2 - 1];
}
switch (cs)
{
case CREATESTATE.NONE:
break;
case CREATESTATE.CREATE:
go = CreateCardGo(i, j, dirX, dirY);
break;
case CREATESTATE.RANDOM:
if (UnityEngine.Random.Range(0,2)==0?true:false)
{
//随机生成
go= CreateCardGo(i,j,dirX,dirY);
}
break;
case CREATESTATE.ONLYCREATE:
go = CreateCardGo(i, j, 0, 0);
break;
default:
break;
}
if (go)
{
Card card = go.GetComponent<Card>();
card.SetCardSprite();
SetCoverState(card);
cards.Add(card);
createCardNum++;
go.name = "I:" + i.ToString() + " J:" + j.ToString() + " K:" + k.ToString();
}
}
}
}
//生成其他四叠
int createNum = (totalCardNum - createCardNum) / 4;
int leftNum = totalCardNum - createCardNum - createNum * 4;
//左竖
for (int i = createNum + leftNum; i>0 ; i--)
{
CreateCard(leftColumnDeckTrans,0,-i);
}
//右竖
for (int i = 0; i < createNum; i++)
{
CreateCard(rightColumnDeckTrans,0,-i);
}
//左下
for (int i = 0; i < createNum; i++)
{
CreateCard(leftDownDeckTrans,i,0);
}
//右下
for (int i = createNum; i >0 ; i--)
{
CreateCard(rightDownDeckTrans, i, 0);
}
}
/// <summary>
/// 生成旁边四叠卡牌
/// </summary>
/// <param name="zeroTrans"></param>
/// <param name="indexX"></param>
/// <param name="indexY"></param>
private void CreateCard(RectTransform zeroTrans,int indexX,int indexY)
{
GameObject go= Instantiate(cardGo,deckTrans);
RectTransform rft = go.GetComponent<RectTransform>();
rft.anchoredPosition = zeroTrans.anchoredPosition +
new Vector2(cardWidth*indexX*0.15f,cardHeight*indexY*0.15f);
Card card = go.GetComponent<Card>();
card.SetCardSprite();
SetCoverState(card);
cards.Add(card);
}
/// <summary>
/// 产生卡牌游戏物体
/// </summary>
private GameObject CreateCardGo(int column,int row,int dirX,int dirY)
{
GameObject go = Instantiate(cardGo, deckTrans);
go.GetComponent<RectTransform>().anchoredPosition
= centerDeckTrans.anchoredPosition +
new Vector2(cardWidth * (column + 0.5f * dirX), -cardHeight * (row + 0.5f * dirY));
return go;
}
/// <summary>
/// 设置当前新生成的卡牌与其他卡牌的覆盖关系
/// </summary>
/// <param name="card"></param>
private void SetCoverState(Card card)
{
for (int i = 0; i < cards.Count; i++)
{
card.SetCoverCardState(cards[i]);
}
}
/// <summary>
/// 获取当前捡牌堆的目标位置
/// </summary>
/// <param name="currentID">当前新选中的牌</param>
/// <param name="posID">格子位置ID索引</param>
/// <returns></returns>
public Transform GetPickDeckTargetTrans(int currentID, out int posID)
{
posID = -1;
for (int i = 0; i < pickDeckCardIDs.Length; i++)
{
//当前捡牌堆中的卡牌有没有与新选中的卡牌ID相等
if (pickDeckCardIDs[i]==currentID&&i+1<=pickDeckCardIDs.Length)
{
posID = i + 1;
return pickDeckPosTrans[i + 1];
}
}
//当前捡牌堆没有与新选卡牌相同的ID
Transform sf= GetEmptyPickDeckTargetTrans();
if (sf)
{
return sf;
}
return null;
}
/// <summary>
/// 获取选中卡牌堆的空位置
/// </summary>
/// <param name="posID">当前选中卡牌堆的格子位置索引ID</param>
/// <returns></returns>
public Transform GetEmptyPickDeckTargetTrans(int posID=-1)
{
for (int i = 0; i < pickDeckCardIDs.Length; i++)
{
if (pickDeckCardIDs[i]==-1)
{
//pickDeckCardIDs[i] = posID;
//有两个或两个以下相同ID的卡牌，需要调整位置
if (posID!=-1)
{
pickDeckPosTrans[i].SetSiblingIndex(posID);
}
return pickDeckPosTrans[i];
}
}
//Debug.Log("游戏结束");
return null;
}
/// <summary>
/// 排序卡牌位置和ID
/// </summary>
public void SortCardAndCardID()
{
SortCard();
SortID();
}
/// <summary>
/// 卡牌排序
/// </summary>
public void SortCard()
{
Transform[] tempTrans = new Transform[pickDeckPosTrans.Length];
for (int i = 0; i < pickDeckPosTrans.Length; i++)
{
int siblingIndex= pickDeckPosTrans[i].GetSiblingIndex();
tempTrans[siblingIndex] = pickDeckPosTrans[i];
}
for (int i = 0; i < pickDeckPosTrans.Length; i++)
{
pickDeckPosTrans[i] = tempTrans[i];
}
}
/// <summary>
/// ID排序
/// </summary>
public void SortID()
{
for (int i = 0; i < pickDeckCardIDs.Length; i++)
{
if (pickDeckPosTrans[i].childCount > 0)
{
pickDeckCardIDs[i] = pickDeckPosTrans[i].GetChild(0).GetComponent<Card>().id;
}
else
{
pickDeckCardIDs[i] = -1;
}
}
}
/// <summary>
/// 卡牌消除判定方法
/// </summary>
public void JudgeClearCard()
{
SortCardAndCardID();
//清除判定
ClearCards();
Invoke("SortGridPos",0.1f);
}
/// <summary>
/// 消除
/// </summary>
public void ClearCards()
{
int sameCount = 0;
int judgeID = -1;
int startIndex = -1;
for (int i = 0; i <pickDeckCardIDs.Length; i++)
{
//空格子
if (pickDeckCardIDs[i]==-1)
{
break;
}
//当前三消判定开始的第一个元素
if (sameCount==0)
{
sameCount++;
judgeID = pickDeckCardIDs[i];
startIndex = i;
}
else
{
if (judgeID == pickDeckCardIDs[i])
{
sameCount++;
}
else
{
sameCount = 1;
judgeID = pickDeckCardIDs[i];
startIndex = i;
}
}
if (sameCount>=3)
{
for (int j = startIndex; j < startIndex+3; j++)
{
pickDeckCardIDs[j] = -1;
Destroy(pickDeckPosTrans[j].GetChild(0).gameObject);
}
PlayClickSound();
break;
}
if (i>= pickDeckCardIDs.Length-1)
{
gameOverPanelGo.SetActive(true);
}
}
}
/// <summary>
/// 排序消除后的格子位置（消除后补齐）
/// </summary>
private void SortGridPos()
{
for (int i = 0; i < pickDeckPosTrans.Length; i++)
{
if (pickDeckPosTrans[i].childCount<=0)
{
//空格子
pickDeckPosTrans[i].SetSiblingIndex(6);
}
}
SortCardAndCardID();
}
public void ReturnToMainScene()
{
SceneManager.LoadScene(1);
}
public void Replay()
{
SceneManager.LoadScene(2);
}
public void PlayClickSound()
{
audioSource.PlayOneShot(clickSound);
}
}
/// <summary>
/// 卡牌的生成状态
/// </summary>
public enum CREATESTATE
{
NONE,//该位置不生成卡牌
CREATE,//生成并且位置可能偏移
RANDOM,//可能生成也可能偏移
ONLYCREATE//生成一定不偏移
}
SheepMove
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
public class SheepMove : MonoBehaviour
{
public RectTransform rt;
public Transform[] movePointsTrans;
private Vector3[] movePoints;
public bool loadScene;
private AsyncOperation ao;
// Start is called before the first frame update
void Start()
{
movePoints = new Vector3[movePointsTrans.Length];
for (int i = 0; i < movePoints.Length; i++)
{
movePoints[i] = movePointsTrans[i].localPosition;
}
if (loadScene)
{
ao = SceneManager.LoadSceneAsync(1);
ao.allowSceneActivation = false;
}
transform.DOLocalPath(movePoints, 3).SetEase(Ease.Linear).OnComplete
(
() =>
{
if (loadScene)
{
ao.allowSceneActivation = true;
}
}
);
}
// Update is called once per frame
void Update()
{
if (rt.anchoredPosition.y >= 0)
{
transform.eulerAngles = new Vector3(0, 180, 0);
}
else
{
transform.eulerAngles = Vector3.zero;
}
}
}
Sheeps
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using UnityEngine.SceneManagement;
public class Sheeps : MonoBehaviour
{
// Start is called before the first frame update
public Transform targetTrans;
private AsyncOperation ao;
public bool ifLoadGameScene;
void Start()
{
ao = SceneManager.LoadSceneAsync(2);
ao.allowSceneActivation = false;
transform.DOLocalMove(targetTrans.localPosition, 2).SetEase(Ease.Linear).OnComplete
(
OnCompeleteEvent
);
}
private void OnCompeleteEvent()
{
if (ifLoadGameScene)
{
ao.allowSceneActivation = true;
}
else
{
Destroy(gameObject);
}
}
}
三、效果展示
网友评论