斗地主判断牌型源码

这是看着别人的代码写的，这样写虽然很全面，但是毫无条理，我吧牌型打完之后感觉很不好，所以放弃，我给每一段加了注释，贴出代码让大家看一看

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;

    }

}