/// <summary>
        /// 计算确定的牌型MatchCardFacesInfo
        /// </summary>
        /// <returns></returns>
        public MatchCardFacesInfo ComputeMatchCardFacesInfo(CardFace[] cardFaces, CardsType cardsType = CardsType.None)
        {
            CardFace[] computedCardFaces = ComputeCardFaces(cardFaces, ref cardsType);
            CardFace[] laiziCardFaces    = new CardFace[computedCardFaces.Length];
            int        idx;

            CardFace[] removeLaizi = new CardFace[1];

            for (int i = 0; i < computedCardFaces.Length; i++)
            {
                idx = CardsTransform.Instance.FindCardFace(cardFaces, computedCardFaces[i]);
                if (idx != -1)
                {
                    laiziCardFaces[i] = cardFaces[idx];
                    cardFaces         = CardsTransform.Instance.CreateDelFaceValues(cardFaces, new CardFace[] { cardFaces[idx] });
                }
                else
                {
                    cardFaces         = CardsTransform.Instance.RemoveLaiziByCount(cardFaces, laizi, 1, removeLaizi);
                    laiziCardFaces[i] = removeLaizi[0];
                }
            }

            MatchCardFacesInfo matchInfo = new MatchCardFacesInfo()
            {
                computedCardFaces = computedCardFaces,
                laiziCardFaces    = laiziCardFaces,
                type = cardsType
            };

            return(matchInfo);
        }
        /// <summary>
        /// 计算牌的分值
        /// </summary>
        /// <param name="cardFaces">手牌</param>
        /// <returns></returns>
        public float CalCardsScore(CardFace[] cardFaces)
        {
            MatchCardFacesInfo matchInfo = match.ComputeMatchCardFacesInfo(cardFaces);

            nextSlotCreater.CreateAllCardsTypeArray(matchInfo.computedCardFaces);
            CardsTypeInfo info = nextSlotCreater.GetMaxScoreCardsTypeInfo();

            return(CalCardsScore(info, null));
        }
        /// <summary>
        /// 判断是否为三顺子
        /// </summary>
        /// <param name="formatCards">CardInfo[] formatCards = CardsTransform.Instance.CreateFormatCards(cardValues, ref laiziCount);</param>
        /// <param name="laiziCount"></param>
        /// <param name="outFaceValues"></param>
        /// <returns></returns>
        public bool IsSanShunZi(CardInfo[] formatCards, int laiziCount, CardFace[] outFaceValues, CardFace[] outComputedFaceValues)
        {
            CardInfo[] cards = formatCards;

            bool ret = false;
            int  n   = 0;
            List <CardsTypeInfo> shunziList  = new List <CardsTypeInfo>();
            List <CardsTypeInfo> shunziList2 = new List <CardsTypeInfo>();

            CardsTypeCreater creater = new CardsTypeCreater();

            creater.CreateShunziArray(cards, laiziCount);
            shunziList.Clear();
            shunziList.AddRange(creater.ShunziList);
            shunziList.AddRange(creater.TonghuashunList);

            for (int i = 0; i < shunziList.Count; i++)
            {
                CardInfo[] cards2      = CardsTransform.Instance.CreateRemoveFaceValues(cards, shunziList[i].cardFaceValues);
                int        laiziCount2 = laiziCount - shunziList[i].laiziCount;
                if (laiziCount2 < 0)
                {
                    continue;
                }

                CardsTypeCreater creater2 = new CardsTypeCreater();
                creater2.CreateShunziArray(cards2, laiziCount2);
                shunziList2.Clear();
                shunziList2.AddRange(creater2.ShunziList);
                shunziList2.AddRange(creater2.TonghuashunList);

                for (int j = 0; j < shunziList2.Count; j++)
                {
                    CardInfo[] cards3      = CardsTransform.Instance.CreateRemoveFaceValues(cards2, shunziList2[j].cardFaceValues);
                    int        laiziCount3 = laiziCount2 - shunziList2[j].laiziCount;
                    if (laiziCount3 < 0)
                    {
                        continue;
                    }

                    if (cards3.Length == 3 &&
                        cards3[0].value + 1 == cards3[1].value &&
                        cards3[1].value + 1 == cards3[2].value)
                    {
                        for (int m = 0; m < 3; m++)
                        {
                            outFaceValues[n++] = CardsTransform.Instance.GetCardFace(cards3[m].value, cards3[m].suit);
                        }
                    }
                    else if (cards3.Length == 2 && laiziCount3 >= 1 &&
                             (cards3[0].value + 1 == cards3[1].value || cards3[0].value + 2 == cards3[1].value))
                    {
                        outFaceValues[n++] = CardsTransform.Instance.GetCardFace(cards3[0].value, cards3[0].suit);
                        outFaceValues[n++] = CardsTransform.Instance.GetCardFace(cards3[1].value, cards3[1].suit);
                        outFaceValues[n++] = CardFace.RedJoker;
                    }
                    else if (cards3.Length == 1 && laiziCount3 >= 2)
                    {
                        outFaceValues[n++] = CardsTransform.Instance.GetCardFace(cards3[0].value, cards3[0].suit);
                        outFaceValues[n++] = CardFace.RedJoker;
                        outFaceValues[n++] = CardFace.RedJoker;
                    }
                    else if (cards3.Length == 0 && laiziCount3 >= 3)
                    {
                        outFaceValues[n++] = CardFace.RedJoker;
                        outFaceValues[n++] = CardFace.RedJoker;
                        outFaceValues[n++] = CardFace.RedJoker;
                    }
                    else
                    {
                        continue;
                    }

                    for (int m = 0; m < shunziList[i].cardFaceValues.Length; m++)
                    {
                        outFaceValues[n++] = shunziList[i].cardFaceValues[m];
                    }
                    for (int m = shunziList[i].cardFaceValues.Length; m < 5; m++)
                    {
                        outFaceValues[n++] = CardFace.RedJoker;
                    }

                    for (int m = 0; m < shunziList2[j].cardFaceValues.Length; m++)
                    {
                        outFaceValues[n++] = shunziList2[j].cardFaceValues[m];
                    }
                    for (int m = shunziList2[j].cardFaceValues.Length; m < 5; m++)
                    {
                        outFaceValues[n++] = CardFace.RedJoker;
                    }

                    ret = true;
                    break;
                }

                if (ret == true)
                {
                    break;
                }
            }

            if (ret == false)
            {
                return(false);
            }

            //
            CardsTypeMatch match = new CardsTypeMatch();

            match.SetLaizi(laizi);

            List <CardFace> cardFaceList = new List <CardFace>();

            for (int i = 0; i <= 2; i++)
            {
                cardFaceList.Add(outFaceValues[i]);
            }
            MatchCardFacesInfo matchInfo1 = match.ComputeMatchCardFacesInfo(cardFaceList.ToArray(), CardsType.ShunZi);

            //
            cardFaceList.Clear();
            for (int i = 3; i <= 7; i++)
            {
                cardFaceList.Add(outFaceValues[i]);
            }
            MatchCardFacesInfo matchInfo2 = match.ComputeMatchCardFacesInfo(cardFaceList.ToArray(), CardsType.ShunZi);

            //
            cardFaceList.Clear();
            for (int i = 8; i <= 12; i++)
            {
                cardFaceList.Add(outFaceValues[i]);
            }
            MatchCardFacesInfo matchInfo3 = match.ComputeMatchCardFacesInfo(cardFaceList.ToArray(), CardsType.ShunZi);

            int k = 0;

            n = 0;

            for (int i = 0; i < matchInfo1.laiziCardFaces.Length; i++)
            {
                if (matchInfo1.laiziCardFaces[i] == CardFace.RedJoker)
                {
                    outFaceValues[n++]         = CardFace.Laizi;
                    outComputedFaceValues[k++] = matchInfo1.computedCardFaces[i];
                }
                else
                {
                    outFaceValues[n++] = matchInfo1.laiziCardFaces[i];
                }
            }

            for (int i = 0; i < matchInfo2.laiziCardFaces.Length; i++)
            {
                if (matchInfo2.laiziCardFaces[i] == CardFace.RedJoker)
                {
                    outFaceValues[n++]         = CardFace.Laizi;
                    outComputedFaceValues[k++] = matchInfo2.computedCardFaces[i];
                }
                else
                {
                    outFaceValues[n++] = matchInfo2.laiziCardFaces[i];
                }
            }

            for (int i = 0; i < matchInfo3.laiziCardFaces.Length; i++)
            {
                if (matchInfo3.laiziCardFaces[i] == CardFace.RedJoker)
                {
                    outFaceValues[n++]         = CardFace.Laizi;
                    outComputedFaceValues[k++] = matchInfo3.computedCardFaces[i];
                }
                else
                {
                    outFaceValues[n++] = matchInfo3.laiziCardFaces[i];
                }
            }

            return(true);
        }