csharp/2881099/FightLandlord/2881099-FightLandlord-9ba79cb/src/BetGame.DDZ.Robot/LandLord.cs

LandLord.cs
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;

namespace GameServer.Script.CsScript.Action
{
    #region
    /// 
    /// 扑克牌的数据类
    /// http://wenku.baidu.com/link?url=FYqoqOlcz25NbwBARplHJBUrJphrvuW7818vzqodndwgmTDtlhaef-a1rAyM1oHEBc81yH8JS1SFuT_xVS8e1QYpMuRrp8yOSFFWfaBptzq
    /// 
    public clast LandLord
    {
        /// 
        /// 红
        /// 
        private static int[] arrHeart = { 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115 };
        /// 
        /// 黑                            215, 
        /// 
        private static int[] arrSpade = { 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215 };
        /// 
        /// 梅                            315,
        /// 
        private static int[] arrClub = { 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315 };
        /// 
        /// 方
        /// 
        private static int[] arrDiamond = { 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415 };
        /// 
        /// 大王17 ,小王16
        /// 
        private static int[] arrKing = { 16, 17 };

        /// 
        /// 一付Poker 52张   
        /// 
        private Queue ALLPoker;
        private const int mNumALLPoker = 54;

        /// 
        /// 单个用户牌的个数      临汾地方规则 
        /// 
        private static int _NumPerUser = 17;

        #region 洗牌 分牌
        /// 
        /// 洗牌, 让所有纸牌,随机顺序
        /// 
        private void Shuffle()
        {
            ALLPoker = new Queue();
            List arrPoker = new List();
            arrPoker.AddRange(arrHeart);
            arrPoker.AddRange(arrSpade);
            arrPoker.AddRange(arrClub);
            arrPoker.AddRange(arrDiamond);
            arrPoker.AddRange(arrKing);
            ////TDisruptedHelper _thelper = new TDisruptedHelper(arrPoker.ToArray());
            ////arrPoker = _thelper.GetDisruptedItems().ToList();
            ////for (int i = 0; i < arrPoker.Count; i++)
            ////{
            ////    ALLPoker.Enqueue(arrPoker[i]);
            ////}
            //随机生成排序这x张牌
            ALLPoker = new Queue(ToolsEx.DisrupteList(arrPoker));
            if (ALLPoker.Count != mNumALLPoker)
            {
                TraceLogEx.Error("201610212116ll ALLPoker.Count != mNumALLPoker 即扑克初始不正确");
            }
        }

        /// 
        /// 初始化后 把纸牌分给三家 
        ///  
        /// 
        public Dictionary DistributePoker(out Queue LeftCard, int userCount)
        {
            if (userCount != 3)
            {
                TraceLogEx.Error("201610212210ll  userCount > 6 || userCount < 2   " + userCount);
                LeftCard = null;
                return null;
            }
            Shuffle();
            if (ALLPoker.Count != mNumALLPoker)
            {
                TraceLogEx.Error("20120824154401 ALLPoker!= " + mNumALLPoker);
                LeftCard = null;
                return null;
            }
            Dictionary retDic = new Dictionary();

            //  1 号的数组 牌
            List firstArr = new List();
            //  2 号的数组 牌                          
            List secondArr = new List();
            //  3 号的数组 牌                          
            List thirdArr = new List();

            for (int i = 0; i < _NumPerUser; i++)
            {
                firstArr.Add(ALLPoker.Dequeue());
                secondArr.Add(ALLPoker.Dequeue());
                thirdArr.Add(ALLPoker.Dequeue());
            }

            retDic.Add(1, firstArr);
            retDic.Add(2, secondArr);
            retDic.Add(3, thirdArr);

            LeftCard = ALLPoker;
            if (ALLPoker.Count != 3)
            {
                TraceLogEx.Error(" 20120824154501ll 给地主抓的牌ALLPoker!= 3. 分牌都分错了");
            }
            return retDic;
        }

        #endregion

        #region   排序 

        /// 
        /// 去掉花色 从大到小排序 
        /// 
        /// 
        /// 
        public static List OrderPaiLord(List paiarr)
        {
            List _tempList = new List(paiarr);
            for (int i = 0; i < _tempList.Count; i++)
            {
                if (_tempList[i] > 100) _tempList[i] %= 100;
            }
            int[] temparr = _tempList.ToArray();
            Array.Sort(temparr);
            List _ASCList = temparr.ToList();
            _ASCList.Reverse();//默认是升序反转一下就降序了
            return _ASCList;
        }
        /// 
        ///  从大到小排序      保留花色
        /// 
        /// 
        /// 
        public static List OrderPaiLordWithColor(List paiarr)
        {
            List _tempList = new List(paiarr);
            for (int i = 0; i < _tempList.Count; i++)
            {
                if (_tempList[i] > 100) _tempList[i] %= 100;
            }
            int[] temparr = _tempList.ToArray();
            Array.Sort(temparr);
            List _ASCList = temparr.ToList();
            _ASCList.Reverse();//默认是升序反转一下就降序了

            //带上花色,有点小复杂 
            Dictionary _dicPoker2Count = GetPoker_Count(_ASCList);
            Dictionary _dicPoker2CountUsed = new Dictionary();
            for (int j = 0; j < _ASCList.Count; j++)
            {
                if (!_dicPoker2CountUsed.ContainsKey(_ASCList[j])) _dicPoker2CountUsed.Add(_ASCList[j], 1);

                for (int c = _dicPoker2CountUsed[_ASCList[j]]; c  PG.Count - amount; i--) //从小到大比较相邻牌是否相同 
            {
                if (PG[i] == PG[i - 1]) IsSame2 = true;
                else
                {
                    IsSame2 = false;
                    break;
                }
            }
            if (IsSame1 || IsSame2) return true;
            else return false;
        }

        ///  
        /// 判断牌组是否为顺子 
        ///  
        /// 牌组 
        /// 是否为顺子 
        public static bool IsStraight(List PG)
        {
            bool IsStraight = false;
            foreach (int poker in PG)//不能包含2、小王、大王 
            {
                if (poker == (int)LordPokerValueNoColorEnum.p15 || poker == (int)LordPokerValueNoColorEnum.jokers16 || poker == (int)LordPokerValueNoColorEnum.jokersb17)
                {
                    IsStraight = false;
                    return IsStraight;
                }
            }
            for (int i = 0; i < PG.Count - 1; i++)
            {
                if (PG[i] - 1 == PG[i + 1]) IsStraight = true;
                else
                {
                    IsStraight = false;
                    break;
                }
            }
            return IsStraight;
        }

        ///  
        /// 判断牌组是否为连对 
        ///  
        /// 牌组 
        /// 是否为连对 
        public static bool IsLinkPair(List PG)
        {
            bool IsLinkPair = false;
            foreach (int poker in PG) //不能包含2、小王、大王 
            {
                if (poker == (int)LordPokerValueNoColorEnum.p15 || poker == (int)LordPokerValueNoColorEnum.jokers16 || poker == (int)LordPokerValueNoColorEnum.jokersb17)
                {
                    IsLinkPair = false;
                    return IsLinkPair;
                }
            }
            //首先比较是否都为对子,再比较第一个对子的点数-1是否等于第二个对子,最后检察最小的两个是否为对子(这里的for循环无法检测到最小的两个,所以需要拿出来单独检查) 
            for (int i = 0; i < PG.Count - 2; i += 2)
            {
                if (PG[i] == PG[i + 1] && PG[i] - 1 == PG[i + 2] && PG[i + 2] == PG[i + 3]) IsLinkPair = true;
                else
                {
                    IsLinkPair = false;
                    break;
                }
            }
            return IsLinkPair;
        }

        ///  
        /// 判断牌组是否为连续三张牌,飞机,飞机带翅膀 
        /// //判断三张牌方法为判断两两相邻的牌,如果两两相邻的牌相同,则count自加1.最后根据count的值判断牌的类型为多少个连续三张 
        ///  
        /// 牌组 
        /// 是否为连续三张牌 
        public static bool IsThreeLinkPokers(List PG, out int _threeCount)
        {
            bool IsThreeLinkPokers = false;
            _threeCount = 0; //飞机的数量 
            PG = SameThreeSort(PG); //排序,把飞机放在前面 
            for (int i = 2; i < PG.Count; i++) //得到牌组中有几个飞机 
            {
                if (PG[i] == PG[i - 1] && PG[i] == PG[i - 2]) _threeCount++;
            }
            if (_threeCount > 0) //当牌组里面有三个时 
            {
                if (_threeCount > 1) //当牌组为飞机时 
                {
                    for (int i = 0; i < _threeCount * 3 - 3; i += 3) //判断飞机之间的点数是否相差1 
                    {//2点不能当飞机出 -------------特殊规则 ------------------
                        if (PG[i] != (int)LordPokerValueNoColorEnum.p15 && PG[i] - 1 == PG[i + 3]) IsThreeLinkPokers = true;
                        else
                        {
                            IsThreeLinkPokers = false;
                            break;
                        }
                    }
                }
                else IsThreeLinkPokers = true; //牌组为普通三个,直接返回true  
            }
            else IsThreeLinkPokers = false;
            return IsThreeLinkPokers;
        }

        ///  
        /// 对飞机和飞机带翅膀进行排序,把飞机放在前面,翅膀放在后面. 
        ///  
        /// 牌组 
        /// 是否为连续三张牌 
        public static List SameThreeSort(List PG)
        {
            int _theFourPoker = 0; //如果把4张当三张出并且带4张的另外一张,就需要特殊处理,这里记录出现这种情况的牌的点数. 
            bool FindedThree = false; //已找到三张相同的牌 

            List tempPokerGroup = new List();       //记录三张相同的牌 
            //write by jsw  tempPokerGroup = new tempPokerGroup()
            int count = 0; //记录在连续三张牌前面的翅膀的张数 
            int Four = 0; // 记录是否连续出现三三相同,如果出现这种情况则表明出现把4张牌(炸弹)当中的三张和其他牌配成飞机带翅膀,并且翅膀中有炸弹牌的点数. 
            // 比如有如下牌组: 998887777666 玩家要出的牌实际上应该为 888777666带997,但是经过从大到小的排序后变成了998887777666 一不美观,二不容易比较. 
            for (int i = 2; i < PG.Count; i++) //直接从2开始循环,因为PG[0],PG[1]的引用已经存储在其他变量中,直接比较即可 
            {
                if (PG[i] == PG[i - 2] && PG[i] == PG[i - 1])// 比较PG[i]与PG[i-1],PG[i]与PG[i-2]是否同时相等,如果相等则说明这是三张相同牌 
                {
                    if (Four >= 1) //默认的Four为0,所以第一次运行时这里为false,直接执行else 
                    //一旦连续出现两个三三相等,就会执行这里的if 
                    {
                        _theFourPoker = PG[i]; //当找到四张牌时,记录下4张牌的点数 
                        int _tempchangePoker;
                        for (int k = i; k > 0; k--) //把四张牌中的一张移动到最前面. 
                        {
                            _tempchangePoker = PG[k];
                            PG[k] = PG[k - 1];
                            PG[k - 1] = _tempchangePoker;
                        }
                        count++; //由于此时已经找到三张牌,下面为count赋值的程序不会执行,所以这里要手动+1 
                    }
                    else
                    {
                        Four++; //记录本次循环,因为本次循环找到了三三相等的牌,如果连续两次找到三三相等的牌则说明找到四张牌(炸弹) 
                        tempPokerGroup.Add(PG[i]); //把本次循环的PG[i]记录下来,即记录下三张牌的点数 
                    }
                    FindedThree = true; //标记已找到三张牌 
                }
                else
                {
                    Four = 0; //没有找到时,连续找到三张牌的标志Four归零 
                    if (!FindedThree) //只有没有找到三张牌时才让count增加.如果已经找到三张牌,则不再为count赋值. 
                    {
                        count = i - 1;
                    }
                }
            }
            foreach (int tempPoker in tempPokerGroup) //迭代所有的三张牌点数 
            {
                int _tempchangePoker; //临时交换Poker 
                for (int i = 0; i < PG.Count; i++) //把所有的三张牌往前移动 
                {
                    if (PG[i] == tempPoker) //当PG[i]等于三张牌的点数时 
                    {
                        if (PG[i] == _theFourPoker) //由于上面已经把4张牌中的一张放到的最前面,这张牌也会与tempPoker相匹配所以这里进行处理 
                        // 当第一次遇到四张牌的点数时,把记录四张牌的FourPoker赋值为null,并中断本次循环.由于FourPoker已经为Null,所以下次再次遇到四张牌的点数时会按照正常情况执行. 
                        {
                            _theFourPoker = 0;
                            continue;
                        }
                        _tempchangePoker = PG[i - count];
                        PG[i - count] = PG[i];
                        PG[i] = _tempchangePoker;
                    }
                }
            }
            return PG;
        }

        public static Dictionary GetPoker_Count(List paiList)
        {
            Dictionary _dicPoker2Count = new Dictionary();
            foreach (int poke in paiList)
            {
                if (_dicPoker2Count.ContainsKey(poke)) _dicPoker2Count[poke]++;
                else _dicPoker2Count.Add(poke, 1);
            }
            return _dicPoker2Count;
        }
        /// 
        /// 获取三带一,飞机牌列中的三张的牌 
        /// 
        /// 无花色
        /// 结果 会从大到小排序 
        private static List GetSameMoreThan3(List paiList)
        {
            Dictionary _dicPoker2Count = GetPoker_Count(paiList);
            List _temp = new List();
            foreach (int key in _dicPoker2Count.Keys)
            {
                if (_dicPoker2Count[key] >= 3) _temp.Add(key);
            }
            _temp = OrderPaiLord(_temp);
            if (_temp.Count == 0) TraceLogEx.Error("201701262114 fetal error!");
            return _temp;
        }

        //无序的牌组通过以上代码的洗礼,已经变成了非常容易比较的牌组了。 
        //比较牌组的大小就非常简单了。首先排除特殊牌组炸弹,双王。 
        //然后再比较普通牌组的第一张牌就可以了。下面是牌组比较的代码,重写了PokerGroup的大于号运算符
        /// 
        /// shoupaiList > targetList  返回True    
        /// 1.确保牌是符合基本规范的才有效, 
        /// 2.不炸弹要确保牌型相同       
        /// 
        /// 
        /// 
        /// 
        public static bool ComparePoker(List shoupaiList, List targetList)
        {
            bool IsGreater = false;
            LordPokerTypeEnum _shoupaiType = GetLordType(shoupaiList);
            LordPokerTypeEnum _targetType = GetLordType(targetList);
            if (_shoupaiType == LordPokerTypeEnum.Error || _targetType == LordPokerTypeEnum.Error) return false;
            if (_shoupaiType != _targetType)
            {   //先比类型
                int _shoupaitypevalue = 0;
                if (_diclordvalue.ContainsKey(_shoupaiType)) _shoupaitypevalue = _diclordvalue[_shoupaiType];
                int _targettypevalue = 0;
                if (_diclordvalue.ContainsKey(_targetType)) _targettypevalue = _diclordvalue[_targetType];

                IsGreater = _shoupaitypevalue > _targettypevalue;
            }
            else
            {

                List _tempShouPaiList = OrderPaiLord(shoupaiList);
                List _tempTargetList = OrderPaiLord(targetList);

                //三不带只能最后一手出,所以不做比较 
                //三带一 , 2飞机带翅, 3飞机带翅, 4飞机带翅 , 5飞机带翅  
                //四带二 ,  移除小于3张相同的牌进行大小排序 比较第一个
                switch (_shoupaiType)
                {
                    case LordPokerTypeEnum.PlaneWing1_4:
                    case LordPokerTypeEnum.PlaneWing2_8:
                    case LordPokerTypeEnum.PlaneWing3_12: //12张可能会有BUG,暂时不处理
                    case LordPokerTypeEnum.PlaneWing4_16:
                    case LordPokerTypeEnum.PlaneWing5_20:
                    case LordPokerTypeEnum.FourWithTwo_6:
                        List _tempShouPaiBig3List = GetSameMoreThan3(_tempShouPaiList);
                        List _tempTargetBig3List = GetSameMoreThan3(_tempTargetList);
                        IsGreater = _tempShouPaiBig3List[0] > _tempTargetBig3List[0];
                        break;
                    default:
                        IsGreater = _tempShouPaiList[0] > _tempTargetList[0];   //single, double, bomb, linkPair, straight
                        break;
                }
            }
            return IsGreater;
        }

        /// 
        /// 大小比值
        /// 
        public static Dictionary _diclordvalue = new Dictionary();
        public static void InitRate()
        {
            if (_diclordvalue.Count >= 2) return;
            _diclordvalue.Add(LordPokerTypeEnum.DoubleKing_2, 1000);
            ////_diclordvalue.Add(LordPokerTypeEnum.BombBombBombBomb, 80);  //四连炸
            ////_diclordvalue.Add(LordPokerTypeEnum.BombBombBomb, 70);      //三连炸
            ////_diclordvalue.Add(LordPokerTypeEnum.BombBomb, 60);          //二连炸
            _diclordvalue.Add(LordPokerTypeEnum.Bomb_4, 50);
            InitWeight();
        }
        public static Dictionary _dicLordWeight = new Dictionary();
        private static void InitWeight()
        {
            _dicLordWeight.Add(LordPokerTypeEnum.Single_1, 1);
            _dicLordWeight.Add(LordPokerTypeEnum.Double_2, 2);
            _dicLordWeight.Add(LordPokerTypeEnum.Three_3, 2);

            _dicLordWeight.Add(LordPokerTypeEnum.Straight5_5, 5);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight6_6, 6);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight7_7, 7);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight8_8, 8);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight9_9, 9);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight10_10, 10);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight11_11, 11);
            _dicLordWeight.Add(LordPokerTypeEnum.Straight12_12, 12);

            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair3_6, 6);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair4_8, 8);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair5_10, 10);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair6_12, 12);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair7_14, 14);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair8_16, 16);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair9_18, 18);
            _dicLordWeight.Add(LordPokerTypeEnum.LinkPair10_20, 20);

            _dicLordWeight.Add(LordPokerTypeEnum.PlaneWing1_4, 4);
            _dicLordWeight.Add(LordPokerTypeEnum.PlaneWing2_8, 8);
            _dicLordWeight.Add(LordPokerTypeEnum.PlaneWing3_12, 12);
            _dicLordWeight.Add(LordPokerTypeEnum.PlaneWing4_16, 16);
            _dicLordWeight.Add(LordPokerTypeEnum.PlaneWing5_20, 20);


            _dicLordWeight.Add(LordPokerTypeEnum.FourWithTwo_6, 7);
            ////_dicLordWeight.Add(LordPokerTypeEnum.Bomb33_2, 8);
            ////_dicLordWeight.Add(LordPokerTypeEnum.Bomb22_2, 9);
            _dicLordWeight.Add(LordPokerTypeEnum.Bomb_4, 10);
            _dicLordWeight.Add(LordPokerTypeEnum.DoubleKing_2, 11);

        }


        #endregion

        #region tip 相关功能
        /// 
        ///       提示功能 根据传入的牌找到可以接起的最小牌型,可能接不起的
        /// 
        /// 手牌要带花色
        /// 
        /// 
        public static List GetTipList(List _shoupai, List _lastPaiArr)
        {
            //剩余牌的数量小于  只能用炸了  //等于上手出牌的数量     //剩余牌的数量大于上手出牌的数量
            List _tiplist = new List();
            LordPokerSplitHelper _splitHelper = new LordPokerSplitHelper();
            _splitHelper.Split(_shoupai);
            if (_lastPaiArr.Count == 0)
            {//没有上家牌,直接按AI规则出牌
                //最大牌型,考虑春天 再最多牌数
                if (_splitHelper._straight.Count != 0)
                {
                    _tiplist = _splitHelper._straight[0];
                }
                else if (_splitHelper._linkerPair.Count != 0)
                {
                    _tiplist = _splitHelper._linkerPair[0];
                    if (_tiplist.Count != 0) _tiplist.AddRange(_tiplist);
                }
                else if (_splitHelper._planeWith.Count != 0)
                {
                    List _planeList = _splitHelper._planeWith[0];
                    List _existoneList = new List();
                    foreach (int _plane in _planeList)
                    {
                        _tiplist.Add(_plane);
                        _tiplist.Add(_plane);
                        _tiplist.Add(_plane);
                        int _tempwithone = _splitHelper.GetSingleToPlaneWith(_planeList, _existoneList);
                        if (_tempwithone != -1)
                        {
                            _tiplist.Add(_tempwithone);
                            _existoneList.Add(_tempwithone);
                        }
                    }
                    if (_tiplist.Count != _planeList.Count * 4) _tiplist = new List();//重置========可能会出现全三带没的带的情况而可以把3张拆成
                }
                else if (_splitHelper._double.Count != 0)
                {
                    int _double = _splitHelper._double[_splitHelper._double.Count - 1];
                    _tiplist.Add(_double);
                    _tiplist.Add(_double);
                }
                ////else if (_splitHelper._bomb22.Count != 0)
                ////{
                ////    _tiplist.Add(_splitHelper._bomb22[0]);
                ////    _tiplist.Add(_splitHelper._bomb22[0]);
                ////}
                ////else if (_splitHelper._bomb33.Count != 0)
                ////{
                ////    _tiplist.Add(_splitHelper._bomb33[0]);
                ////    _tiplist.Add(_splitHelper._bomb33[0]);
                ////}
                else if (_splitHelper._bomb4List.Count != 0)
                {
                    int _bomb = _splitHelper._bomb4List[_splitHelper._bomb4List.Count - 1];
                    _tiplist.Add(_bomb);
                    _tiplist.Add(_bomb);
                    _tiplist.Add(_bomb);
                    _tiplist.Add(_bomb);
                }
                else if (_splitHelper._doubleKing.Count != 0)
                {
                    _tiplist.AddRange(_splitHelper._doubleKing);
                }
                else
                {
                    _tiplist.Add(_splitHelper._single[_splitHelper._single.Count - 1]);
                }
                _tiplist = GetPaiColor(_shoupai, _tiplist);
                return _tiplist;
            }
            List _templastPoker = OrderPaiLord(_lastPaiArr);
            LordPokerTypeEnum _lordtype = GetLordType(_templastPoker);
            switch (_lordtype)
            {
                case LordPokerTypeEnum.DoubleKing_2: return new List();//如果上手出了王炸,直接要不起 
                case LordPokerTypeEnum.Bomb_4:
                    _tiplist = UseBomb(_splitHelper, _templastPoker[0]);
                    if (_tiplist.Count != 0) _tiplist = GetPaiColor(_shoupai, _tiplist);
                    return _tiplist;

                case LordPokerTypeEnum.Single_1:// 单张           
                    _tiplist = GetSingleBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.Double_2:
                    _tiplist = GetDoubleBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.Three_3:
                    _tiplist = GetThreeBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.PlaneWing1_4:
                case LordPokerTypeEnum.PlaneWing2_8:
                case LordPokerTypeEnum.PlaneWing3_12:
                case LordPokerTypeEnum.PlaneWing4_16:
                case LordPokerTypeEnum.PlaneWing5_20:
                    _tiplist = GetPlaneBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.Straight5_5:
                case LordPokerTypeEnum.Straight6_6:
                case LordPokerTypeEnum.Straight7_7:
                case LordPokerTypeEnum.Straight8_8:
                case LordPokerTypeEnum.Straight9_9:
                case LordPokerTypeEnum.Straight10_10:
                case LordPokerTypeEnum.Straight11_11:
                case LordPokerTypeEnum.Straight12_12:
                    _tiplist = GetStraightBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.LinkPair3_6:
                case LordPokerTypeEnum.LinkPair4_8:
                case LordPokerTypeEnum.LinkPair5_10:
                case LordPokerTypeEnum.LinkPair6_12:
                case LordPokerTypeEnum.LinkPair7_14:
                case LordPokerTypeEnum.LinkPair8_16:
                case LordPokerTypeEnum.LinkPair9_18:
                case LordPokerTypeEnum.LinkPair10_20:
                    _tiplist = GetLinkerPairBig(_templastPoker, _splitHelper);
                    break;
                case LordPokerTypeEnum.FourWithTwo_6:
                    _tiplist = GetFourWithTwoBig(_templastPoker, _splitHelper);
                    break;
                default:
                    TraceLogEx.Error(_lordtype + ":...............................lllllllllllllllllllllll");
                    break;
            }

            if (_tiplist.Count == 0)
            {
                _tiplist = UseBomb(_splitHelper, 0);
            }
            if (_tiplist.Count != 0) _tiplist = GetPaiColor(_shoupai, _tiplist);
            return _tiplist;
        }

        /// 
        /// 
        ///                           
        /// 
        /// 0表示只能炸弹就行,1表示是33,2表示是22,大于等于3表示是四个一样的炸弹3333,4444
        /// 
        private static List UseBomb(LordPokerSplitHelper _splitHelper, int lv)
        {
            List _tiplist = new List();
            switch (lv)
            {
                case 0:   //接小于炸弹的
                    ////if (_splitHelper._bomb33.Count != 0)
                    ////{
                    ////    _tiplist =  new List() { _splitHelper._bomb33[0], _splitHelper._bomb33[0] };
                    ////}
                    ////else if (_splitHelper._bomb22.Count != 0)
                    ////{
                    ////    _tiplist = new List() { _splitHelper._bomb22[0], _splitHelper._bomb22[0] };
                    ////}
                    ////else
                    if (_splitHelper._bomb4List.Count != 0)
                    {
                        _tiplist = new List() { _splitHelper._bomb4List[0], _splitHelper._bomb4List[0], _splitHelper._bomb4List[0], _splitHelper._bomb4List[0] };
                    }
                    else if (_splitHelper._doubleKing.Count != 0)
                    {
                        _tiplist = new List() { (int)LordPokerValueNoColorEnum.jokers16, (int)LordPokerValueNoColorEnum.jokersb17 };
                    }
                    break;

                default:
                    //case 3:   //bomb4 以上的        lv 为对应炸的值     
                    if (_splitHelper._bomb4List.Count != 0)
                    {
                        foreach (int poker in _splitHelper._bomb4List)
                        {
                            if (poker > lv) _tiplist = new List() { poker, poker, poker, poker };
                        }
                    }
                    else if (_splitHelper._doubleKing.Count != 0)
                    {
                        _tiplist = new List() { (int)LordPokerValueNoColorEnum.jokers16, (int)LordPokerValueNoColorEnum.jokersb17 };
                    }
                    break;
            }

            return _tiplist;
        }

        private static List GetSingleBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _ret = new List();
            if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;

            for (int i = _splitHelper._one.Count - 1; i >= 0; i--)
            {
                if (_splitHelper._one[i] > _lastPoker[0])
                {
                    _ret.Add(_splitHelper._one[i]);
                    break;
                }
            }
            return _ret;
        }
        private static List GetDoubleBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _ret = new List();
            if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;

            for (int i = _splitHelper._double.Count - 1; i >= 0; i--)
            {
                if (_splitHelper._double[i] > _lastPoker[0])
                {
                    _ret.Add(_splitHelper._double[i]);
                    _ret.Add(_splitHelper._double[i]);
                    break;
                }
            }
            return _ret;
        }
        /// 
        /// 获取三不带的提示
        /// 
        /// 
        /// 
        /// 
        private static List GetThreeBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _ret = new List();
            if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;

            for (int i = _splitHelper._threeList.Count - 1; i >= 0; i--)
            {
                if (_splitHelper._threeList[i] > _lastPoker[0])
                {
                    _ret.Add(_splitHelper._threeList[i]);
                    _ret.Add(_splitHelper._threeList[i]);
                    _ret.Add(_splitHelper._threeList[i]);
                    break;
                }
            }
            return _ret;
        }
        /// 
        /// 获取三带一 或飞机的的最小值 
        /// 
        /// 
        /// 
        /// 
        private static List GetPlaneBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _lastThreeList = GetSameMoreThan3(_lastPoker);
            if (_lastPoker.Count == 4)
            {
                List _ret = new List();
                if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;
                if (_splitHelper._three.Count < 1) return _ret;
                for (int i = _splitHelper._three.Count - 1; i >= 0; i--)
                {
                    if (_splitHelper._three[i] > _lastThreeList[0])
                    {
                        _ret.Add(_splitHelper._three[i]);
                        _ret.Add(_splitHelper._three[i]);
                        _ret.Add(_splitHelper._three[i]);
                        int _tempwithone = _splitHelper.GetSingleToPlaneWith(new List() { _splitHelper._three[i] });
                        if (_tempwithone != -1) _ret.Add(_tempwithone);
                        break;
                    }
                }
                if (_ret.Count == 4) return _ret;
                return new List();
            }
            else
            {
                List _tiplist = new List();
                if (_splitHelper._planeWith.Count < 1) return _tiplist;
                foreach (List _planeList in _splitHelper._planeWith)
                {
                    if (_planeList.Count < _lastThreeList.Count) continue;//个数不够
                    if (_planeList[0] < _lastThreeList[0]) continue;//大小不对 ==================需要写在从最小值取值 ,现在直接从最大值开取的=======
                    foreach (int _plane in _planeList)
                    {
                        _tiplist.Add(_plane);
                        _tiplist.Add(_plane);
                        _tiplist.Add(_plane);
                        int _tempwithone = _splitHelper.GetSingleToPlaneWith(_planeList);
                        if (_tempwithone != -1) _tiplist.Add(_tempwithone);
                    }
                    if (_tiplist.Count != _planeList.Count * 4) _tiplist = new List();//重置========可能会出现全三带没的带的情况而可以把3张拆成
                }
                return _tiplist;
            }
        }
        /// 
        /// 获取四带二   的最小值 
        /// 
        /// 
        /// 
        /// 
        private static List GetFourWithTwoBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _lastThreeList = GetSameMoreThan3(_lastPoker);
            List _ret = new List();
            if (_lastPoker.Count != 6) return _ret;
            if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;
            if (_splitHelper._four.Count < 1) return _ret;

            for (int i = _splitHelper._four.Count - 1; i >= 0; i--)
            {
                if (_splitHelper._four[i] > _lastThreeList[0])
                {
                    _ret.Add(_splitHelper._four[i]);
                    _ret.Add(_splitHelper._four[i]);
                    _ret.Add(_splitHelper._four[i]);
                    _ret.Add(_splitHelper._four[i]);
                    List _tempwithone = _splitHelper.GetSingleToFourWith(new List() { _splitHelper._four[i] });
                    _ret.AddRange(_tempwithone);
                    break;
                }
            }
            if (_ret.Count == 6) return _ret;
            return new List();

        }
        /// 
        /// 直接取最大的连子, 
        /// 
        /// 
        /// 
        /// 
        private static List GetStraightBig(List _lastPoker, LordPokerSplitHelper _splitHelper)
        {
            List _ret = new List();
            if (_lastPoker.Count < 5) return _ret;
            if (_splitHelper._shouPai.Count < _lastPoker.Count) return _ret;
            if (_splitHelper._straight.Count < 0) return _ret;
            foreach (var _onestraight in _splitHelper._straight)
            {
                if (_onestraight.Count < _lastPoker.Count) continue;
                int _tempfirstindex = -1;
                for (int i = 0; i = 5) _straight.Add(_minStraight);//最后一组必须加进去 不然一个长连子没搜索到
        }
        /// 
        /// 只存了单个牌 好处理
        /// 
        public void SearchLinkerPair()
        {
            if (_shouPai.Count < 6) return;//不足6个牌就不处理的
            List _temptwo = new List(_two);
            if (_temptwo.Contains((int)LordPokerValueNoColorEnum.p15)) _temptwo.Remove((int)LordPokerValueNoColorEnum.p15);    // ,2 不能组成连子   
            if (_temptwo.Count < 3) return;//不足6个牌就不处理的

            List _minLinker = new List();
            for (int i = 0; i < _temptwo.Count - 1; i++)
            {
                if (_temptwo[i] - 1 == _temptwo[i + 1])
                {
                    _minLinker.Add(_temptwo[i]);
                    if (i + 1 == _temptwo.Count - 1) _minLinker.Add(_temptwo[i + 1]);//最后一个要加上
                }
                else
                {//可能会出现刚才好3个,而后还有牌,搜索不到
                    _minLinker.Add(_temptwo[i]);
                    if (_minLinker.Count >= 3) _linkerPair.Add(_minLinker);
                    _minLinker = new List();
                }
            }
            if (_minLinker.Count >= 3) _linkerPair.Add(_minLinker);
        }
        /// 
        /// 只存了单个牌 好处理
        /// 
        public void SearchPlaneWithone()
        {
            if (_shouPai.Count < 4) return;//不足4个牌就不处理的
            if (_three.Count < 2) return;//不足两个三带一
            List _tempthree = new List(_three);
            List _minPlane = new List();
            for (int i = 0; i < _tempthree.Count - 1; i++)
            {
                if (_tempthree[i] - 1 == _tempthree[i + 1])
                {
                    _minPlane.Add(_tempthree[i]);
                    if (i + 1 == _tempthree.Count - 1) _minPlane.Add(_tempthree[i + 1]);//最后一个要加上
                }
                else
                {//可能会出现刚才好2个,而后还有牌,搜索不到
                    _minPlane.Add(_tempthree[i]);
                    if (_minPlane.Count >= 2) _planeWith.Add(_minPlane);
                    _minPlane = new List();
                }
            }
            if (_minPlane.Count >= 2) _planeWith.Add(_minPlane);
        }
        /// 
        /// 获取三带一中的单牌
        /// 
        /// 
        /// 
        public int GetSingleToPlaneWith(List planeList)
        {
            if (_single.Count == 0) return -1;
            int _tempSingle = 0;
            for (int i = _single.Count - 1; i >= 0; i--)
            {//不能是三带一中的牌 
                if (_single[i] == (int)LordPokerValueNoColorEnum.p15) continue;//2不带用于三带1 只有最后一个手三带一可以用 
                if (_single[i] == (int)LordPokerValueNoColorEnum.jokers16 || _single[i] == (int)LordPokerValueNoColorEnum.jokersb17)
                {
                    continue;//王不带用于三带1 只有最后一个手三带一可以用
                }
                bool _issametoPlane = false;
                foreach (int plane in planeList)
                {
                    if (plane == _single[i]) _issametoPlane = true;
                }
                if (_issametoPlane) continue;
                _tempSingle = _single[i];
                break;
            }
            if (_tempSingle != -1)
            {
                _single.Remove(_tempSingle);
            }

            return _tempSingle;
        }
        /// 
        /// 获取三带一中的单牌
        /// 
        /// 
        /// 
        public int GetSingleToPlaneWith(List planeList, List _existonelist)
        {
            if (_single.Count == 0) return -1;
            int _tempSingle = 0;
            for (int i = _single.Count - 1; i >= 0; i--)
            {//不能是三带一中的牌 
                if (_single[i] == (int)LordPokerValueNoColorEnum.p15) continue;//2不带用于三带1 只有最后一个手三带一可以用 
                if (_single[i] == (int)LordPokerValueNoColorEnum.jokers16 || _single[i] == (int)LordPokerValueNoColorEnum.jokersb17)
                {
                    continue;//王不带用于三带1 只有最后一个手三带一可以用
                }
                bool _issametoPlane = false;
                foreach (int plane in planeList)
                {
                    if (plane == _single[i]) _issametoPlane = true;
                }
                if (_issametoPlane) continue;
                _tempSingle = _single[i];
                if (_existonelist.Contains(_tempSingle))
                {
                    _tempSingle = -1;
                    continue;
                }
                break;
            }
            return _tempSingle;
        }
        /// 
        /// 获取四带二中的两个单牌
        /// 
        /// 
        /// 
        public List GetSingleToFourWith(List planeList)
        {
            List _withtwo = new List();
            if (_single.Count == 0) return _withtwo;
            for (int i = _single.Count - 1; i >= 0; i--)
            {//不能是四带二中的牌  可以带2,带王
                ////if (_single[i] == (int)LordPokerValueNoColorEnum.p15) continue;//2不带用于三带1 只有最后一个手三带一可以用 
                ////if (_single[i] == (int)LordPokerValueNoColorEnum.jokers16 || _single[i] == (int)LordPokerValueNoColorEnum.jokersb17)
                ////{
                ////    continue;//王不带用于三带1 只有最后一个手三带一可以用
                ////}
                bool _issametoPlane = false;
                foreach (int plane in planeList)
                {
                    if (plane == _single[i]) _issametoPlane = true;
                }
                if (_issametoPlane) continue;
                _withtwo.Add(_single[i]);
                if (_withtwo.Count >= 2) break;
            }
            return _withtwo;
        }
    }

    #endregion

}