这是看着别人的代码写的,这样写虽然很全面,但是毫无条理,我吧牌型打完之后感觉很不好,所以放弃,我给每一段加了注释,贴出代码让大家看一看
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Linq;
/// <summary>
/// 首先对手牌进行排序,然后判断出我手上的牌型,当出牌时
/// 判断我选择出的牌和上家的牌的大小,决定是否可以出牌。
/// </summary>
public class CardModel : MonoBehaviour {
//牌型枚举
public enum CardType
{
Single_Card,//单牌
Double_Card,//对子
Three_Card,//三张
Bomb_Card,//炸弹
KingBomb_Card,//王炸
ThreeOne_Card,//三带一
ThreeTwo_Card,//三代二
Four_TwoSingle_Card,//四带俩单
Four_TwoDouble_Card,//四带两对
Lian_Card,//单顺
Double_Lian_Card,//连对
Feiji_Card,//飞机(两个三张连)
Feiji_TwoSingle_Card,//飞机带俩单
Feiji_TwoDouble_Card,//飞机带两对
Error_Card//错误出牌
}
//牌型个数结构体,所有的牌型都是由这四种牌型组合而成。
public struct CardType_Index
{
public List<int> Single_index;//单牌
public List<int> Double_index;//对子
public List<int> Three_index;//三张
public List<int> Four_index;//四张
}
//牌型结构体
public struct GetCardInfo
{
public CardType cardType { get; set; }//牌型
public string talk { get; set; }
}
/// <summary>
/// 手牌排序
/// </summary>
/// <param name="Cards">手牌列表</param>
public void SortCards(List<int> Cards)
{ //判断卡牌先后
Cards.Sort(Comparator);
}
/// <summary>
/// 排序方法
/// </summary>
/// <param name="x">前一张牌</param>
/// <param name="y">后一张牌</param>
/// <returns></returns>
private int Comparator(int x, int y)
{
if (x >= y)
return 1;
else
return -1;
}
/// <summary>
/// 判断玩家是否可以出牌的方法
/// </summary>
/// <param name="MyCards">玩家想要出牌的个数</param>
/// <param name="MyCardType">玩家想要出牌牌型</param>
/// <param name="PrevCards">上家出牌的个数</param>
/// <param name="PreyCardType">上家出牌的类型</param>
/// <returns></returns>
public bool IsOverComePrev(List<int> MyCards, CardType MyCardType, List<int> PrevCards, CardType PrevCardType)
{ //玩家的牌和要出的牌不能为空
if (MyCards == null || PrevCards == null)
{
return false;
}
//玩家的牌型不能为空,要出的牌型不能是错误牌型
if (MyCardType == null || PrevCardType == CardType.Error_Card)
{
return false;
}
//玩家卡牌的个数
int MySize = MyCards.Count;
//要出牌的个数
int PreSize = PrevCards.Count;
//第一轮当没有出牌的时候,玩家先出牌
if (PreSize == 0 && MySize != 0)
{
return true;
}
//判断是不是王炸
if (PrevCardType == CardType.KingBomb_Card)
{ //是王炸,我不能出牌
return false;
}
else if (MyCardType == CardType.KingBomb_Card)
{
//我出王炸,肯定能出牌
return true;
}
//判断要出的不是炸弹,但我是炸弹的情况
if (PrevCardType != CardType.Bomb_Card && MyCardType == CardType.Bomb_Card)
{
return true;
}
//普通情况
SortCards(MyCards);//对我的牌排序
SortCards(PrevCards);//对上家出的牌排序
int MyGrade = getGrade(MyCards[0]);
int PrevGrade = getGrade(PrevCards[0]);
//单牌
if (PrevCardType == CardType.Single_Card && MyCardType == CardType.Single_Card)
{
// 单张可以大过上家的牌
return compareGrade(MyGrade, PrevGrade);
}
// 对子
else if (PrevCardType == CardType.Double_Card
&& MyCardType == CardType.Double_Card)
{
// 2张牌可以大过上家的牌
return compareGrade(MyGrade, PrevGrade);
}
// 3不带
else if (PrevCardType == CardType.Three_Card
&& MyCardType == CardType.Three_Card)
{
// 3张牌可以大过上家的牌
return compareGrade(MyGrade, PrevGrade);
}
// 3带2
//else if(PrevCardType == CardType.ThreeTwo_Card
// && MyCardType == CardType.ThreeTwo_Card)
//{
// MyGrade = getGrade(MyCards[2]);
// PrevGrade = getGrade(PrevCards[2]);
// return compareGrade(MyGrade, PrevGrade);
//}
// 炸弹
else if (PrevCardType == CardType.Bomb_Card
&& MyCardType == CardType.Bomb_Card)
{
// 4张牌可以大过上家的牌
return compareGrade(MyGrade, PrevGrade);
}
// 3带1
else if (PrevCardType == CardType.ThreeOne_Card
&& MyCardType == CardType.ThreeOne_Card )
{
// 3带1只需比较第2张牌的大小
MyGrade = getGrade(MyCards[1]);
PrevGrade = getGrade(PrevCards[1]);
return compareGrade(MyGrade, PrevGrade);
}
// 4带2
else if (PrevCardType == CardType.Four_TwoDouble_Card
&& MyCardType == CardType.Four_TwoDouble_Card)
{
// 4带2只需比较第3张牌的大小
MyGrade = getGrade(MyCards[2]);
PrevGrade = getGrade(PrevCards[2]);
}
// 顺子
else if (PrevCardType == CardType.Lian_Card
&& MyCardType == CardType.Lian_Card)
{
if (MySize != PreSize)
{
return false;
}
else
{
// 顺子只需比较最大的1张牌的大小
MyGrade = getGrade(MyCards[MySize - 1]);
PrevGrade = getGrade(PrevCards[PreSize - 1]);
return compareGrade(MyGrade, PrevGrade);
}
}
// 连对
else if (PrevCardType == CardType.Double_Lian_Card
&& MyCardType == CardType.Double_Lian_Card)
{
if (MySize != PreSize)
{
return false;
}
else
{
// 顺子只需比较最大的1张牌的大小
MyGrade = getGrade(MyCards[MySize - 1]);
PrevGrade = getGrade(PrevCards[PreSize - 1]);
return compareGrade(MyGrade, PrevGrade);
}
}
// 飞机不带牌
else if (PrevCardType == CardType.Feiji_Card
&&MyCardType == CardType.Feiji_Card)
{
if (MySize != PreSize)
{
return false;
}
else
{
// 顺子只需比较第5张牌的大小(特殊情况333444555666没有考虑,即12张的飞机,可以有2种出法)
MyGrade = getGrade(MyCards[4]);
PrevGrade = getGrade(PrevCards[4]);
return compareGrade(MyGrade, PrevGrade);
}
}
// 飞机带对子
else if (PrevCardType == CardType.Feiji_TwoSingle_Card
&& MyCardType == CardType.Feiji_TwoSingle_Card)
{
if (MySize != PreSize)
{
return false;
}
else
{
// 顺子只需比较第5张牌的大小(特殊情况333444555666没有考虑,即12张的飞机,可以有2种出法)
MyGrade = getGrade(MyCards[4]);
PrevGrade = getGrade(PrevCards[4]);
return compareGrade(MyGrade, PrevGrade);
}
}
// 飞机dai dui
else if (PrevCardType == CardType.Feiji_TwoDouble_Card
&& MyCardType == CardType.Feiji_TwoDouble_Card)
{
if (MySize != PreSize)
{
return false;
}
else
{
// 顺子只需比较第5张牌的大小(特殊情况333444555666没有考虑,即12张的飞机,可以有2种出法)
MyGrade = getGrade(MyCards[4]);
PrevGrade = getGrade(PrevCards[4]);
return compareGrade(MyGrade, PrevGrade);
}
}
//默认不出牌
return false;
}
/// <summary>
/// 判断我所有的牌中,是否有比上家大的牌
/// </summary>
/// <param name="myCards"></param>
/// <param name="prevCards"></param>
/// <param name="prevCardType"></param>
/// <returns></returns>
public bool isOvercomePrevHint(List<int> myCards, List<int> prevCards, CardType prevCardType)
{// 我的牌和上家的牌都不能为null
if (myCards == null || prevCards == null)
{
return false;
}
if (prevCardType == null)
{
return false;
}
// 默认情况:上家和自己想出的牌都符合规则
SortCards(myCards);// 对牌排序
SortCards(prevCards);// 对牌排序
// 上一首牌的个数
int prevSize = prevCards.Count;
int mySize = myCards.Count;
// 我先出牌,上家没有牌
if (prevSize == 0 && mySize != 0)
{
return true;
}
// 集中判断是否王炸,免得多次判断王炸
if (prevCardType == CardType.KingBomb_Card)
{
return false;
}
if (mySize >= 2)
{
List<int> cards = new List<int>();
cards.Add(myCards[mySize - 1]);
cards.Add(myCards[mySize - 2]);
if (isDuiWang(cards))
{
return true;
}
}
// 集中判断对方不是炸弹,我出炸弹的情况
if (prevCardType != CardType.Bomb_Card)
{
if (mySize < 4)
{
return false;
}
else
{
for (int i = 0; i < mySize - 3; i++)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i + 1]);
int grade2 = getGrade(myCards[i + 2]);
int grade3 = getGrade(myCards[i + 3]);
//判断四张牌是不是相等
if (grade1 == grade0 && grade2 == grade0
&& grade3 == grade0)
{
return true;
}
}
}
}
int prevGrade = getGrade(prevCards[0]);
// 比较两家的牌,
//我出和上家一种类型的牌,我比上家大
// 我出炸弹,比上家大
// 上家出单
if (prevCardType == CardType.Single_Card)
{
// 一张牌可以大过上家的牌
for (int i = mySize - 1; i >= 0; i--)
{
int grade = getGrade(myCards[i]);
//判断牌是否大过上家
if (grade > prevGrade)
{
// 只要有1张牌可以大过上家,则返回true
return true;
}
}
}
// 上家出对子
else if (prevCardType == CardType.Double_Card)
{
// 2张牌可以大过上家的牌
for (int i = mySize - 1; i >= 1; i--)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i - 1]);
//判断两张牌是不是相等
if (grade0 == grade1)
{ //判断牌是否大过上家
if (grade0 > prevGrade)
{
// 只要有1对牌可以大过上家,则返回true
return true;
}
}
}
}
// 上家出3不带
else if (prevCardType == CardType.Three_Card)
{
// 3张牌可以大过上家的牌
for (int i = mySize - 1; i >= 2; i--)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i - 1]);
int grade2 = getGrade(myCards[i - 2]);
//判断三张牌是不是相等
if (grade0 == grade1 && grade0 == grade2)
{ //判断三张的其中一张牌是否大过上家
if (grade0 > prevGrade)
{
// 只要3张牌可以大过上家,则返回true
return true;
}
}
}
}
// 上家出3带1
else if (prevCardType == CardType.ThreeOne_Card)
{
// 判断牌的数量是否是4张
if (mySize < 4)
{
return false;
}
// 3张牌可以大过上家的牌
for (int i = mySize - 1; i >= 2; i--)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i - 1]);
int grade2 = getGrade(myCards[i - 2]);
//判断三张是否相等
if (grade0 == grade1 && grade0 == grade2)
{
if (grade0 > prevGrade)
{
// 只要3张牌可以大过上家,则返回true
return true;
}
}
}
}
上家出3带2
//else if (prevCardType == CardType.ThreeTwo_Card)
//{
//判断牌的适量是否是5张
// if (mySize < 5)
// {
// return false;
// }
// // 3张牌可以大过上家的牌
// for (int i = mySize - 1; i >= 2; i--)
// {
// int grade0 = getGrade(myCards[i]);
// int grade1 = getGrade(myCards[i - 1]);
// int grade2 = getGrade(myCards[i - 2]);
// //判断是否三张相等
// if (grade0 == grade1 && grade0 == grade2)
// {
// if (grade0 > prevGrade)
// {
// // 只要3张牌可以大过上家,则返回true
// return true;
// }
// }
// }
//}
// 上家出炸弹
else if (prevCardType == CardType.KingBomb_Card)
{
// 4张牌可以大过上家的牌
for (int i = mySize - 1; i >= 3; i--)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i - 1]);
int grade2 = getGrade(myCards[i - 2]);
int grade3 = getGrade(myCards[i - 3]);
if (grade0 == grade1 && grade0 == grade2 && grade0 == grade3)
{
if (grade0 > prevGrade)
{
// 只要有4张牌可以大过上家,则返回true
return true;
}
}
}
}
// 上家出4带2
else if (prevCardType == CardType.Four_TwoDouble_Card)
{
// 判断牌的数量是否是8张
if (mySize < 8)
{
return false;
}
// 4张牌可以大过上家的牌
for (int i = mySize - 1; i >= 3; i--)
{
int grade0 = getGrade(myCards[i]);
int grade1 = getGrade(myCards[i - 1]);
int grade2 = getGrade(myCards[i - 2]);
int grade3 = getGrade(myCards[i - 3]);
if (grade0 == grade1 && grade0 == grade2 && grade0 == grade3)
{
// 只要有炸弹,则返回true
return true;
}
}
}
上家出4带1
//else if (prevCardType == CardType.Four_TwoSingle_Card)
//{
// // 判断牌的数量是否是5张
// if (mySize < 6)
// {
// return false;
// }
// // 4张牌可以大过上家的牌
// for (int i = mySize - 1; i >= 3; i--)
// {
// int grade0 = getGrade(myCards[i]);
// int grade1 = getGrade(myCards[i - 1]);
// int grade2 = getGrade(myCards[i - 2]);
// int grade3 = getGrade(myCards[i - 3]);
// //判断四张牌是否相等
// if (grade0 == grade1 && grade0 == g rade2 && grade0 == grade3)
// {
// // 只要有炸弹,则返回true
// return true;
// }
// }
//}
// 上家出顺子
else if (prevCardType == CardType.Lian_Card)
{
//玩家要出牌的数量小于需要出牌的数量
if (mySize < prevSize)
{
return false;
}
else
{
for (int i = mySize - 1; i >= prevSize - 1; i--)
{
List<int> cards = new List<int>();
//将需要出牌个数的我的手牌加入cards数组
for (int j = 0; j < prevSize; j++)
{
cards.Add(myCards[i - j]);
}
CardType myCardType = getCardType(cards).cardType;
if (myCardType == CardType.Lian_Card)
{
int myGrade2 = getGrade(cards[cards.Count - 1]); // 最大的牌在最后
int prevGrade2 = getGrade(prevCards[prevSize - 1]);// 最大的牌在最后)
//判断最大一张牌,比上家的牌的最大要大
if (myGrade2 > prevGrade2)
{
return true;
}
}
}
}
}
// 上家出连对
else if (prevCardType == CardType.Double_Lian_Card)
{ //要出数量比上家牌的数量少
if (mySize < prevSize)
{
return false;
}
else
{
for (int i = mySize - 1; i >= prevSize - 1; i--)
{
List<int> cards = new List<int>();
for (int j = 0; j < prevSize; j++)
{
cards.Add(myCards[i - j]);
}
CardType myCardType = getCardType(cards).cardType;
if (myCardType == CardType.Double_Lian_Card)
{
int myGrade2 = getGrade(cards[cards.Count - 1]); // 最大的牌在最后
int prevGrade2 = getGrade(prevCards[prevSize - 1]);// 最大的牌在最后)
//判断最大一张牌,比上家的牌要大
if (myGrade2 > prevGrade2)
{
return true;
}
}
}
}
}
// 上家出飞机
else if (prevCardType == CardType.Feiji_Card )
{ //要出牌的数量比上家的牌的数量少
if (mySize < prevSize)
{
return false;
}
else
{
for (int i = mySize - 1; i >= prevSize - 1; i--)
{
List<int> cards = new List<int>();
//将手牌加入card数组
for (int j = 0; j < prevSize; j++)
{
cards.Add(myCards[i - j]);
}
CardType myCardType = getCardType(cards).cardType;
if (myCardType == CardType.Feiji_Card)
{
int myGrade4 = getGrade(cards[4]);//
int prevGrade4 = getGrade(prevCards[4]);
//判断相连的第二个三张的牌比其他的要大
if (myGrade4 > prevGrade4)
{
return true;
}
}
}
}
}
// //上家出飞机带单
//else if (prevCardType == CardType.Feiji_TwoSingle_Card)
//{ //要出的牌的数量比上家牌的数量少
// if (mySize < prevSize)
// {
// return false;
// }
// else
// {
// for (int i = mySize - 1; i >= prevSize - 1; i--)
// {
// List<int> cards = new List<int>();
// for (int j = 0; j < prevSize; j++)
// {
// cards.Add(myCards[i - j]);
// }
// CardType myCardType = getCardType(cards).cardType;
// if (myCardType == CardType.Feiji_TwoSingle_Card)
// {
// int myGrade4 = getGrade(cards[4]);//
// int prevGrade4 = getGrade(prevCards[4]);
// //判断相连的第二个三张的牌比其他的要大
// if (myGrade4 > prevGrade4)
// {
// return true;
// }
// }
// }
// }
//}
//else if (prevCardType == CardType.Feiji_TwoDouble_Card)
//{
// if (mySize < prevSize)
// {
// return false;
// }
// else
// {
// for (int i = mySize - 1; i >= prevSize - 1; i--)
// {
// List<int> cards = new List<int>();
// for (int j = 0; j < prevSize; j++)
// {
// cards.Add(myCards[i - j]);
// }
// CardType myCardType = getCardType(cards).cardType;
// if (myCardType == CardType.Feiji_TwoDouble_Card)
// {
// int myGrade4 = getGrade(cards[4]);//
// int prevGrade4 = getGrade(prevCards[4]);
// //判断相连的第二个三张的牌比其他的要大
// if (myGrade4 > prevGrade4)
// {
// return true;
// }
// }
// }
// }
//}
// 默认不能出牌
return false;
}
/// <summary>
/// 定义要出牌的类型并给ui赋值
/// </summary>
/// <param name="myCards">我要出的牌型</param>
/// <returns></returns>
public GetCardInfo getCardType(List<int> myCards)
{
GetCardInfo dic = new GetCardInfo();
CardType cardType = CardType.Error_Card;
string talk = "要不起";
if (myCards != null)
{
// 大概率事件放前边,以减少代码运算次数
//给牌型赋值,给UI赋值
//判断是否是单张
if (isDan(myCards))
{
cardType = CardType.Single_Card;
talk = "一张" + (getGrade(myCards[0]));
}//判断是否是王炸
else if (isDuiWang(myCards))
{
cardType = CardType.KingBomb_Card;
talk = "王炸";
}//判断是否是对子
else if (isDuiZi(myCards))
{
cardType = CardType.Double_Card;
talk = "一对" + (getGrade(myCards[0]));
}//判断是否是炸弹
else if (isZhaDan(myCards))
{
cardType = CardType.Bomb_Card;
talk = "炸弹!";
}//判断是否是三带一
else if (isSanDaiYi(myCards) != -1)
{
cardType = CardType.ThreeOne_Card;
talk = "三带一";
}//判断是否三代二
else if (isSanDaiEr(myCards) != -1)
{
cardType = CardType.ThreeTwo_Card;
talk = "三带二";
}//判断是否是三张
else if (isSanBuDai(myCards))
{
cardType = CardType.Three_Card;
talk = "三张" + (getGrade(myCards[0]));
}//判断是否是顺子
else if (isShunZi(myCards))
{
cardType = CardType.Lian_Card;
talk = "顺子";
}
else if (isLianDui(myCards))
{
cardType = CardType.Double_Lian_Card;
talk = "连对";
}
else if (isSiDaiEr(myCards))
{
cardType = CardType.Four_TwoSingle_Card;
talk = "四带俩单";
}
else if (isSiDaiErDui(myCards))
{
cardType = CardType.Four_TwoDouble_Card;
talk = "四带俩对";
}
else if (isFeiJiBuDai(myCards))
{
cardType = CardType.Feiji_Card;
talk = "飞机没翅膀";
}
else if (isFeiJiDaiDan(myCards))
{
cardType = CardType.Feiji_TwoSingle_Card;
talk = "飞机单翅膀";
}
else if (isFeiJiDaiDui(myCards))
{
cardType = CardType.Feiji_TwoDouble_Card;
talk = "飞机双翅膀!";
}
}
dic.cardType = cardType;
dic.talk = talk;
return dic;
}
/// <summary>
/// 去掉两个王,顺子没有王和2
/// </summary>
/// <param name="mycards"></param>
/// <returns></returns>
private List<int> removeBigPai(List<int> mycards)
{
List<int> list = new List<int>();
if (mycards.Count != 0)
{
for (int i = 0; i < mycards.Count - 1; i++)
{
int grade = getGrade(mycards[i]);
if (grade < 15) list.Add(grade);
}
return list;
}
return list;
}
/// <summary>
/// 判断牌型是否是单牌
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isDan(List<int> myCards)
{
// 默认不是单
bool flag = false;
if (myCards != null && myCards.Count == 1)
{
flag = true;
}
return flag;
}
/// <summary>
/// 判断是否是对子
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isDuiZi(List<int> myCards)
{
// 默认不是对子
bool flag = false;
//出牌牌不为空并且数量只能是两张,并且两张值必须相等
if (myCards != null && myCards.Count == 2)
{
int grade0 = getGrade(myCards[0]);
int grade1 = getGrade(myCards[1]);
if (grade0 == grade1)
{
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断是否是炸弹
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isZhaDan(List<int> myCards)
{
// 默认不是炸弹
bool flag = false;
//出牌不能为空,并且数量要等于4
if (myCards != null && myCards.Count == 4)
{
//取得四张牌并判断四张牌是否相等
int[] grades = new int[4];
grades[0] = getGrade(myCards[0]);
grades[1] = getGrade(myCards[1]);
grades[2] = getGrade(myCards[2]);
grades[3] = getGrade(myCards[3]);
if ((grades[1] == grades[0]) && (grades[2] == grades[0])
&& (grades[3] == grades[0]))
{
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断牌型是否是三带一
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public int isSanDaiYi(List<int> myCards)
{
int flag = -1;
// 默认不是3带1,判断卡牌必须是4
if (myCards != null && myCards.Count == 4)
{
// 对牌进行排序
SortCards(myCards);
int[] grades = new int[4];
grades[0] = getGrade(myCards[0]);
grades[1] = getGrade(myCards[1]);
grades[2] = getGrade(myCards[2]);
grades[3] = getGrade(myCards[3]);
// 暂时认为炸弹不为3带1
if ((grades[1] == grades[0]) && (grades[2] == grades[0])
&& (grades[3] == grades[0]))
{
return -1;
}
// 3带1,被带的牌在牌头
else if ((grades[1] == grades[0] && grades[2] == grades[0]))
{
return 0;
}
// 3带1,被带的牌在牌尾
else if (grades[1] == grades[3] && grades[2] == grades[3])
{
return 3;
}
}
return flag;
}
/// <summary>
/// 判断是否三带二
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public int isSanDaiEr(List<int> myCards)
{
int flag = -1;
// 默认不是3带2,卡牌数量必须是5
if (myCards != null && myCards.Count == 5)
{
// 对牌进行排序
SortCards(myCards);
int[] grades = new int[5];
//取得五张牌
grades[0] = getGrade(myCards[0]);
grades[1] = getGrade(myCards[1]);
grades[2] = getGrade(myCards[2]);
grades[3] = getGrade(myCards[3]);
grades[4] = getGrade(myCards[4]);
//判断三张是否相等,一对是否相等
// 3带2,被带的牌在牌头
if ((grades[1] == grades[0] && grades[2] == grades[3] && grades[4] == grades[3]))
{
return 0;
}
// 3带,被带的牌在牌尾
else if (grades[0] == grades[1] && grades[2] == grades[1] && grades[4] == grades[3])
{
return 3;
}
}
return flag;
}
/// <summary>
/// 判断是否是三张
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isSanBuDai(List<int> myCards)
{
// 默认不是3张
bool flag = false;
//判断卡牌数量等于3,取得三张牌并判断是否相等
if (myCards != null && myCards.Count == 3)
{
int[] grades = new int[3];
grades[0] = getGrade(myCards[0]);
grades[1] = getGrade(myCards[1]);
grades[2] = getGrade(myCards[2]);
if (grades[0] == grades[1] && grades[2] == grades[0])
{
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断是否是顺子
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isShunZi(List<int> myCards)
{
// 默认是顺子
bool flag = true;
if (myCards != null)
{
int size = myCards.Count;
// 顺子牌的个数在5到12之间
if (size < 5 || size > 12)
{
return false;
}
// 对牌进行排序
SortCards(myCards);
for (int n = 0; n < size - 1; n++)
{
int prev = getGrade(myCards[n]);
int next = getGrade(myCards[n + 1]);
// 小王、大王、2不能加入顺子
if (prev == 17 || prev == 16 || prev == 15 || next == 17
|| next == 16 || next == 15)
{
flag = false;
break;
}
else
{ //判断牌值是否连续,不连续就不是顺子
if (prev - next != -1)
{
flag = false;
break;
}
}
}
}
return flag;
}
/// <summary>
/// 判断是否是连对
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isLianDui(List<int> myCards)
{
// 默认是连对
bool flag = true;
if (myCards == null)
{
flag = false;
return flag;
}
int size = myCards.Count;
//判断牌数书否大于6并且牌数不是奇数
if (size < 6 || size % 2 != 0)
{
flag = false;
}
else
{
// 对牌进行排序
SortCards(myCards);
for (int i = 0; i < size; i = i + 2)
{ //判断两张牌是否是对子
if (getGrade(myCards[i]) != getGrade(myCards[i + 1]))
{
flag = false;
break;
}
//判断不是对子的两张牌的牌值是否是连续的
if (i < size - 2)
{
if (getGrade(myCards[i]) - getGrade(myCards[i + 2]) != -1)
{
flag = false;
break;
}
}
}
}
return flag;
}
/// <summary>
/// 判断是否是四带两单
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isSiDaiEr(List<int> myCards)
{
bool flag = false;
//手牌不能为空,并且数量大于6
if (myCards != null && myCards.Count == 6)
{ //将要出的牌拿去判断,是否是四张
CardType_Index carT_index = CardIndexCompute(myCards);
if (carT_index.Four_index.Count == 1 && carT_index.Three_index.Count == 0)
{
if (carT_index.Single_index.Count == 2 || carT_index.Double_index.Count == 1)
{
flag = true;
}
}
}
return flag;
}
/// <summary>
/// 判断是否是四带两对,判断方法与四带两单一样
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isSiDaiErDui(List<int> myCards)
{
bool flag = false;
if (myCards != null && myCards.Count == 8)
{
CardType_Index carT_index = CardIndexCompute(myCards);
if (carT_index.Four_index.Count == 1 && carT_index.Three_index.Count == 0)
{
if (carT_index.Double_index.Count == 2)
{
flag = true;
}
}
}
return flag;
}
/// <summary>
/// 判断是否是飞机
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isFeiJiBuDai(List<int> myCards)
{
bool flag = false;
if (myCards != null && myCards.Count % 3 == 0)
{
CardType_Index carT_index = CardIndexCompute(myCards);
if (carT_index.Three_index.Contains(15)) //飞机主体不能带2
{
return false;
}
//对要出的牌进行排序
SortCards(carT_index.Three_index);
//判断两个三张是否是连续的
for (int i = 0; i < carT_index.Three_index.Count - 1; i++)
{ //如果两个三张中两个牌值相减不为1那就不是连续的
if (carT_index.Three_index[i + 1] - carT_index.Three_index[i] != 1)
{
return false;
}
}
//飞机不带的模型是四张为0,三张不为0,对子为0,单张为0
if (carT_index.Four_index.Count == 0 && carT_index.Three_index.Count != 0 && carT_index.Double_index.Count == 0 && carT_index.Single_index.Count == 0)
{
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断是否是飞机带两单,先判断是否是飞机,然后在判断是否有两张单牌
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isFeiJiDaiDan(List<int> myCards)
{
bool flag = false;
if (myCards != null && myCards.Count % 4 == 0)
{
CardType_Index carT_index = CardIndexCompute(myCards);
//飞机三张中不能有2
if (carT_index.Three_index.Contains(15))
{
return false;
}
SortCards(carT_index.Three_index);
//判断是否是飞机
for (int i = 0; i < carT_index.Three_index.Count - 1; i++)
{
if (carT_index.Three_index[i + 1] - carT_index.Three_index[i] != 1)
{
return false;
}
}
//飞机带单的模型是 4=0,3!=0,2*2 + 1 = 主体数(即比如 333 444 555 可以带 667 678)
if (carT_index.Four_index.Count == 0 && carT_index.Three_index.Count != 0)
{
if (carT_index.Double_index.Count * 2 + carT_index.Single_index.Count == carT_index.Three_index.Count)
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断是否是飞机带两对,原理和上面的带单一样
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isFeiJiDaiDui(List<int> myCards)
{
bool flag = false;
if (myCards != null && myCards.Count % 5 == 0)
{
CardType_Index carT_index = CardIndexCompute(myCards);
//飞机三张不能有2
if (carT_index.Three_index.Contains(15))
{
return false;
}
SortCards(carT_index.Three_index);
//判断是否是飞机
for (int i = 0; i < carT_index.Three_index.Count - 1; i++) //飞机的主体必须是连续的,如333 555就不行
{
if (carT_index.Three_index[i + 1] - carT_index.Three_index[i] != 1)
{
return false;
}
}
//飞机带对的模型是 4=0,3!=0,2!=0且 2=3, 1 = 0
if (carT_index.Four_index.Count == 0 && carT_index.Three_index.Count != 0)
{
if (carT_index.Double_index.Count == carT_index.Three_index.Count && carT_index.Single_index.Count == 0)
flag = true;
}
}
return flag;
}
/// <summary>
/// 判断是否是王炸,是返回true
/// </summary>
/// <param name="myCards"></param>
/// <returns></returns>
public bool isDuiWang(List<int> myCards)
{
// 默认不是对王
bool flag = false;
if (myCards != null && myCards.Count == 2)
{
// 只有小王和大王的value之和才可能是33
int[] grades = new int[2];
grades[0] = getGrade(myCards[0]);
grades[1] = getGrade(myCards[1]);
if (grades[0] + grades[1] == 33)
{
flag = true;
}
}
return flag;
}
/// <summary>
/// 获得牌值
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public int getGrade(int index)
{
GameObject pai = GameObject.Find(index.ToString());
int grade = pai.GetComponent<CardObj>().Value;
return grade;
}
/// <summary>
/// 比较两个牌的大小
/// </summary>
/// <param name="grade1"></param>
/// <param name="grade2"></param>
/// <returns></returns>
private bool compareGrade(int grade1, int grade2)
{
return grade1 > grade2;
}
/// <summary>
/// 计算手牌中,单牌,对子,三张,四张的个数各有多少
/// </summary>
/// <param name="mycards"></param>
/// <returns></returns>
public CardType_Index CardIndexCompute(List<int> mycards)
{
CardType_Index cardT_index;
//为四种牌型新建一个list
cardT_index.Single_index = new List<int>();
cardT_index.Double_index = new List<int>();
cardT_index.Three_index = new List<int>();
cardT_index.Four_index = new List<int>();
List<int> pre = new List<int>();
for (int i = 0; i < mycards.Count; i++)
{
pre.Add(getGrade(mycards[i]));
}
var vs = from int p in pre group p by p into g select new { g, num = g.Count() };
//将所对应的牌型放入相对应的list中
foreach (var v in vs)
{
if (v.num == 4)
{
cardT_index.Four_index.Add(v.g.Key);
}
else if (v.num == 3)
{
cardT_index.Three_index.Add(v.g.Key);
}
else if (v.num == 2)
{
cardT_index.Double_index.Add(v.g.Key);
}
else if (v.num == 1)
{
cardT_index.Single_index.Add(v.g.Key);
}
}
return cardT_index;
}
}