hnhzServer/app/paodekuai/logic.js

'use strict';
//// 为什么选择 Lodash ？
//// Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。
//// Lodash 的模块化方法 非常适用于：

//// 遍历 array、object 和 string
//// 对值进行操作和检测
//// 创建符合功能的函数
var _ = require('lodash');

var quick = require('quick-pomelo');
var logger = quick.logger.getLogger('fhmj', __filename);
// 所有牌
const CARDS = [
    101,102,103,104,105,106,107,108,109,110,111,112,113,////这代表黑桃A~K
            203,204,205,206,207,208,209,210,211,212,213,////这代表红桃A~K
            303,304,305,306,307,308,309,310,311,312,313,////这代表梅花A~K
            403,404,405,406,407,408,409,410,411,412,////这代表方片A~K
    // 516,517,                                            ////代表小王和大王
];

// 块类型
const STYLE = {
    ERROR: 1,       // 牌型不存在
    NULL: 2,	    // 无效（牌型存在但是大不过）
    YAOBUQI: 3,     // 要不起
    DAN: 4,		    // 单牌
    YIDUI: 5,	 	// 一对子
    LIANDUI: 6,	 	// 连对（2对或2对以上点数相连的牌，如：5566；）
    SANDAIYI: 7,	// 三带一
    SANDAIER: 8,	// 三带二
    SIDAIER: 9,	    // 四带二
    SIDAISAN: 10,   // 四带三
    FEIJI:11,       // 飞机
    SHUNZI:12,      // 顺子
    ZHADAN:13,      // 炸弹
};

// 椅子数
const CHAIR_COUNT = 3;
const CARDS_COUNT = 15;

// 构造方法
var Logic = function (type,gameKindTL,playerAllCount,other) {
    // 类型
    this.type = type;
    this.other = other;//////TL++2人3人的游戏规则
    this.isHTSFB = false;//是否红桃十翻倍
    if(this.other & 1){
        this.isHTSFB = true;
    } 
    this.isZDBKC = false;//是否炸弹不可拆
    if(this.other & 2){
        this.isZDBKC = true;
    } 
    this.isCanSiDaiEr = false;//是否可四带2
    if(this.other & 4){
        this.isCanSiDaiEr = true;
    } 
    this.isSiCanDaiSan = false;//是否可四带3
    if(this.other & 32){
        this.isSiCanDaiSan = true;
    } 
    this.cardCount = 15;//张数
    if(this.other & 8){//
        //一副牌去除大小王、去除3个A、去除3个2，去除一个方片K，共剩45张牌，每人15张牌；(一手牌中只有1个黑桃2，1个黑桃A，3个K)；
        this.cardCount = 15;
    }
    else if(this.other & 16){//
        //一副牌去除大小王、去除1个A、去除3个2，共48张牌，每人16张牌;(一手牌只有1个2,3个A);
        this.cardCount = 16;
    }
    this.isYPBC = true;//是否有牌必出（能大过必须出牌大掉）
    // console.warn("是否红桃十翻倍  "+this.isHTSFB)
    // console.warn("是否炸弹不可拆  "+this.isZDBKC)
    // console.warn("是否可四带2  "+this.isCanSiDaiEr)
    // console.warn("是否可四带3  "+this.isSiCanDaiSan)
    // console.warn("张数  "+this.cardCount)
    // 全牌
    var cards = _.clone(CARDS);
    //添加红中红中
    if (this.cardCount == 16){
        cards[cards.length] = 201;
        cards[cards.length] = 301;
        cards[cards.length] = 413;
    }
    // console.warn("牌池总张数  "+cards.length+"'   "+cards)
    this.castCount = 0;
    // this.disCount = 0;
    this.lastCount = cards.length;//////设置剩余牌数为了测试海底捞月
    this.cardsPool = cards;
    this.cardsyl = _.clone(cards);


    this.styleTL = STYLE;
    this.dahuTypeTL = [
        ["牌型不存在"], ///// 0 牌型不存在
        ["无效"],       ///// 1 无效（牌型存在但是大不过）
        ["要不起"],     ///// 2 要不起
        ["单牌"],       ///// 3 单牌
        ["一对子"],     ///// 4 一对子
        ["连对"],       ///// 5 连对（2对或2对以上点数相连的牌，如：5566；）
        ["三带一"],     ///// 6 三带一
        ["三带二"],     ///// 7 三带二
        ["四带二"],     ///// 8 四带二
        ["四带三"],     ///// 9 四带三
        ["飞机"],       ///// 10 飞机
        ["顺子"],       ///// 11 顺子
        ["炸弹"],       ///// 12 炸弹 
        
    ];
    //////以下变量全是TL++
    this.gameKindTL = gameKindTL || 1;////没啥用
    this.playerAllCount = playerAllCount || 4;////游戏人数  = 2表示2人局 = 3表示3人局 = 4表示4人局
    this.setCardFilerIndex = 0
    this.currChairIDTL = 0/////当前判断胡的chairID,用于得到当前玩家的胡牌情况
    this.setCardFileName = '';/////设置手牌的文件名
    this.cardGroupIndex = 0;////要设置的牌型种类
    this.uidsfydsq = [];//uid和是否有定时器的对应
    this.everyJPQSYSJ = [0,0,0];//每个玩家记牌器剩余时间
    this.dczsList = this.fillDeep(Array(13), 0);//打出张数列表，用于记牌器
};


Logic.setHCfileNameList =[/////全部设置牌型的文件名
    "setHandCard_tianhu",
]

// 导出常量
Logic.CARDS = CARDS;
Logic.STYLE = STYLE;
Logic.CHAIR_COUNT = CHAIR_COUNT;
Logic.CARDS_COUNT = CARDS_COUNT;

// 导出类
module.exports = Logic;

// 原型对象
var proto = Logic.prototype;

///////TL++在table类中出牌函数中调用，为了判断天胡和地胡
proto.chuPaiTL = function () {
    // console.warn("111c天胡判断不正确",this.chuPaiCountTL); 
    this.chuPaiCountTL += 1//////这个其实并不是真实的出牌个数，因为这个方法的调用在判断吃碰杠胡之前调用的
}

///////TL++在table类中出牌函数中调用，为了判断天胡和地胡
proto.moPaiTL = function () {
    // console.warn("111c天胡判断不正确",this.chuPaiCountTL); 
    this.moPaiCountTL += 1//////TL++,记录出牌的个数，为了判断天胡和地胡 += 1
}
    
///////TL++重置默认数据，在每局游戏开始的洗牌函数中调用
proto.resetDataOnGameStart = function () {
    this.dczsList = this.fillDeep(Array(13), 0);//打出张数列表，用于记牌器
    this.chuPaiCountTL = 0//////TL++出牌个数
    this.moPaiCountTL = 0//////TL++,记录摸牌的个数，为了判断天胡和地胡
    this.lastMoPaiChairID = 0//////TL++,最后一个摸牌玩家的id
}

// 重新洗牌
proto.shuffle = function () {
    this.castCount = 0;
    // this.disCount = 0;
    this.cardsPool = _.clone(this.cardsyl);
    this.lastCount = this.cardsPool.length;
    this.cardsPool = _.shuffle(this.cardsPool);////随机打乱一个数组
    this.cardsPool = _.shuffle(this.cardsPool);////洗第二次牌  
    // this.cardsPool = _.shuffle(this.cardsPool);////洗第三次牌  
};

// 填充数组
proto.fillDeep = function (array, o, isMore) {
    for (let i = 0; i < array.length; ++i) {
        if (!isMore) {
            array[i] = _.clone(o);
        } else {
            array[i] = _.cloneDeep(o);/////深度拷贝，就是重新分配内存空间，浅拷贝则是两个变量共用一个内存对象
        }
    }
    return array;
};

//////TL++ 深复制一个object类型的数据
proto.deepCloneTL = function (obj){
    let objClone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj==="object"){
        for(let key in obj){
            if(obj.hasOwnProperty(key)){
                //判断ojb子元素是否为对象，如果是，递归复制
                if(obj[key]&& typeof obj[key] ==="object"){
                    objClone[key] = this.deepCloneTL(obj[key]);
                }else{
                    //如果不是，简单复制
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
};


// 获取类型
proto.getType = function (card) {
    return Math.floor(card / 100);
};

// 获取牌值
proto.getValue = function (card) {
    return card % 100;
};

//排序时使用的获取牌值
proto.getValuepx = function (card) {
    let v = card % 100;
    if(v == 1 || v == 2) v+=13;
    return v;
}
// 手牌排序
proto.sort = function (handCards) {
    // return _.sortBy(handCards);///降序排序
    // console.warn("111手牌排序",JSON.stringify(handCards));
    // 111手牌排序 [101,102,103,104,105,106,107,108,109,110,111,112,113,403,404,201]
    var ng = _.groupBy(handCards, function (n) { 
        let value = n % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    // console.warn("222手牌排序",JSON.stringify(ng));
    // 222手牌排序 {"3":[103,403],"4":[104,404],"5":[105],"6":[106],"7":[107],"8":[108],"9":[109],"10":[110],"11":[111],"12":[112],"13":[113],"14":[101,201],"15":[102]}
    // let xxc = _.sortBy(ng, function(o) { return o.length; });
    // 333手牌排序 [[105],[106],[107],[108],[109],[110],[111],[112],[113],[102],[103,403],[104,404],[101,201]]
    let xxc = _.sortBy(ng, function(o) { 
        let value = o[0] % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    // 333手牌排序 [[103,403],[104,404],[105],[106],[107],[108],[109],[110],[111],[112],[113],[101,201],[102]]
    // console.warn("333手牌排序",JSON.stringify(xxc));
    
    let res = [];
    for (var i = 0; i < xxc.length; i++) {
        res = res.concat(_.sortBy(xxc[i]))
        // console.warn("444手牌排序",JSON.stringify(res));
        // 444手牌排序 [105]
        // 444手牌排序 [105,106]
        // 444手牌排序 [105,106,107]
        // 444手牌排序 [105,106,107,108]
        // 444手牌排序 [105,106,107,108,109]
        // 444手牌排序 [105,106,107,108,109,110]
        // 444手牌排序 [105,106,107,108,109,110,111]
        // 444手牌排序 [105,106,107,108,109,110,111,112]
        // 444手牌排序 [105,106,107,108,109,110,111,112,113]
        // 444手牌排序 [105,106,107,108,109,110,111,112,113,102]
        // 444手牌排序 [105,106,107,108,109,110,111,112,113,102,103,403]
        // 444手牌排序 [105,106,107,108,109,110,111,112,113,102,103,403,104,404]
        // 444手牌排序 [105,106,107,108,109,110,111,112,113,102,103,403,104,404,101,201]
    }
    // console.warn("555手牌排序",JSON.stringify(res));


    //下面是验证排序过程中是否出错（改变原数组）了
    let lygdys = _.difference(handCards,res);////另一个队员的人数
    let lygdys2 = _.difference(res,handCards);////另一个队员的人数
    if(lygdys.length > 0 || lygdys2.length > 0 || handCards.length != res.length){
        console.error("111==============================这把派出错了 =======",handCards);
        console.error("222==============================这把派出错了 =======",res);
        return handCards;
    }
    // console.warn("1010手牌排序",JSON.stringify(res));
    // 555手牌排序 [105,106,107,108,109,110,111,112,113,102,103,403,104,404,101,201]
    // 1010手牌排序 [103,403,104,404,105,106,107,108,109,110,111,112,113,101,201,102]
    return res;
};

// 删除手牌 
proto.remove = function (handCards, cards) {
    if (typeof (cards) == 'number') {
        if (cards == handCards[handCards.length - 1]) {
            return (handCards.pop(), true);
        } else {
            let pos = handCards.indexOf(cards);
            if (pos == -1) return false;
            return (handCards.splice(pos, 1), true);
        }
    }
    // console.warn("删除手牌");
    var length = cards.length;
    for (let i = 0; i < length; ++i) {
        let pos = handCards.indexOf(cards[i]);
        if (pos == -1) return false;
    }
    for (let i = 0; i < length; ++i) {
        let pos = handCards.indexOf(cards[i]);
        if (pos == -1) return false;
        handCards.splice(pos, 1);
    }
    return true;
};

// 剩余牌数
proto.leaveCount = function () {
    return this.lastCount;
};

// 设置打出张数列表
proto.setDCZSList = function (outCards) {
    for (var i = 0; i < outCards.length; i++) {
        let pz = this.getValue(outCards[i]);
        this.dczsList[pz-1]++
    }
};

// 获得打出张数列表
proto.getDCZSList = function (chairID) {
    if(chairID < 0) return [];
    if(this.everyJPQSYSJ[chairID] <= 0) return [];
    return this.dczsList;
};

//////TL++,人工设置测试牌型
proto.setTestSendCardsTL = function () {
    this.setCardFileName = '';

    let fileName = "setHandCard_pdk"

    if(!fileName) return;/////文件名字不存在 
    // console.warn("设置手牌的文件名",fileName);
    this.setCardFileName = fileName
    var SetHandCardTL = require('./setcard/' + fileName);
    if(!SetHandCardTL) return;
    //////TL++,设置手牌的文件
    this.setHandCardTL = new SetHandCardTL();
    
    ////console.error("洗牌之后的牌",this.cardsPool);
    let ccc = this.setHandCardTL.getSCFP(this.cardGroupIndex)
    if(ccc){//////已经设置的手牌发完了就随机发牌
        this.cardsPool = ccc/////设置手牌的地方 设置牌
        this.cardGroupIndex += 1; ////此句是否存在代表是否只发某一种牌型
        // SetHandCardTL.cardGroupIndex += 1; ////此句是否存在代表是否只发某一种牌型
        // if(SetHandCardTL.cardGroupIndex == 1) SetHandCardTL.cardGroupIndex = 0
    }
    else{
        this.setCardFilerIndex += 1;
        this.cardGroupIndex = 0;
        // SetHandCardTL.cardGroupIndex = 0;
        if(Logic.setCardFilerIndex < Logic.setHCfileNameList.length) this.setTestSendCardsTL()
    }
}

// 初始手牌
proto.handCards = function (chBanker,_PJHF,_over,recordid,_ctime) {
    this.resetDataOnGameStart()//////TL++
    this.shuffle();

    // if(this.hzCount == 8) {
        // this.cardsPool = [405,309,109,306,204,408,307,105,312,110,410,304,208,210,406,213,212,106,204,412,305,103,308,107,404,411,104,409,112,209,303,313,207,403,211,101,311,310,205,206,407,113,111,108,102]
        // this.cardsPool = [405,309,109,306,203,408,307,105,312,110,410,304,208,210,406,213,212,106,204,412,305,103,308,107,404,411,104,409,112,209,303,313,207,403,211,101,311,310,205,206,407,113,111,108,102]
        // this.cardsPool = [405,309,109,306,211,408,307,105,312,110,410,304,208,210,406,213,212,106,204,412,305,111,308,107,404,411,104,409,112,209,311,313,207,403,211,101,311,310,205,206,407,113,111,108,102]
        // this.cardsPool = [405,309,109,306,203,408,307,105,312,110,410,304,208,213,406,213,212,106,204,412,305,103,308,107,404,411,104,409,112,209,303,313,207,403,211,101,311,310,205,206,407,113,111,108,102]
        // this.cardsPool = [405,309,109,306,203,408,307,105,312,110,410,304,208,209,406,213,212,106,204,412,305,103,308,107,404,411,104,409,112,209,303,309,207,403,211,101,311,310,205,206,407,109,111,108,102,104,204,304]
        // this.cardsPool = [405,309,109,306,205,408,307,105,312,110,410,304,208,209,406,213,212,106,204,412,305,105,308,107,404,411,104,409,112,209,305,309,207,405,211,101,311,310,205,206,407,109,111,108,102,104,204,304]
        // this.cardsPool = [405,310,110,306,205,408,307,105,312,110,410,304,208,210,406,213,212,106,204,412,305,105,308,107,404,411,104,410,112,210,305,310,207,405,211,101,311,310,205,206,407,110,111,108,102,104,204,304]
        // this.cardsPool = [405,309,109,306,203,408,307,105,312,110,410,304,208,209,406,213,212,106,204,412,305,103,308,107,404,411,104,409,112,209,303,309,207,403,211,101,311,310,205,206,407,109,111,108,102,104,204,304]
        // this.cardsPool = [406,210,103,308,407,305,113,211,207,410,209,205,404,208,309,108,313,106,403,312,102,206,212,405,311,304,409,303,213,310,306,111,110,411,107,109,203,204,112,104,307,101,408,412,105]
        this.setTestSendCardsTL()///////设置手牌的地方，设置发牌   不需要设置的时候注释掉这个方法就可以了
        // this.lastCount = this.cardsPool.length;//////设置剩余牌数设置剩余牌数，测试完这句要删掉
    // }

    let dqjs = _over + 1;
    _PJHF.writexpJson(this.deepCloneTL(this.cardsPool),dqjs,recordid,_ctime);
    
    var result = [];
    // console.warn("发的牌池"+"牌数  "+this.cardsPool.length+"   "+JSON.stringify(this.cardsPool));
    var castCount = 0;
    for (let i = 0; i < this.playerAllCount; ++i) {
        let cardCount = this.cardCount;
        // if (i == chBanker) cardCount += 1;
        let cards = this.cardsPool.slice(castCount, castCount + cardCount);
        castCount += cardCount;
        result.push({ cards: this.sort(cards) });
    }
    this.castCount += castCount
    this.lastCount -= castCount;
    //上面的发牌方式是前15张发给第一个人，中间15张发给第二个人，后15张发给第三个人，下面是每人发一张直到牌发完
    // let everyCards = [[],[],[]];
    // for (let i = 0; i < this.cardsPool.length; ++i) {
    //     let fgs = i%3;
    //     let djz = everyCards[fgs].length;
    //     if(djz >= this.cardCount) break;
    //     everyCards[fgs][djz] = this.cardsPool[i];
    //     this.castCount += 1
    //     this.lastCount -= 1;
    // }
    // for (let i = 0; i < this.playerAllCount; ++i) {
    //     result.push({ cards: this.sort(everyCards[i]) });
    // }

    // // 下面是每人发4张（5张）直到牌发完
    // let everyCards = [[],[],[]];
    // if(this.cardCount == 15){
    //     let cardCount = 5;
    //     var castCount = 0;
    //     for (let i = 0; i < 3; ++i) {
    //         for (let j = 0; j < 3; ++j) {
    //             let cards = this.cardsPool.slice(castCount, castCount + cardCount);
    //             castCount += cardCount;
    //             everyCards[j] = everyCards[j].concat(cards)
    //             this.castCount += cardCount
    //             this.lastCount -= cardCount;
    //         }
    //     }
    // }
    // else if(this.cardCount == 16){
    //     let cardCount = 4;
    //     for (let i = 0; i < 4; ++i) {
    //         for (let j = 0; j < 3; ++j) {
    //             let cards = this.cardsPool.slice(castCount, castCount + cardCount);
    //             castCount += cardCount;
    //             everyCards[j] = everyCards[j].concat(cards)
    //             this.castCount += cardCount
    //             this.lastCount -= cardCount;
    //         }
    //     }
    // }
    // console.warn("发的手牌",JSON.stringify(everyCards));
    // for (let i = 0; i < this.playerAllCount; ++i) {
    //     result.push({ cards: this.sort(everyCards[i]) });
    // }

    // // 下面是每人发3张
    // let everyCards = [[],[],[]];
    // let cardCount = 3;
    // var castCount = 0;
    // for (let i = 0; i < 5; ++i) {
    //     for (let j = 0; j < 3; ++j) {
    //         let cards = this.cardsPool.slice(castCount, castCount + cardCount);
    //         castCount += cardCount;
    //         everyCards[j] = everyCards[j].concat(cards)
    //         this.castCount += cardCount
    //         this.lastCount -= cardCount;
    //     }
    // }
    // if(this.cardCount == 16){
    //     let cardCount2 = 1;
    //     for (let j = 0; j < 3; ++j) {
    //         let cards = this.cardsPool.slice(castCount, castCount + cardCount2);
    //         castCount += cardCount2;
    //         everyCards[j] = everyCards[j].concat(cards)
    //         this.castCount += cardCount2
    //         this.lastCount -= cardCount2;
    //     }
    // }
    // console.warn("发的手牌",JSON.stringify(everyCards));
    // for (let i = 0; i < this.playerAllCount; ++i) {
    //     result.push({ cards: this.sort(everyCards[i]) });
    // }
    // console.warn("发的手牌",JSON.stringify(result)+"  "+this.castCount+"  "+this.lastCount);
    return result;
};

// 是否无牌
proto.isNoCards = function () {
    return this.lastCount <= 0;
};

// 分析牌型
proto.parseBlock = function (card1, card2, card3) {
    // 刻子
    if (card1 && card1 == card2 && card1 == card3) {
        return { style: STYLE.KE, cards: [card1, card2, card3] };
    }
    // 顺子(排除风字)
    var cards = this.sort([card1, card2, card3]);
    if (cards[2] < 40) {
        if (cards[2] == cards[1] + 1 && cards[1] == cards[0] + 1) {
            return { style: STYLE.SUN, cards: cards };
        }
    }
};

////TL++得到首局出牌玩家
proto.getSCId = function (handCards) {

    let res = -1;
    for (let i = 0; i < handCards.length; ++i) {
        if(handCards[i].cards.indexOf(103) != -1){
            res = i;//首局黑桃3先出
            break;
        }
    }
    //二人时两人手牌都没有黑桃三则按照3到2的排序，看谁手上有黑桃。
    // 譬如没有黑桃3 ，就黑桃4 ，没有黑桃4，就黑桃5.但是除了黑桃3.其他的不需要第一手牌必出
    //两人手上都没有黑桃的话就按照红桃的3到2的排序看谁手上有红桃
    if(res == -1){
        let pdsx = [103,104,105,106,107,108,109,110,111,112,113,203,204,205,206,207,208,209,210,211,212,213]
        for (let j = 0; j < pdsx.length; ++j) {
            for (let i = 0; i < handCards.length; ++i) {
                if(handCards[i].cards.indexOf(pdsx[j]) != -1){
                    res = i;//首局黑桃3先出
                    break;
                }
            }
        }
    }
    return res;
}

proto.getIsHeLi = function (daicards,tipAllKind,_vgs,isHTSSC) {
    let bsyqk = [[-1,-1,-1],[-1,-1,-1]];//可带牌被使用情况[[第一张是否做顺子了,第一张是否做连对了,第一张是否做对子了],[第二张是否做顺子了,第二张是否做连对了,第二张是否做对子了]]
    for (var i = 0; i < tipAllKind.length; i++) {
        if(tipAllKind[i].type == STYLE.SHUNZI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let szIndex1 = tipAllKind[i].tipCards[j].indexOf(daicards[0]);
                if(szIndex1 != -1) bsyqk[0][0] = szIndex1
                let szIndex2 = tipAllKind[i].tipCards[j].indexOf(daicards[1]);
                if(szIndex2 != -1) bsyqk[1][0] = szIndex2
            }
        }
        if(tipAllKind[i].type == STYLE.LIANDUI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let szIndex1 = tipAllKind[i].tipCards[j].indexOf(daicards[0]);
                if(szIndex1 != -1) bsyqk[0][1] = szIndex1
                let szIndex2 = tipAllKind[i].tipCards[j].indexOf(daicards[1]);
                if(szIndex2 != -1) bsyqk[1][1] = szIndex2
            }
        }
        if(tipAllKind[i].type == STYLE.YIDUI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let szIndex1 = tipAllKind[i].tipCards[j].indexOf(daicards[0]);
                if(szIndex1 != -1) bsyqk[0][2] = szIndex1
                let szIndex2 = tipAllKind[i].tipCards[j].indexOf(daicards[1]);
                if(szIndex2 != -1) bsyqk[1][2] = szIndex2
            }
        }
    }
    
    let isheli = true;
    for (var i = 0; i < bsyqk.length; i++) {
        for (var j = 0; j < bsyqk[i].length; j++) {
            if(bsyqk[i][j] != -1){
                isheli = false;
                break;
            }
        }
        if(!isheli) break;
    }
    let res = {
        isheli:isheli,
        bsyqk:bsyqk,
    };
    return res;
}

proto.changeShunZiPai = function (tipCards,shunziCards,vgs,isHTSSC) {
    // console.warn("得到三带四带可带牌数组 changeShunZiPai   tipCards  "+JSON.stringify(tipCards) +"  shunziCards   "+JSON.stringify(shunziCards));
    // let sdpz = this.getValuepx(tipCards[0])
    let szxb = shunziCards.indexOf(tipCards[0]);
    let res = [this.deepCloneTL(shunziCards)];
    if(szxb != -1){
        for (var i = 0; i < vgs.length; i++) {
            if(vgs[i][0] == tipCards[0]){
                if(vgs[i].length == 3){
                    res = [];
                    if(szxb >= 5){
                        let szp = this.deepCloneTL(shunziCards);
                        res[res.length] = szp.slice(0,szxb-1);
                        // console.warn(" changeShunZiPai111   res  "+JSON.stringify(res)+"  szxb  "+szxb);
                    }
                    if(shunziCards.length - szxb > 5){
                        let szp = this.deepCloneTL(shunziCards);
                        res[res.length] = szp.slice(szxb+1, szp.length);
                        // console.warn(" changeShunZiPai222   res  "+JSON.stringify(res)+"  szxb  "+szxb);
                    }
                }
                else if(vgs[i].length == 4) res[0][szxb] = vgs[i][3];
                break;
            }
        }
    }
    // console.warn("得到三带四带可带牌数组 changeShunZiPai   res  "+JSON.stringify(res)+"  szxb  "+szxb);
    return res;
}

//在传进来的连对list参数中去掉指定的豹子之后，返回可做连对的list
proto.changeLDByBZ = function (ldList,bzList,sdTip) {
    // console.warn("changeLDByBZ    ldList "+JSON.stringify(ldList)+"  bzList  "+JSON.stringify(bzList)+"  sdTip  "+JSON.stringify(sdTip));
    let duiziList = [];
    let isbhbz = false;//连对里是否包含指定豹子
    for (var i = 0; i < ldList.length; i++) {
        if(bzList.indexOf(ldList[i]) != -1){
            isbhbz = true;
        }
        else{
            if(i%2 == 0) {
                duiziList[duiziList.length] = [ldList[i],ldList[i+1]]
            }
        } 
    }
    if(!isbhbz) return ldList;
    let lianduiList = [];
    if(duiziList.length >= 2){  
        let pdz = this.getValuepx(duiziList[0][0]); 
        let pdIndex = 0;
        lianduiList[0] = [duiziList[0]];
        // console.warn("出牌提示  连对list   "+JSON.stringify(lianduiList));
        for (var i = 1; i < duiziList.length; i++) {
            if((pdz+i-pdIndex) == this.getValuepx(duiziList[i][0])){
                let lianduiListLastItemIndex = lianduiList.length-1;
                let lianduiListLastItemLastIndex = lianduiList[lianduiList.length-1].length;
                lianduiList[lianduiListLastItemIndex][lianduiListLastItemLastIndex] = duiziList[i];
            }
            else{
                // console.warn("出牌提示  连对到这里了嘛222   "+JSON.stringify(duiziList[i]));
                lianduiList[lianduiList.length] = [];
                lianduiList[lianduiList.length-1] = [duiziList[i]];
                pdz = this.getValuepx(duiziList[i][0]);
                pdIndex = i;
            }
        }
    }
    let lianduiTip = [];
    for (var i = 0; i < lianduiList.length; i++) {
        if(lianduiList[i].length >= 2){
            let lds = [];
            for (var j = 0; j < lianduiList[i].length; j++) {
                lds = lds.concat(lianduiList[i][j])
            }
            if(lds.length == 4){
                for (var z = 0; z < sdTip.length; z++) {
                    if(sdTip[z].indexOf(lds[0]) != -1 || sdTip[z].indexOf(lds[2]) != -1){
                        //拆开一个豹子去做4张的连对不划算
                        lds = [];
                        // kzld = false;
                        break;
                    }
                }
            }
            lianduiTip[lianduiTip.length] = lds;
        }
    }
    let kzlddp = [];//可做连对的牌
    for (var j = 0; j < lianduiTip.length; j++) {
        for (var z= 0; z < lianduiTip[j].length; z++) {
            kzlddp = kzlddp.concat(lianduiTip[j][z]);
        }
    }
    // console.warn("changeLDByBZ    duiziList "+JSON.stringify(duiziList)+"  lianduiList  "+JSON.stringify(lianduiList)+"  lianduiTip  "+JSON.stringify(lianduiTip)+"  kzlddp  "+JSON.stringify(kzlddp));
    return kzlddp;
}

//优化三带二提示牌所带的牌  之前带的是手上的最小牌，缺点是带的牌可能会拆散手上的顺子对子连对等等
proto.getNewDaiPai = function (cards,tipAllKind,vgs,isHTSSC,tipCards) {
    let handCards = this.deepCloneTL(cards);
    let sdekdItem = [tipCards[3],tipCards[4]];
    let sdebzItem = [tipCards[0],tipCards[1],tipCards[2]];
    // console.warn("????? 优化三带二提示牌所带的牌  sdekdItem "+JSON.stringify(sdekdItem)+"  sdebzItem "+JSON.stringify(sdebzItem)+"  tipCards "+JSON.stringify(tipCards));
    let kzszdp = [];
    let kzlddp = [];
    let kzdzdp = [];
    let dsldcd = 0;//带三的连对长度
    for (var i = 0; i < tipAllKind.length; i++) {
        if(tipAllKind[i].type == STYLE.SHUNZI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let changeed = this.changeShunZiPai(tipCards,tipAllKind[i].tipCards[j],vgs,isHTSSC);
                for (var z = 0; z < changeed.length; z++) {
                    kzszdp = kzszdp.concat(changeed[z]);
                }
            }
        }
    }
    let sdTip = [];
    for (var i = 0; i < vgs.length; i++) {
        if(vgs[i].length == 3){
            sdTip[sdTip.length] = vgs[i];
        }
        if(!this.isZDBKC && vgs[i].length == 4){
            if(kzszdp.indexOf(vgs[i][0]) != -1) sdTip[sdTip.length] = [vgs[i][1],vgs[i][2],vgs[i][3]];
            else sdTip[sdTip.length] = [vgs[i][0],vgs[i][1],vgs[i][2]];
        }
    }
    for (var i = 0; i < tipAllKind.length; i++) {
        if(tipAllKind[i].type == STYLE.LIANDUI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let kzld = true;
                // console.warn("这里出错了？？？ "+tipAllKind[i].tipCards[j] + "   sdebzItem[0]  "+sdebzItem[0]+"   sdTip "+JSON.stringify(sdTip));
                let newLDList = this.changeLDByBZ(tipAllKind[i].tipCards[j],sdebzItem,sdTip);
                if( newLDList.length != tipAllKind[i].tipCards[j].length){
                    kzld = false;
                    kzlddp = kzlddp.concat(newLDList);
                }

                // if(tipAllKind[i].tipCards[j].indexOf(sdebzItem[0]) != -1) kzld = false;
                // if(this.getValuepx(tipAllKind[i].tipCards[j][0]) != this.getValuepx(sdebzItem[0])) kzld = false;
                if(kzld){
                    if(tipAllKind[i].tipCards[j].length == 4){
                        for (var z = 0; z < sdTip.length; z++) {
                            if(sdTip[z].indexOf(tipAllKind[i].tipCards[j][0]) != -1 || sdTip[z].indexOf(tipAllKind[i].tipCards[j][2] != -1)){
                                //拆开一个豹子去做4张的连对不划算
                                kzld = false;
                                break;
                            }
                        }
                    }
                }
                if(kzld){
                    kzlddp = kzlddp.concat(tipAllKind[i].tipCards[j]);
                    // if(isHTSSC && tipAllKind[i].tipCards[j][0] == 103) dsldcd = tipAllKind[i].tipCards[j].length;
                }
            }
        }
    }
    for (var i = 0; i < tipAllKind.length; i++) {
        if(tipAllKind[i].type == STYLE.YIDUI){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let kzdz =  true;
                if(this.getValuepx(tipAllKind[i].tipCards[j][0]) == this.getValuepx(sdebzItem[0])) kzdz = false;
                if(kzdz && kzlddp.indexOf(tipAllKind[i].tipCards[j][0]) != -1) kzdz = false;
                let pai = tipAllKind[i].tipCards[j][0];
                for (var z = 0; z < vgs.length; z++) {
                    if(vgs[z][0] == tipAllKind[i].tipCards[j][0]){
                        if(vgs[z].length == 4){
                            pai = vgs[3];
                            break;
                        }
                    }
                }
                if(kzdz && kzszdp.indexOf(pai) != -1) kzdz = false;
                if(kzdz){
                    kzdzdp = kzdzdp.concat(tipAllKind[i].tipCards[j]);
                }
            }
        }
    }
    // console.warn("得到三带四带可带牌数组 调整之后   kzdzdp  "+JSON.stringify(kzdzdp) +"  kzlddp   "+JSON.stringify(kzlddp)+"  kzszdp   "+JSON.stringify(kzszdp) );
    
    let kzdpdp = [];//可做单牌的牌
    for (var i = 0; i < handCards.length; i++) {
        let zszIndex = -1;//做顺子下标
        let zldIndex = -1;//做连对下标
        let zdzIndex = -1;//做对子下标
        zszIndex = kzszdp.indexOf(handCards[i]);
        zldIndex = kzlddp.indexOf(handCards[i]);
        zdzIndex = kzdzdp.indexOf(handCards[i]);
        if(zszIndex == -1 && zldIndex == -1 && zdzIndex == -1) {
            let iskd = true;
            for (var j = 0; j < sdTip.length; j++) {
                if(sdTip[j].indexOf(handCards[i]) != -1){
                    iskd = false;
                    break;
                }
            }
            if(iskd) kzdpdp[kzdpdp.length] = handCards[i];
        }
    }
    // console.warn("得到三带四带可带牌数组   kzdpdp  "+JSON.stringify(kzdpdp) );
    // if(isHTSSC && kzdpdp.indexOf(103) == -1){
    //     if(handCards.indexOf(103) != -1){//加这个判断是为了防止在首局黑桃三出牌之后判断第二家能否要起的时候把103添加给第二家的出牌提示
    //         kzdpdp = [103].concat(kzdpdp);
    //         if(vgs[0][0] == 103 && vgs[0].length == 2 && lianduiTip[0][0][0] == 103){
    //             //黑桃3首出的时候，由于必须带三导致带黑桃三的连对失败，就剔除掉连对列表里面带黑桃三的这个连对
    //             if(dsldcd == 2){
    //                 console.warn("得到三带四带可带牌数组111   kzdzdp  "+JSON.stringify(kzdzdp)+"  kzlddp  "+JSON.stringify(kzlddp) );
    //                 kzdzdp = [kzlddp[0],kzlddp[1],kzlddp[2],kzlddp[3]].concat(kzdzdp);
    //                 kzlddp =kzlddp.slice(4, kzlddp.length);
    //                 console.warn("得到三带四带可带牌数组222   kzdzdp  "+JSON.stringify(kzdzdp)+"  kzlddp  "+JSON.stringify(kzlddp) );
    //             }
    //             else if(dsldcd > 2){
    //                 kzdzdp = [kzlddp[0],kzlddp[1]].concat(kzdzdp);
    //                 kzlddp =kzlddp.slice(2, kzlddp.length);
    //             }
    //         }
    //     }
    // }
    let res = [];
    res = res.concat(kzdpdp);
    res = res.concat(kzdzdp);
    res = res.concat(kzlddp);
    res = res.concat(kzszdp);
    // console.warn("得到三带四带可带牌数组   结果去重之前  "+JSON.stringify(res));
    res = _.uniq(res);
    if(this.getValuepx(res[0]) > this.getValuepx(res[1]) && this.getValuepx(res[1]) == this.getValuepx(res[2])){
        let qsg = [res[1],res[2],res[0]];
        res = res.slice(3, res.length);
        res = qsg.concat(res);
    }
    // console.warn("得到三带四带可带牌数组   结果去重之后  "+JSON.stringify(res));
    return [res[0],res[1]];
}
//优化三带二提示牌所带的牌  之前带的是手上的最小牌，缺点是带的牌可能会拆散手上的顺子对子连对等等
proto.getKeDaisSort2 = function (cards,_tipAllKind,_vgs,isHTSSC) {
    if(cards.length <= 5) return
    let tipAllKind = this.deepCloneTL(_tipAllKind);
    let vgs = this.deepCloneTL(_vgs);
    let handCards = this.deepCloneTL(cards);
    for (var i = 0; i < tipAllKind.length; i++) {
        if(tipAllKind[i].type == STYLE.SANDAIER){
            for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
                let sdetsItem = tipAllKind[i].tipCards[j];
                let sdekdItem = [tipAllKind[i].tipCards[j][3],tipAllKind[i].tipCards[j][4]]
                let isHeLi = this.getIsHeLi(sdekdItem,tipAllKind)//这个三带二带的是否需要优化
                // console.warn("三带二提示牌  "+JSON.stringify(tipAllKind[i].tipCards[j])+"  带的牌  "+sdekdItem+"  是否合理  "+JSON.stringify(isHeLi));
                if(!isHeLi.isheli){
                    let newDaiPai = this.getNewDaiPai(handCards,tipAllKind,vgs,isHTSSC,tipAllKind[i].tipCards[j])
                    tipAllKind[i].tipCards[j][3] = newDaiPai[0];
                    tipAllKind[i].tipCards[j][4] = newDaiPai[1];
                    _tipAllKind[i].tipCards[j] = tipAllKind[i].tipCards[j];
                }
            }
        }
    }
}

//得到三带四带可带牌数组  之前带的是手上的最小牌，缺点是带的牌可能会拆散手上的顺子对子连对等等
// proto.getKeDaisSort = function (cards,_tipAllKind,_vgs,isHTSSC,sdTip) {
//     let tipAllKind = this.deepCloneTL(_tipAllKind);
//     let vgs = this.deepCloneTL(_vgs);
//     let handCards = this.deepCloneTL(cards);
//     let kzszdp = [];
//     for (var i = 0; i < tipAllKind.length; i++) {
//         if(tipAllKind[i].type == STYLE.SHUNZI){
//             for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
//             //     let iskd = true;
//             //     for (var z = 0; z < sdTip.length; z++) {
//             //         for (var x = 0; x < sdTip[z].length; x++) {
//             //             if(tipAllKind[i].tipCards[j].indexOf(sdTip[z][x]) != -1){
//             //                 iskd = false;
//             //                 break;
//             //             }
//             //         }
//             //         if(iskd == false) break;       
//             //     }
//             //     console.warn("得到三带四带可带牌数组  提示里面可做顺子的牌   "+JSON.stringify(tipAllKind[i].tipCards[j])+"  iskd  "+iskd);
//             //     if(!iskd) continue;
//                 kzszdp = kzszdp.concat(tipAllKind[i].tipCards[j]);
//             } 
//         }
//     }
//     console.warn("得到三带四带可带牌数组  可做顺子的牌   "+JSON.stringify(kzszdp)+"  手牌  "+JSON.stringify(handCards)+"  vgs  "+JSON.stringify(vgs) );
//     let duiziList = [];
//     let duiziList2 = [];
//     // let pzgsList = [];//牌值个数list
//     for (var i = 0; i < vgs.length; i++) {
//         let iskd = true;
//         for (var j = 0; j < sdTip.length; j++) {
//             if(sdTip[j].indexOf(vgs[i][0]) != -1){
//                 iskd = false;
//                 break;
//             }
//         }
//         if(!iskd) continue;
//         if(vgs[i].length == 2 || vgs[i].length == 3){
//             duiziList[duiziList.length] = [vgs[i][0],vgs[i][1]];
//             duiziList2[duiziList2.length] = [vgs[i][0],vgs[i][1]];
//         }
//         if(!this.isZDBKC && vgs[i].length == 4){
//             duiziList[duiziList.length] = [vgs[i][0],vgs[i][1]];
//             duiziList2[duiziList2.length] = [vgs[i][0],vgs[i][1]];
//             duiziList2[duiziList2.length] = [vgs[i][2],vgs[i][3]];
//         }
//     }
//     let lianduiList = [];
//     let dsldcd = 0;//带三的连对长度
//     if(duiziList.length >= 2){  
//         let pdz = this.getValuepx(duiziList[0][0]); 
//         if(isHTSSC && pdz == 3 && duiziList[0][0] == 103) dsldcd = 1;
//         let pdIndex = 0;
//         lianduiList[0] = [duiziList[0]];
//         // console.warn("出牌提示  连对list   "+JSON.stringify(lianduiList));
//         for (var i = 1; i < duiziList.length; i++) {
//             if((pdz+i-pdIndex) == this.getValuepx(duiziList[i][0])){
//                 if(isHTSSC && pdz == 3) dsldcd++;
//                 let lianduiListLastItemIndex = lianduiList.length-1;
//                 let lianduiListLastItemLastIndex = lianduiList[lianduiList.length-1].length;
//                 lianduiList[lianduiListLastItemIndex][lianduiListLastItemLastIndex] = duiziList[i];
//             }
//             else{
//                 // console.warn("出牌提示  连对到这里了嘛222   "+JSON.stringify(duiziList[i]));
//                 lianduiList[lianduiList.length] = [];
//                 lianduiList[lianduiList.length-1] = [duiziList[i]];
//                 pdz = this.getValuepx(duiziList[i][0]);
//                 pdIndex = i;
//             }
//         }
//     }
//     let lianduiTip = [];
//     for (var i = 0; i < lianduiList.length; i++) {
//         if(lianduiList[i].length >= 2){
//             let lds = [];
//             for (var j = 0; j < lianduiList[i].length; j++) {
//                 lds = lds.concat(lianduiList[i][j])
//             }
//             lianduiTip[lianduiTip.length] = lds;
//         }
//     }
//     let kzlddp = [];//可做连对的牌
//     for (var j = 0; j < lianduiTip.length; j++) {
//         for (var z= 0; z < lianduiTip[j].length; z++) {
//             kzlddp = kzlddp.concat(lianduiTip[j][z]);
//         }
//     }
//     let kzdzdp = [];//可做对子的牌
//     for (var i = 0; i < duiziList2.length; i++) {
//         let iskzld = false;
//         for (var j = 0; j < lianduiTip.length; j++) {
//             if(iskzld) break;
//             for (var z= 0; z < lianduiTip[j].length; z++) {
//                 if(duiziList2[i][0] == lianduiTip[j][z][0]){
//                     iskzld = true;
//                     break;
//                 }
//             }
//         }
//         if(!iskzld) kzdzdp = kzdzdp.concat(duiziList2[i]);
//     }
//     console.warn("得到三带四带可带牌数组   duiziList  "+JSON.stringify(duiziList) +"  lianduiTip   "+JSON.stringify(lianduiTip) );
//     console.warn("得到三带四带可带牌数组   kzdzdp  "+JSON.stringify(kzdzdp) +"  kzlddp   "+JSON.stringify(kzlddp) );
//     // let kzdpdp = [];
//     // for (var i = 0; i < vgs.length; i++) {
//     //     if(vgs[i].length == 1 ) kzdpdp[kzdpdp.length] =[vgs[i][0];
//     // }
//     for (var i = 0; i < handCards.length; i++) {
//         let zszIndex = -1;//做顺子下标
//         let zldIndex = -1;//做连对下标
//         let zdzIndex = -1;//做对子下标
//         zszIndex = kzszdp.indexOf(handCards[i]);
//         zldIndex = kzlddp.indexOf(handCards[i]);
//         zdzIndex = kzdzdp.indexOf(handCards[i]);
//         if(zszIndex == -1 && zldIndex == -1 && zdzIndex == -1) {
//         }
//         else{
//             let vg = [];//牌值列表
//             for (var j = 0; j < vgs.length; j++) {
//                 if(vgs[j][0] == handCards[i]) {
//                     vg = vgs[j];
//                     break;
//                 }
//             }
//             // if(vg.length >= 3){
//                 if(vg.length == 2){
//                     console.warn("到这里了嘛？？？ ",zszIndex,zdzIndex,handCards[i]);
//                     if(zszIndex != -1 && zdzIndex != -1) {
//                         console.warn("到这里了嘛？？？222 ",zszIndex,zdzIndex,handCards[i]);
//                         let cards = kzdzdp.slice(0, zdzIndex);////手牌数组的前zdzIndex个元素
//                         cards = cards.concat(kzdzdp.slice(zdzIndex + 2));
//                         kzdzdp = [];
//                         kzdzdp = this.deepCloneTL(cards);
//                     }
//                 }
//                 if(vg.length == 3){
//                     if(zldIndex != -1){
//                         kzlddp[zldIndex] = vg[1];
//                         kzlddp[zldIndex+1] = vg[2];
//                     }
//                     else if(zszIndex != -1 && zdzIndex != -1) {
//                         kzlddp[zldIndex] = vg[1];
//                         kzlddp[zldIndex+1] = vg[2];
//                     }
//                 }
//                 // else if(vg.length == 4){
//                 //     if(zldIndex != -1){
//                 //         kzlddp[zldIndex] = vg[2];
//                 //         kzlddp[zldIndex+1] = vg[3];
//                 //     }
//                 //     else if(zszIndex != -1 && zdzIndex != -1) {
//                 //         kzlddp[zldIndex] = vg[2];
//                 //         kzlddp[zldIndex+1] = vg[3];
//                 //     }
//                 // }
//             // }
//         }
//     }
//     console.warn("得到三带四带可带牌数组 调整之后   kzdzdp  "+JSON.stringify(kzdzdp) +"  kzlddp   "+JSON.stringify(kzlddp) );
//     let kzdpdp = [];//可做单牌的牌
//     for (var i = 0; i < handCards.length; i++) {
//         // console.warn("出牌提示  ??   "+handCards[i]+ "  v  "+this.getValuepx(handCards[i])+"  三带牌值  "+JSON.stringify(sdPaiZhi) );
//         // let iddp = (kzszdp.indexOf(handCards[i]) == -1);
//         // if(iddp) iddp = (kzlddp.indexOf(handCards[i]) == -1);
//         // if(iddp) iddp = (kzdzdp.indexOf(handCards[i]) == -1);
//         // if(iddp) {
//         //     kzdpdp[kzdpdp.length] = handCards[i];
//         // }
//         let zszIndex = -1;//做顺子下标
//         let zldIndex = -1;//做连对下标
//         let zdzIndex = -1;//做对子下标
//         zszIndex = kzszdp.indexOf(handCards[i]);
//         zldIndex = kzlddp.indexOf(handCards[i]);
//         zdzIndex = kzdzdp.indexOf(handCards[i]);
//         if(zszIndex == -1 && zldIndex == -1 && zdzIndex == -1) {
//             let iskd = true;
//             for (var j = 0; j < sdTip.length; j++) {
//                 if(sdTip[j].indexOf(handCards[i]) != -1){
//                     iskd = false;
//                     break;
//                 }
//             }
//             if(iskd) kzdpdp[kzdpdp.length] = handCards[i];
//         }
//     }
//     console.warn("得到三带四带可带牌数组   kzdpdp  "+JSON.stringify(kzdpdp) );
//     if(isHTSSC && kzdpdp.indexOf(103) == -1){
//         if(handCards.indexOf(103) != -1){//加这个判断是为了防止在首局黑桃三出牌之后判断第二家能否要起的时候把103添加给第二家的出牌提示
//             kzdpdp = [103].concat(kzdpdp);
//             if(vgs[0][0] == 103 && vgs[0].length == 2 && lianduiTip[0][0][0] == 103){
//                 //黑桃3首出的时候，由于必须带三导致带黑桃三的连对失败，就剔除掉连对列表里面带黑桃三的这个连对
//                 if(dsldcd == 2){
//                     console.warn("得到三带四带可带牌数组111   kzdzdp  "+JSON.stringify(kzdzdp)+"  kzlddp  "+JSON.stringify(kzlddp) );
//                     kzdzdp = [kzlddp[0],kzlddp[1],kzlddp[2],kzlddp[3]].concat(kzdzdp);
//                     kzlddp =kzlddp.slice(4, kzlddp.length);
//                     console.warn("得到三带四带可带牌数组222   kzdzdp  "+JSON.stringify(kzdzdp)+"  kzlddp  "+JSON.stringify(kzlddp) );
//                 }
//                 else if(dsldcd > 2){
//                     kzdzdp = [kzlddp[0],kzlddp[1]].concat(kzdzdp);
//                     kzlddp =kzlddp.slice(2, kzlddp.length);
//                 }
//             }
//         }
//     }
//     let res = [];
//     res = res.concat(kzdpdp);
//     res = res.concat(kzdzdp);
//     res = res.concat(kzlddp);
//     res = res.concat(kzszdp);
//     console.warn("得到三带四带可带牌数组   结果去重之前  "+JSON.stringify(res));
//     res = _.uniq(res);
//     // return _.uniq(res);
//     // console.warn("得到三带四带可带牌数组   结果去重之后  "+JSON.stringify(res));
//     if(this.getValuepx(res[0]) > this.getValuepx(res[1]) && this.getValuepx(res[1]) == this.getValuepx(res[2])){
//         let qsg = [res[1],res[2],res[0]];
//         res = res.slice(3, res.length);
//         res = qsg.concat(res);
//     }
//     return res;
// }

/**
 * 根据牌返回牌值的个数
 * 如[202,203,204,302,403]  返回[1,2,2]   1个4  2个2  2个3
   如[102,302,402,106,306,406,307,107,207,308,108,408,208,]   返回[ 3, 3, 3, 4 ]
 * @param {*} cards 
 */
proto.getPokeValueArr = function (cards) {
    // console.warn("根据牌返回牌值的个数111    "+JSON.stringify(cards));
    // 根据牌返回牌值的个数111    [107,106,105,404,104,403,103]
    var getLogicValue = function (card) {
        let value = card % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value;
    };
    var cg = _.groupBy(_.map(cards, function (n) { return getLogicValue(n) }));
    // console.warn("根据牌返回牌值的个数222    "+JSON.stringify(cg));
    // 根据牌返回牌值的个数222    {"3":[3,3],"4":[4,4],"5":[5],"6":[6],"7":[7]}
    var cgs = Object.keys(cg);
    // console.warn("根据牌返回牌值的个数333    "+JSON.stringify(cgs));
    // 根据牌返回牌值的个数333    ["3","4","5","6","7"]
    var ng = _.map(cgs, function (n) { return cg[n].length });
    // console.warn("根据牌返回牌值的个444    "+JSON.stringify(ng));
    // 根据牌返回牌值的个444    [2,2,1,1,1]
    ng = _.sortBy(ng);
    // console.warn("根据牌返回牌值的个555    "+JSON.stringify(ng));
    // 根据牌返回牌值的个555    [1,1,1,2,2]
    return ng;
}

proto.aCardIsHefa = function (card) {
    return this.getType(card) >= 1 && this.getType(card) <= 4 && this.getValue(card) >= 1 && this.getValue(card) <= 13
}

//得到手牌中牌值最大的数组
proto.getMaxDanList = function (cards) {
    let max = 0;
    for(var i = 0; i < cards.length; i++){ //遍历当前数组 
        let v = this.getValuepx(cards[i]);
        if(v > max) max = v;
    }
    let res = [];
    for(var i = 0; i < cards.length; i++){ //遍历当前数组 
        let v = this.getValuepx(cards[i]);
        if(v == max) res[res.length] = cards[i];
    }
    return res;
}

//得到list中是否含有豹子  用于判断连对是否拆了豹子
proto.getIsHanBaozi = function (list,vgs) {
    for (var i = 0; i < vgs.length; i++) {
        if(vgs[i].length >= 3 ){
            for (var j = 0; j < list.length; j++) {
                if(vgs[i].indexOf(list[j]) != -1) return true;
            }
        }
    }
    return false;
}

// // TL++出牌提示  chairID(TL++这个参数)  手牌 上家出牌  是否黑桃三首出  是否下家只剩一张了
proto.getOutTip = function (chairID,_handCards,lastOut,isHTSSC,isXJZSYZ) {
    // console.error("sscc777出牌提示handCards",chairID,JSON.stringify(_handCards),JSON.stringify(lastOut),isHTSSC);

    let tipRes = [];////最终返回结果
    let handCards = _.clone(_handCards);
    var ng = _.groupBy(handCards, function (n) { 
        let value = n % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    // console.warn("222出牌提示 ",JSON.stringify(ng));
    var kgs = Object.keys(ng);
    // console.warn("出牌提示根据牌返回牌值的个数333   kgs "+JSON.stringify(kgs));
    let vgs = _.sortBy(ng, function(o) { 
        let value = o[0] % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    // console.warn("根据牌返回牌值的个数444   vgs "+JSON.stringify(vgs));
    let pzfbqk = this.getPokeValueArr(handCards);//牌值分布情况
    let lpzfbqk = [];//上次有效出牌牌值分布情况
    if(lastOut.cards.length > 0){
        lpzfbqk = this.getPokeValueArr(lastOut.cards);
    }
    // console.warn("222出牌提示 手牌牌值分布情况  ",JSON.stringify(pzfbqk));
    // console.warn("222出牌提示 上次出牌牌值分布情况  ",JSON.stringify(lpzfbqk));


    let spCount = handCards.length;
    let tipAllKind = [];////提示的所有种可能性   
    let bkzcszddp = [];//不可组成顺子的单牌 
    let isKeShunzi = false;
    let isblFirst = (lastOut.type == -1 && lastOut.cards.length == 0);//是否本轮第一个出牌

    let baoziList = [];
    for (var i = 0; i < vgs.length; i++) {
        if(vgs[i].length == 3 ) baoziList[baoziList.length] = [vgs[i][0],vgs[i][1],vgs[i][2]];
        if(!this.isZDBKC && vgs[i].length == 4) baoziList[baoziList.length] = [vgs[i][0],vgs[i][1],vgs[i][2]];
    }
    // console.warn("出牌提示  豹子list   "+JSON.stringify(baoziList));
    if(baoziList.length >= 2){
        let lianbaoList = [];
        let pdz = this.getValuepx(baoziList[0][0]);
        let pdIndex = 0;
        lianbaoList[0] = [baoziList[0]];
        // console.warn("出牌提示  豹子list   "+JSON.stringify(baoziList));
        for (var i = 1; i < baoziList.length; i++) {
            // console.warn("出牌提示  豹子 i "+i+"  pdz   "+pdz+"  pdIndex   "+pdIndex);
            if((pdz+i-pdIndex) == this.getValuepx(baoziList[i][0])){
                let lianbaoListLastItemIndex = lianbaoList.length-1;
                let lianbaoListLastItemLastIndex = lianbaoList[lianbaoList.length-1].length;
                // console.warn("出牌提示  豹子到这里了嘛111   "+lianbaoListLastItemIndex+"  "+lianbaoListLastItemLastIndex+"  "+JSON.stringify(lianbaoList));
                lianbaoList[lianbaoListLastItemIndex][lianbaoListLastItemLastIndex] = baoziList[i];
            }
            else{
                // console.warn("出牌提示  豹子到这里了嘛222   "+JSON.stringify(lianbaoList));
                lianbaoList[lianbaoList.length] = [];
                lianbaoList[lianbaoList.length-1] = [baoziList[i]];
                pdz = this.getValuepx(baoziList[i][0]);
                pdIndex = i;
            }
        }
        // console.warn("出牌提示  lianbaolist   "+JSON.stringify(lianbaoList));
        let lianbaoList2 = [];
        let fjPaiZhi = [];
        for (var i = 0; i < lianbaoList.length; i++) {
            if(lianbaoList[i].length >= 2){
                for (var j = 0; j < lianbaoList[i].length; j++) {
                    fjPaiZhi[fjPaiZhi.length] = this.getValuepx(lianbaoList[i][j][0])
                }
                lianbaoList2[lianbaoList2.length] = lianbaoList[i];
            }
        }
        // console.warn("出牌提示  lianbaolist2   "+JSON.stringify(lianbaoList2)+"  飞机3张牌值  "+JSON.stringify(fjPaiZhi));
        if(lianbaoList2.length > 0){
            if(lastOut.type == STYLE.FEIJI && lastOut.cards.length == 10){
                //别人打的是个2连豹的飞机，自己手上是个3连豹（4连豹）的飞机，将自己的3（4）连豹拆分成多个2连豹的飞机
                if(lianbaoList2.length == 1 && lianbaoList2[0].length > 2){
                    let lianbaoList3 = [];
                    let item = [];
                    for (var i = 0; i < lianbaoList2[0].length; i++) {
                        if(item.length < 2) item[item.length] = lianbaoList2[0][i];
                        if(item.length == 2){
                            lianbaoList3[lianbaoList3.length] = item;
                            item = [];
                            item[item.length] = lianbaoList2[0][i];
                        }
                    }
                    lianbaoList2 = [];
                    for (var i = 0; i < lianbaoList3.length; i++) {
                        if(lianbaoList3[i].length >= 2){
                            lianbaoList2[lianbaoList2.length] = lianbaoList3[i];
                        }
                    }
                    // console.warn("出牌提示  lianbaolist3   "+JSON.stringify(lianbaoList3)+"  lianbaoList2  "+JSON.stringify(lianbaoList2));
                }
            }

            let kedais = [];
            for (var i = 0; i < handCards.length; i++) {
                // console.warn("出牌提示  ??   "+handCards[i]+ "  v  "+this.getValuepx(handCards[i])+"  三带牌值  "+JSON.stringify(sdPaiZhi) );
                if(!this.isZDBKC){
                    if(fjPaiZhi.indexOf(this.getValuepx(handCards[i])) == -1) kedais[kedais.length] = handCards[i];
                }
                else{
                    let iszd = false;
                    for (var j = 0; j < vgs.length; j++) {
                        if(vgs[j].length == 4 && vgs[j].indexOf(handCards[i]) != -1){
                            iszd = true;
                            break;
                        }
                    }
                    if(!iszd && fjPaiZhi.indexOf(this.getValuepx(handCards[i])) == -1) kedais[kedais.length] = handCards[i];
                }
                if(kedais.length >= lianbaoList2[0].length*2) break
            }
            let ckedais = this.deepCloneTL(kedais);
            // console.warn("出牌提示  飞机list   "+JSON.stringify(lianbaoList2)+"  可带  "+kedais);
            let feijiTip = [];
            for (var i = 0; i < lianbaoList2.length; i++) {
                if(lianbaoList2[i].length >= 2){
                    if(spCount >= lianbaoList2[i].length*5){
                        kedais = this.deepCloneTL(ckedais);
                        if(kedais.length < lianbaoList2[i].length*2){
                            // console.warn("手上的单牌不够飞机带，就需要拆豹子带了"+"  可带  "+kedais+"   handCards[j]  "+handCards[j]);
                            //手上的单牌不够飞机带，就需要拆豹子带了
                            for (var j = 0; j < handCards.length; j++) {
                                let isCanAddToFJkedais = true;//是否可以添加进飞机可带
                                for (var jj = 0; jj < lianbaoList2[i].length; jj++) {
                                    if(lianbaoList2[i][jj].indexOf(handCards[j]) != -1 || kedais.indexOf(handCards[j]) != -1){
                                        isCanAddToFJkedais = false;
                                        break;
                                    }
                                }
                                if(isCanAddToFJkedais) {
                                    kedais[kedais.length] = handCards[j];
                                }
                                else continue;
                                if(kedais.length >= lianbaoList2[i].length*2) break
                            }
                        }
                        let dd = [kedais[0],kedais[1],kedais[2],kedais[3]];
                        if(lianbaoList2[i].length == 3) dd = dd.concat([kedais[4],kedais[5]]);
                        feijiTip[feijiTip.length] = [];
                        for (var j = 0; j < lianbaoList2[i].length; j++) {
                            feijiTip[feijiTip.length-1] = feijiTip[feijiTip.length-1].concat(lianbaoList2[i][j]);
                        }
                        feijiTip[feijiTip.length-1] = feijiTip[feijiTip.length-1].concat(dd);
                    }
                    else{
                        if(isblFirst){
                            feijiTip[feijiTip.length] = [];
                            for (var j = 0; j < lianbaoList2[i].length; j++) {
                                feijiTip[feijiTip.length-1] = feijiTip[feijiTip.length-1].concat(lianbaoList2[i][j]);
                            }
                            feijiTip[feijiTip.length-1] = feijiTip[feijiTip.length-1].concat(kedais);
                        }
                    }
                }
            }

            // console.warn("出牌提示  飞机结果   "+JSON.stringify(feijiTip));
            if(feijiTip.length > 0){
                tipAllKind[tipAllKind.length] = {
                    type: STYLE.FEIJI,
                    tipCards: feijiTip
                };
            }
        }
    }

    if(spCount >= 5){
        let bkzsz = [];
        if(this.isZDBKC){
            for (var i = 0; i < vgs.length; i++) {
                if(vgs[i].length == 4 ) bkzsz[bkzsz.length] = this.getValuepx(vgs[i][0]);
            }
        }
        // console.warn("不可左顺子的牌值   "+JSON.stringify(bkzsz)+"  kgs  "+JSON.stringify(kgs));
        let szgs = 0;
        let szpz = [];
        let sindex = 0;
        if(bkzsz.length > 0 ){
            for (var i = 0; i < kgs.length; i++) {
                if(parseInt(kgs[i]) == 15) continue;
                if(bkzsz.indexOf(parseInt(kgs[i])) == -1) {
                    szpz[0] = [kgs[i]];
                    sindex = i+1;
                    break;
                }
            }
        }
        else{
            szpz[0] = [kgs[0]];
            sindex = 1;
        }
        // console.warn("出牌提示  顺子牌值111   "+JSON.stringify(szpz) );
        if(szpz.length > 0) {
            for (var i = sindex; i < kgs.length; i++) {
                if (parseInt(kgs[i]) == 15) continue;
                if (bkzsz.length > 0 && bkzsz.indexOf(parseInt(kgs[i])) != -1) continue;
                if ((parseInt(szpz[szgs][0]) + szpz[szgs].length) == parseInt(kgs[i])) {
                    szpz[szgs][szpz[szgs].length] = kgs[i];
                } else {
                    if (szpz[szgs].length >= 5) szgs++;
                    szpz[szgs] = [kgs[i]];
                }
            }

            // console.warn("出牌提示  顺子牌值111   "+JSON.stringify(szpz) );
            if (_.last(szpz).length < 5) {
                szpz = _.initial(szpz);
            }
        }
        // console.warn("出牌提示  顺子牌值222   "+JSON.stringify(szpz) );
        // if(isKeShunzi){
        let szTip = [];
        for (var i = 0; i < szpz.length; i++) {
            if(szpz[i].length < 5) continue
            szTip[i] = [];
            for (var j = 0; j < szpz[i].length; j++) {
                if(j == 0 && szpz[i][j] == "3"){
                    if(ng["3"].indexOf(103) != -1) szTip[i][j] = 103;
                    else szTip[i][j] = ng["3"][0];
                }
                else szTip[i][j] = ng[szpz[i][j]][0]
            }
        }
        if(lastOut.type == STYLE.SHUNZI ){
            //上家出顺子的话把自己手上能大过的顺子加入提示数组
            // console.warn("上家出顺子的话把自己手上能大过的顺子加入提示数组");
            let isExitBiger = false;//是否存在更大的
            for (var i = 0; i < szpz.length; i++) {
                if(szpz[i].length == lastOut.cards.length){
                    if(parseInt(szpz[i][0]) > this.getValuepx(lastOut.cards[0])){
                        isExitBiger = true;
                        break;
                    }
                }
            }
            // console.warn("shifou有现成的能大过的提示数组   "+isExitBiger+"  szpz "+JSON.stringify(szpz));
            if(!isExitBiger){
                //上面的写法是只提示出来一个最小的能大的过的顺子，下面是提示出来所有能大得过的顺子
                for (var i = 0; i < szpz.length; i++) {
                    if(szpz[i].length >= lastOut.cards.length){
                        // console.warn("看看自己顺子的最大值能否大过别人出的顺子的最大值    ",parseInt(szpz[i][szpz[i].length-1]) , this.getValuepx(lastOut.cards[lastOut.cards.length-1]));
                        if(parseInt(szpz[i][szpz[i].length-1]) > this.getValuepx(lastOut.cards[lastOut.cards.length-1])){
                            let minIndex = -1;
                            for (var jj = 0; jj < szpz[i].length; jj++) {
                                if(parseInt(szpz[i][jj]) > this.getValuepx(lastOut.cards[0])){
                                    minIndex = jj;
                                    // minIndex2 = jj;
                                    break;
                                }
                            }
                            // console.warn("找大的过的顺子 "+minIndex+"   "+szpz[i].length +"   "+ (minIndex+lastOut.cards.length));
                            if(minIndex > -1){
                                //提示一个能大得过的最小顺子
                                if(szpz[i].length < minIndex+lastOut.cards.length){
                                    break;//手上的大的过的顺子不够长
                                } 
                                let geshu = szpz[i].length - minIndex-lastOut.cards.length
                                for (var z = 0; z <= geshu; z++) {
                                    // console.warn("找大的过的顺子 "+minIndex+"   "+szpz[i].length +"   "+ geshu);
                                    let newbigger = [];
                                    for (var j = minIndex; j < minIndex+lastOut.cards.length; j++) {
                                        newbigger[newbigger.length] = ng[szpz[i][j]][0];
                                    }
                                    // console.warn("加入大的过的顺子 "+JSON.stringify(newbigger));
                                    szTip[szTip.length] = newbigger;
                                    minIndex++;
                                }
                            }
                        }
                    }
                }
            }
            else{
                //有现成的能大过的提示数组,再把更长的顺子拆开的能大的过的进行提示
                for (var i = 0; i < szpz.length; i++) {
                    let isNeedPD = true;
                    if(szpz[i].length == lastOut.cards.length){
                        if(parseInt(szpz[i][0]) > this.getValuepx(lastOut.cards[0])){
                            isNeedPD = false;
                            break;
                        }
                    }
                    if(isNeedPD){
                        if(szpz[i].length >= lastOut.cards.length){
                            // console.warn("看看自己顺子的最大值能否大过别人出的顺子的最大值    ",parseInt(szpz[i][szpz[i].length-1]) , this.getValuepx(lastOut.cards[lastOut.cards.length-1]));
                            if(parseInt(szpz[i][szpz[i].length-1]) > this.getValuepx(lastOut.cards[lastOut.cards.length-1])){
                                let minIndex = -1;
                                for (var jj = 0; jj < szpz[i].length; jj++) {
                                    if(parseInt(szpz[i][jj]) > this.getValuepx(lastOut.cards[0])){
                                        minIndex = jj;
                                        // minIndex2 = jj;
                                        break;
                                    }
                                }
                                // console.warn("找大的过的顺子 "+minIndex+"   "+szpz[i].length +"   "+ (minIndex+lastOut.cards.length));
                                if(minIndex > -1){
                                    //提示一个能大得过的最小顺子
                                    if(szpz[i].length < minIndex+lastOut.cards.length){
                                        break;//手上的大的过的顺子不够长
                                    } 
                                    let geshu = szpz[i].length - minIndex-lastOut.cards.length
                                    for (var z = 0; z <= geshu; z++) {
                                        // console.warn("找大的过的顺子 "+minIndex+"   "+szpz[i].length +"   "+ geshu);
                                        let newbigger = [];
                                        for (var j = minIndex; j < minIndex+lastOut.cards.length; j++) {
                                            newbigger[newbigger.length] = ng[szpz[i][j]][0];
                                        }
                                        // console.warn("加入大的过的顺子 "+JSON.stringify(newbigger));
                                        szTip[szTip.length] = newbigger;
                                        minIndex++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        // console.warn("出牌提示  顺子牌值2   "+JSON.stringify(szTip) );
        tipAllKind[tipAllKind.length] = {
            type: STYLE.SHUNZI,
            tipCards: szTip
        };
    }

    // let isKeSidai = false;
    if(!this.isZDBKC && pzfbqk.indexOf(4) != -1){
        //可四带
        let sdTip = [];
        let sdPaiZhi = [];
        if(this.isCanSiDaiEr || this.isSiCanDaiSan){
            for (var i = 0; i < vgs.length; i++) {
                if(vgs[i].length == 4){
                    sdTip[sdTip.length] = vgs[i];
                    sdPaiZhi = sdPaiZhi.concat(vgs[i]);
                }
            }
        }
        // console.warn("出牌提示  四带   "+JSON.stringify(sdTip)+"  四带牌值  "+JSON.stringify(sdPaiZhi) );
        if(sdTip.length > 0){
            let sdeTip = [];
            let kedais = [];
            for (var i = 0; i < handCards.length; i++) {
                if(sdPaiZhi.indexOf(handCards[i]) == -1) kedais[kedais.length] = handCards[i];
                if(kedais.length >= 3) break
            }
            if(this.isCanSiDaiEr){
                if(spCount >= 6){
                    let dd = [kedais[0],kedais[1]]
                    for (var i = 0; i < sdTip.length; i++) {
                        sdeTip[i] = sdTip[i].concat(dd);
                    }
                }
                else{
                    if(isblFirst){
                        for (var i = 0; i < sdTip.length; i++) {
                            sdeTip[i] = sdTip[i].concat(kedais);
                        }
                    }
                }
                // console.warn("出牌提示  四带2   "+JSON.stringify(sdeTip) );
                tipAllKind[tipAllKind.length] = {
                    type: STYLE.SIDAIER,
                    tipCards: sdeTip
                };
            }
            if(this.isSiCanDaiSan){
                let sdsTip = [];
                if(spCount >= 7){
                    for (var i = 0; i < sdTip.length; i++) {
                        sdsTip[i] = sdTip[i].concat(kedais);
                    }
                }
                else{
                    if(isblFirst){
                        for (var i = 0; i < sdTip.length; i++) {
                            sdsTip[i] = sdTip[i].concat(kedais);
                        }
                    }
                }
                // console.warn("出牌提示  四带3   "+JSON.stringify(sdsTip) );
                tipAllKind[tipAllKind.length] = {
                    type: STYLE.SIDAISAN,
                    tipCards: sdsTip
                };
            }
            // console.warn("出牌提示  四带22   "+JSON.stringify(sdTip)+"  四带牌值  "+JSON.stringify(sdPaiZhi) );
        }
    }

    if(pzfbqk.indexOf(3) != -1 || (!this.isZDBKC && pzfbqk.indexOf(4) != -1)){
        let sidPaiZhi = [];//手上的炸弹牌，炸弹不可拆时带牌不能带炸弹
        if(this.isZDBKC && pzfbqk.indexOf(4) != -1){
            for (var i = 0; i < vgs.length; i++) {
                if(vgs[i].length == 4){
                    sidPaiZhi = sidPaiZhi.concat(vgs[i]);
                }
            }
        }
        //可三带
        let sdTip = [];
        let sdPaiZhi = [];
        // let ydz = [];
        for (var i = 0; i < vgs.length; i++) {
            // if(vgs[i].length == 2){
            //     ydz[ydz.length] = vgs[i];
            // }
            if(vgs[i].length == 3){
                sdTip[sdTip.length] = vgs[i];
                sdPaiZhi = sdPaiZhi.concat([this.getValuepx(vgs[i][0])]);
                // ydz[ydz.length] = [vgs[0],vgs[1]];
            }
            if(!this.isZDBKC && vgs[i].length == 4){
                sdTip[sdTip.length] = [vgs[i][0],vgs[i][1],vgs[i][2]];
                sdPaiZhi = sdPaiZhi.concat([this.getValuepx(vgs[i][0])]);
                // ydz[ydz.length] = [vgs[0],vgs[1]];
            }
        }
        // console.warn("出牌提示  三带   "+JSON.stringify(sdTip)+"  三带牌值  "+JSON.stringify(sdPaiZhi)+"  四带牌值  "+JSON.stringify(sidPaiZhi) );
        if(sdTip.length > 0){
            let sdeTip = [];
            let kedais = [];
            for (var i = 0; i < handCards.length; i++) {
                // console.warn("出牌提示  ??   "+handCards[i]+ "  v  "+this.getValuepx(handCards[i])+"  三带牌值  "+JSON.stringify(sdPaiZhi) );
                // if(sdPaiZhi.indexOf(this.getValuepx(handCards[i])) == -1) kedais[kedais.length] = handCards[i];
                let iskd = true;
                for (var j = 0; j < sdTip.length; j++) {
                    // console.warn("出牌提示  三带  j "+j+"  三带牌值  "+JSON.stringify(sdTip)+"  四带牌值  "+JSON.stringify(sidPaiZhi)+"  handCards[i]  "+handCards[i] );
                    if(sdTip[j].indexOf(handCards[i]) != -1){
                        iskd = false;
                        break;
                    }
                    if(this.isZDBKC && sidPaiZhi.indexOf(handCards[i]) != -1){
                        // 炸弹不可拆时带牌不能带炸弹
                        iskd = false;
                        break;
                    }
                }
                if(iskd) kedais[kedais.length] = handCards[i];
                if(kedais.length >= 2) break;
            }
            
            // console.warn("出牌提示  三带可带牌   "+JSON.stringify(kedais))
            if(spCount == 3){
                if(lastOut.type == -1 && lastOut.cards.length == 0){
                    if(sdTip.length == 1){
                        // 打到最后剩3张牌的时候，才可以3不带；
                        let sdyTip = [];
                        sdyTip[0] = sdTip[0].concat(kedais);
                        tipAllKind[tipAllKind.length] = {
                            type: STYLE.SANDAIYI,
                            tipCards: sdyTip
                        };
                    }   
                }
            }
            else if(spCount == 4){
                if(lastOut.type == -1 && lastOut.cards.length == 0){
                    // 打到最后剩4张牌的时候，才可以3带1；
                    if(sdTip.length == 1){
                        let sdyTip = [];
                        for (var i = 0; i < handCards.length; i++) {
                            if(sdTip[0].indexOf(handCards[i]) == -1){
                                kedais = [handCards[i]];
                                break;
                            }
                        }
                        sdyTip[0] = sdTip[0].concat(kedais);
                        tipAllKind[tipAllKind.length] = {
                            type: STYLE.SANDAIYI,
                            tipCards: sdyTip
                        };
                    }   
                }
            }
            else if(spCount > 4){
                // console.warn("出牌提示 牌够  三带可带牌  "+JSON.stringify(kedais))
                if(kedais.length == 2){
                    sdeTip = [];
                    for (var i = 0; i < sdTip.length; i++) {
                        sdeTip[i] = sdTip[i].concat(kedais);
                    }
                    tipAllKind[tipAllKind.length] = {
                        type: STYLE.SANDAIER,
                        tipCards: sdeTip
                    };
                    // console.warn("出牌提示 牌够  三带1   "+JSON.stringify(sdeTip)+"  三带2   "+JSON.stringify(sdeTip) );
                }
                else if(kedais.length == 1){
                    for (var i = 0; i < sdTip.length; i++) {
                        for (var j = 0; j < handCards.length; j++) {
                            if(sdTip[i].indexOf(handCards[j]) == -1){
                                if(kedais.indexOf(handCards[j]) == -1) kedais[1] = handCards[j];
                                if(kedais.length >= 2) break;
                            }
                        }
                        if(kedais.length == 2) {
                            sdeTip[i] = sdTip[i].concat(kedais);
                        }
                    }
                    tipAllKind[tipAllKind.length] = {
                        type: STYLE.SANDAIER,
                        tipCards: sdeTip
                    };
                }
                else if(kedais.length == 0){
                    sdeTip = [];
                    for (var i = 0; i < sdTip.length; i++) {
                        kedais = [];
                        for (var j = 0; j < handCards.length; j++) {
                            if(sdTip[i].indexOf(handCards[j]) == -1){
                                kedais[kedais.length] = handCards[j];
                                if(kedais.length >= 2) break;
                            }
                        }
                        if(kedais.length == 2) sdeTip[i] = sdTip[i].concat(kedais);
                    }
                    tipAllKind[tipAllKind.length] = {
                        type: STYLE.SANDAIER,
                        tipCards: sdeTip
                    };
                    // console.warn("出牌提示 牌够  三带1   "+JSON.stringify(sdeTip)+"  三带2   "+JSON.stringify(sdeTip) );
                }
            }
        }
    }

    let duiziList = [];
    for (var i = 0; i < vgs.length; i++) {
        if(vgs[i].length == 2 || vgs[i].length == 3) duiziList[duiziList.length] = [vgs[i][0],vgs[i][1]];
        if(!this.isZDBKC && vgs[i].length == 4) duiziList[duiziList.length] = [vgs[i][0],vgs[i][1]];
    }
    // console.warn("出牌提示  对子list   "+JSON.stringify(duiziList));
    if(duiziList.length >= 2){
        let lianduiList = [];
        let pdz = this.getValuepx(duiziList[0][0]);
        let pdIndex = 0;
        lianduiList[0] = [duiziList[0]];
        // console.warn("出牌提示  连对list   "+JSON.stringify(lianduiList));
        for (var i = 1; i < duiziList.length; i++) {
            if((pdz+i-pdIndex) == this.getValuepx(duiziList[i][0])){
                let lianduiListLastItemIndex = lianduiList.length-1;
                let lianduiListLastItemLastIndex = lianduiList[lianduiList.length-1].length;
                lianduiList[lianduiListLastItemIndex][lianduiListLastItemLastIndex] = duiziList[i];
            }
            else{
                // console.warn("出牌提示  连对到这里了嘛222   "+JSON.stringify(duiziList[i]));
                lianduiList[lianduiList.length] = [];
                lianduiList[lianduiList.length-1] = [duiziList[i]];
                pdz = this.getValuepx(duiziList[i][0]);
                pdIndex = i;
            }
        }
        // console.warn("出牌提示  连对list   "+JSON.stringify(lianduiList));
        let lianduiTip = [];
        for (var i = 0; i < lianduiList.length; i++) {
            if(lianduiList[i].length >= 2){
                let lds = [];
                for (var j = 0; j < lianduiList[i].length; j++) {
                    lds = lds.concat(lianduiList[i][j])
                }
                lianduiTip[lianduiTip.length] = lds;
            }
        }
        // console.warn("出牌提示  连对结果   "+JSON.stringify(lianduiTip));
        if(lastOut.type == STYLE.LIANDUI ){
            //上家出连对的话把自己手上能大过的连对加入提示数组
            let isExitBiger = false;//是否存在更大的
            for (var i = 0; i < lianduiTip.length; i++) {
                if(lianduiTip[i].length == lastOut.cards.length){
                    if(this.getValuepx(lianduiTip[i][0]) > this.getValuepx(lastOut.cards[0])){
                        isExitBiger = true;
                        break;
                    }
                }
            }
            if(!isExitBiger){
                for (var i = 0; i < lianduiTip.length; i++) {
                    if(this.getValuepx(lianduiTip[i][lianduiTip[i].length-1]) > this.getValuepx(lastOut.cards[lastOut.cards.length-1])){
                        isExitBiger = true;
                        break;
                    }
                }
                if(isExitBiger){
                    let add3 = [];
                    for (var i = 0; i < lianduiTip.length; i++) {
                        let add2 = [];
                        for (var j = 0; j < lianduiTip[i].length; j++) {
                            // console.warn("上家出连对的话??? "+JSON.stringify(lianduiTip)+"  "+JSON.stringify(add3)+"  "+JSON.stringify(add2)+"  "+add2[add2.length-1] +"  "+ lianduiTip[i][j]);
                            if(add2.length > 0 && this.getValuepx(add2[add2.length-1]) > this.getValuepx(lianduiTip[i][j])) continue;
                            if(this.getValuepx(lianduiTip[i][j]) > this.getValuepx(lastOut.cards[0])){
                                let isslg = (lianduiTip[i].length - j) >= lastOut.cards.length;//张数够不够
                                // console.warn("数量够不够   "+lianduiTip[i].length+"  "+lastOut.cards.length+"  i  "+i+"  j  "+j);
                                if(isslg){
                                    let add = [];
                                    for (var z = 0; z < lastOut.cards.length; z++) {
                                        add[add.length] = lianduiTip[i][j+z]
                                    }
                                    // console.warn("上家出连对的话把自己手上能大过的连对加入提示数组 "+JSON.stringify(add));
                                    add3[add3.length] = add;
                                    add2 = add;
                                }
                                else{
                                    break;
                                }
                            }
                        }
                    }
                    let add4 = [];
                    for (var i = 0; i < add3.length; i++) {
                        if(this.getIsHanBaozi(add3[i],vgs)) add4[add4.length] = add3[i];
                        else lianduiTip[lianduiTip.length] = add3[i];
                    }
                    for (var i = 0; i < add4.length; i++) {
                        lianduiTip[lianduiTip.length] = add4[i];
                    }
                }
            }
        }
        // console.warn("上家出连对的话  lianduiTip "+JSON.stringify(lianduiTip));
        if(lianduiTip.length > 0){
            tipAllKind[tipAllKind.length] = {
                type: STYLE.LIANDUI,
                tipCards: lianduiTip
            };
        }
    }

    if(pzfbqk.indexOf(4) != -1){
        let zhadanTip = [];
        for (var i = 0; i < vgs.length; i++) {
            if(vgs[i].length == 4){
                zhadanTip[zhadanTip.length] = vgs[i];
            }
        }
        // console.warn("出牌提示  炸弹结果   "+JSON.stringify(zhadanTip));
        if(zhadanTip.length > 0){
            tipAllKind[tipAllKind.length] = {
                type: STYLE.ZHADAN,
                tipCards: zhadanTip
            };
        }
    }


    if(duiziList.length > 0){
        let duiziTip = [];
        let add4 = [];
        for (var i = 0; i < duiziList.length; i++) {
            if(this.getIsHanBaozi(duiziList[i],vgs)) add4[add4.length] = duiziList[i];
            else duiziTip[duiziTip.length] = duiziList[i];
        }
        for (var i = 0; i < add4.length; i++) {
            duiziTip[duiziTip.length] = add4[i];
        }
        if(duiziTip.length > 0){
            tipAllKind[tipAllKind.length] = {
                type: STYLE.YIDUI,
                tipCards: duiziTip
            };
        }
    }

    let danTip = [];
    let hsisExit = false;
    for (var i = 0; i < vgs.length; i++) {
        if(vgs[i].length == 1){
            danTip[danTip.length] = vgs[i];
            if(vgs[i][0] == 103) hsisExit = true;
        }
    }
    if(isHTSSC && (!hsisExit)){
        if(handCards.indexOf(103) != -1){//加这个判断是为了防止在首局黑桃三出牌之后判断第二家能否要起的时候把103添加给第二家的出牌提示
            danTip[danTip.length] = [103];
        }
    }
    if(lastOut.cards.length == 1){
        if(danTip[danTip.length-1] != handCards[handCards.length-1]){
            danTip[danTip.length] = [handCards[handCards.length-1]];
        }
    }
    if(isXJZSYZ){
        //下家只剩一张牌了
        let maxDanList = this.getMaxDanList(handCards);
        danTip = [];
        danTip[danTip.length] = [maxDanList[0]];
    }
    // console.warn("出牌提示  单牌结果   "+JSON.stringify(danTip));
    if(danTip.length > 0){
        tipAllKind[tipAllKind.length] = {
            type: STYLE.DAN,
            tipCards: danTip
        };
    }

    // console.warn("出牌提示  所有结果111   "+JSON.stringify(tipAllKind));
    this.getKeDaisSort2(handCards,tipAllKind,vgs,isHTSSC);
    // console.warn("出牌提示  所有结果优化之后   "+JSON.stringify(tipAllKind));
    let tipAllKindtip = [];
    for (var i = 0; i < tipAllKind.length; i++) {
        for (var j = 0; j < tipAllKind[i].tipCards.length; j++) {
            tipAllKindtip[tipAllKindtip.length] = tipAllKind[i].tipCards[j];
        }
    }
    // console.warn("出牌提示  所有结果2   "+JSON.stringify(tipAllKindtip));
    let glzh = [];
    for (var i = 16; i >= 0; i--) {
        glzh[i] = [];
    }
    // console.warn("出牌提示  所有结果3   "+JSON.stringify(glzh));
    for (var i = 0; i < tipAllKindtip.length; i++) {
        let index1 = tipAllKindtip[i].length;
        let index2 = glzh[index1].length;
        glzh[index1][index2] = tipAllKindtip[i];
    }
    // console.warn("出牌提示  所有结果4   "+JSON.stringify(glzh));
    let tipAllKindSorted = [];
    for (var i = 16; i >= 0; i--) {
        if(glzh[i].length > 0){
            for (var j = 0; j < glzh[i].length; j++) {
                tipAllKindSorted[tipAllKindSorted.length] = glzh[i][j];
            }
        }
    }
    // console.warn("出牌提示  所有结果222   "+JSON.stringify(tipAllKind));
    // console.warn("出牌提示  所有结果333   "+JSON.stringify(tipAllKindSorted));
    // tipRes = tipAllKindSorted;
    if(isHTSSC){
        //黑桃三首出，出牌必须有黑桃三
        for (var i = 0; i < tipAllKindSorted.length; i++) {
            if(tipAllKindSorted[i].indexOf(103) != -1){
                tipRes[tipRes.length] = tipAllKindSorted[i];
            }
        }
    }
    else{
        if(lastOut.type == -1 && lastOut.cards.length == 0){
            //本轮第一个出牌的玩家
            tipRes = tipAllKindSorted;
        }
        else{
            let needCompareList = [];
            for (var i = 0; i < tipAllKind.length; i++) {
                if(tipAllKind[i].type == lastOut.type){
                    needCompareList = needCompareList.concat(tipAllKind[i].tipCards);
                }
            }
            for (var i = 0; i < tipAllKind.length; i++) {
                if(tipAllKind[i].type == STYLE.ZHADAN){
                    needCompareList = needCompareList.concat(tipAllKind[i].tipCards);
                }
            }
            // console.warn("出牌提示 去掉大不过上家的提示出牌   "+JSON.stringify(needCompareList));
            for (var i = 0; i < needCompareList.length; i++) {
                let outType = this.getCardsType(needCompareList[i],lastOut,handCards,isHTSSC,[]);
                // console.warn("出牌提示 是否能大过   ",JSON.stringify(needCompareList[i]),outType,lastOut.type,STYLE.ZHADAN)
                if(outType == lastOut.type || outType == STYLE.ZHADAN){
                    // console.warn("能大过   ",JSON.stringify(needCompareList[i]))
                    tipRes[tipRes.length] = needCompareList[i];
                }
            }
            
        }
    }
    // console.error("出牌提示  最终的返回结果   "+JSON.stringify(tipRes));
    let tipRes22 = [];////最终返回结果
    for (var i = 0; i < tipRes.length; i++) {
        if(!this.checkZhaDan(tipRes[i])) tipRes22.push(tipRes[i]);
        // else console.warn("这个被剔除了",tipRes[i]);
    }
    return tipRes22;
};

//得到一组牌里面是否有炸弹，为了解决炸弹+单牌这五张牌当三带2提示出去
proto.checkZhaDan = function (cards) {
    if(cards.length != 5) return null;
    let tipItem = _.clone(cards); 
    tipItem = this.sort(tipItem);
    for (var i = 0; i < tipItem.length; i++) {
        tipItem[i] = this.getValue(tipItem[i])
    }
    if(tipItem[0] == tipItem[1] && tipItem[0] == tipItem[2] && tipItem[0] == tipItem[3]) return true;
    else if(tipItem[1] == tipItem[2] && tipItem[1] == tipItem[3] && tipItem[1] == tipItem[4]) return true;
    return false;
}

//得到能否一把出完的牌，如果能出完返回出牌李彪，如果不能一把出完返回[]
proto.getCanOutOverList = function (currentId,_handCards,tipInfo,lastOut) {
    // console.warn("得到能否一把出完的牌  "+currentId+"   "+JSON.stringify(_handCards)+"   "+JSON.stringify(tipInfo)+"   "+JSON.stringify(lastOut));
    if(currentId != tipInfo.chairId || tipInfo.chairId < 0) return [];
    let handCards = this.deepCloneTL(_handCards);
    let pzfbqk = this.getPokeValueArr(handCards);//牌值分布情况
    // console.warn("得到能否一把出完的牌  牌值分布情况 "+ JSON.stringify(pzfbqk))
    if(pzfbqk.indexOf(4) != -1){
        if(handCards.length > 4) return [];//手上有炸弹的话不能自动打出，需要玩家选择
        else if(handCards.length == 4) return handCards;//手上只剩一个炸弹了让他自己打出去
    } 
    let res = [];
    for (var i = 0; i < tipInfo.tipCards.length; i++) {
        if(tipInfo.tipCards[i].length == handCards.length){
            let lygdys = _.difference(tipInfo.tipCards[i],handCards);////另一个队员的人数
            let lygdys2 = _.difference(handCards,tipInfo.tipCards[i]);////另一个队员的人数
            if(lygdys.length == 0 && lygdys2.length == 0){
                res = tipInfo.tipCards[i];
                // console.warn("得到能否一把出完的牌   找到了  "+JSON.stringify(res));
                break;
            }
        }
    }
    // console.warn("得到能否一把出完的牌   返回值  "+JSON.stringify(res));
    return res;
}

//得到出牌是否合法和所出牌的牌型 出牌数组 上家出牌 自己手牌 是否是黑桃三首出
proto.getCardsType = function (_outCards,lastOut,_sp,isHTSSC,tips) {
    // console.error("得到出牌是否合法和所出牌的牌型   出牌数组  "+_outCards+"  上家出牌数组  "+JSON.stringify(lastOut) +"  自己手牌"+JSON.stringify(_sp));
    let outCards = this.deepCloneTL(_outCards)
    outCards = this.sort(outCards)
    let sp = this.deepCloneTL(_sp)
    let spCount = sp.length;
    let type = -1;
    for (var i = 0; i < outCards.length; i++) {
        if(!this.aCardIsHefa(outCards[i])) return -1;//出牌中包含非法牌
    }
    //至此出牌数组中每张牌都是合法的
    let outLength = outCards.length;
    if(outLength == 0){
        //要不起
        if(lastOut.type == -1 && lastOut.cards.length == 0) return STYLE.ERROR;//本轮第一个出牌的玩家不能不出牌（出[])
        else{
            if(this.isYPBC && tips.length > 0) return -2;
        }
        type = STYLE.YAOBUQI;
    }
    else if(outLength > 0){
        if(isHTSSC && outCards.indexOf(103) == -1) return -3;//黑桃三首出所出的牌没有黑桃三
        let pzfbqk = this.getPokeValueArr(outCards);//牌值分布情况
        // console.warn("牌值分布情况  "+JSON.stringify(pzfbqk)+"  炸弹是否不可拆  "+this.isZDBKC);
        if(this.isZDBKC){
            if(this.isZhaDan(outCards,pzfbqk,lastOut,spCount) == STYLE.ZHADAN) return STYLE.ZHADAN;
            var ng = _.groupBy(sp, function (n) { 
                let value = n % 100;
                if(value == 1) value = 14;
                if(value == 2) value = 15;
                return value; 
            });
            // console.warn("222出牌提示 ",JSON.stringify(ng));
            var kgs = Object.keys(ng);
            // console.warn("出牌提示根据牌返回牌值的个数333   kgs "+JSON.stringify(kgs));
            let vgs = _.sortBy(ng, function(o) { 
                let value = o[0] % 100;
                if(value == 1) value = 14;
                if(value == 2) value = 15;
                return value; 
            });
            let bkcxdpz = [];//炸弹不可拆时出牌里不能出现的牌值
            for (var i = 0; i < vgs.length; i++) {
                if(vgs[i].length == 4 ) bkcxdpz[bkcxdpz.length] = this.getValuepx(vgs[i][0]);
            }
            // console.warn("下面是判断牌型  炸弹不可拆时出牌里不能出现的牌值  "+JSON.stringify(bkcxdpz) )
            for (var i = 0; i < outCards.length; i++) {
                // console.warn("下面是判断牌型  炸弹不可拆时出牌里不能出现的牌值  "+outCards[i]+"    "+this.getValuepx(outCards[i]) )
                if( bkcxdpz.indexOf(this.getValuepx(outCards[i])) != -1){
                    // console.warn("走到这里了？？？？？  ");
                    return -4;//炸弹不可拆时出的牌不能带炸弹
                }  
            }
        }
        // console.warn("下面是判断牌型  出牌牌值  "+JSON.stringify(outCards) +"  分布情况  "+JSON.stringify(pzfbqk)+"  last  "+JSON.stringify(lastOut)+"  spCount  "+JSON.stringify(spCount));
        // 出牌牌值  103,403,104,404,105,106,107,108  分布情况  1,1,1,1,2,2
        for (var i = 0; i < this.dahuTypeTL.length; i++) {
            // console.warn("判断type ====   ===  i  "+i+"   type  "+type);
            if( i == 3 && type < 3){
                type = this.isDan(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 4 && type < 3){
                type = this.isYiDui(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 5 && type < 3){
                type = this.isLianDui(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 6 && type < 3){
                type = this.isSanDaiYi(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 7 && type < 3){
                type = this.isSanDaiEr(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 8 && type < 3){
                type = this.isSiDaiEr(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 9 && type < 3){
                type = this.isSiDaiSan(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 10 && type < 3){
                type = this.isFeiJi(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 11 && type < 3){
                type = this.isShunZi(outCards,pzfbqk,lastOut,spCount);
            }
            else if( i == 12 && type < 3){
                type = this.isZhaDan(outCards,pzfbqk,lastOut,spCount);
            }
        }
    }
    // console.error("得到出牌是否合法和所出牌的牌型   结束   " + type);
    return type
}

// 是否单牌 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isDan = function (outCards,pzfbqk,lastOut,spCount) {
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.DAN) return STYLE.NULL;//别人出的不是单牌自己不能出单牌
    if(outCards.length != 1) return STYLE.ERROR;
    if(lastOut.cards.length > 0){
        if(this.getValuepx(outCards[0]) > this.getValuepx(lastOut.cards[0])) return STYLE.DAN;
        else return STYLE.NULL;
    }
    return STYLE.DAN;
}

// 是否一对子 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isYiDui = function (outCards,pzfbqk,lastOut,spCount) {
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.YIDUI) return STYLE.NULL;//别人出的不是一对子自己不能出一对子
    if(outCards.length != 2) return STYLE.ERROR;
    if(this.getValuepx(outCards[0]) == this.getValuepx(outCards[1])){
        if(lastOut.cards.length > 0){
            if(this.getValuepx(outCards[0]) > this.getValuepx(lastOut.cards[0])) return STYLE.YIDUI;
            else return STYLE.NULL;
        }
    }
    else return STYLE.ERROR;
    return STYLE.YIDUI;
}

// 是否连对 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isLianDui = function (outCards,pzfbqk,lastOut,spCount) {
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.LIANDUI) return STYLE.NULL;//别人出的不是连对自己不能出连对
    if(outCards.length < 4) return STYLE.ERROR;
    if(outCards.length % 2 != 0) return STYLE.ERROR;//出的张数不是偶数
    if(pzfbqk.length != outCards.length / 2) return STYLE.ERROR;//出的不全是对子
    let isAllDuizi = true;
    for (var i = 0; i < pzfbqk.length; i++) {
        if(pzfbqk[i] != 2){
            isAllDuizi = false;
            break;
        }
    }
    if(isAllDuizi){
        let qc = [];
        for (var i = 0; i < outCards.length; i++) {
            qc[qc.length] = outCards[i];
            i++
        }
        // console.warn("连对判断  111  "+JSON.stringify(outCards)+"   "+JSON.stringify(lastOut.cards));
        // console.warn("连对判断  222  "+JSON.stringify(qc));
        for (var i = 1; i < qc.length; i++) {
            if(this.getValuepx(qc[i]) == 15) return STYLE.ERROR;//牌面数值2（逻辑牌值15）不能去做顺子
            if(this.getValuepx(qc[i]) != this.getValuepx(qc[0])+i){
                return STYLE.ERROR;
            }
        }
    }
    else return STYLE.ERROR;
    // console.warn("连对判断  至此出的牌是个合法的连对了 "+JSON.stringify(outCards)+"   "+JSON.stringify(lastOut.cards));
    //至此出的牌是个合法的连对了
    if(lastOut.cards.length > 0){
        if(outCards.length != lastOut.cards.length){
            //本次出牌牌数和上次出牌数不一样，不能压
            return STYLE.NULL;
        }
        else{
            if(this.getValuepx(outCards[0]) <= this.getValuepx(lastOut.cards[0])){
                //张数一样点数不够大的连对压不住
                return STYLE.NULL;
            }
        }
    }
    return STYLE.LIANDUI;
}

//按照牌面值出现个数对手牌数组进行排序
proto.sortOut = function (_outs) {
    let outs = this.deepCloneTL(_outs);
    // return _.sortBy(handCards);///降序排序
    // console.warn("111按照牌面值出现个数对除牌数组进行排序",JSON.stringify(outs));
    // 111手牌排序 [101,102,103,104,105,106,107,108,109,110,111,112,113,403,404,201]
    var ng = _.groupBy(outs, function (n) { 
        let value = n % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    // console.warn("222按照牌面值出现个数对除牌数组进行排序",JSON.stringify(ng));
    // 222手牌排序 {"3":[103,403],"4":[104,404],"5":[105],"6":[106],"7":[107],"8":[108],"9":[109],"10":[110],"11":[111],"12":[112],"13":[113],"14":[101,201],"15":[102]}
    let xxc = _.sortBy(ng, function(o) { return o.length; });
    // 333手牌排序 [[105],[106],[107],[108],[109],[110],[111],[112],[113],[102],[103,403],[104,404],[101,201]]
    
    // 333手牌排序 [[103,403],[104,404],[105],[106],[107],[108],[109],[110],[111],[112],[113],[101,201],[102]]
    // console.warn("333手牌排序",JSON.stringify(xxc));
    
    let res = [];
    for (var i = 0; i < xxc.length; i++) {
        res = res.concat(_.sortBy(xxc[i]))
    }
    //下面是验证排序过程中是否出错（改变原数组）了
    let lygdys = _.difference(outs,res);////另一个队员的人数
    let lygdys2 = _.difference(res,outs);////另一个队员的人数
    if(lygdys.length > 0 || lygdys2.length > 0 || outs.length != res.length){
        console.error("111===============这把排序出错了 =======",outs);
        console.error("222===============这把排序出错了 =======",res);
        return outs;
    }
    // console.warn("1010手牌排序",JSON.stringify(res));
    // 555手牌排序 [105,106,107,108,109,110,111,112,113,102,103,403,104,404,101,201]
    // 1010手牌排序 [103,403,104,404,105,106,107,108,109,110,111,112,113,101,201,102]
    return res;
};

// 是否三带一 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isSanDaiYi = function (outCards,pzfbqk,lastOut,spCount) {
    if(lastOut.cards.length > 0) return STYLE.ERROR;
    if(lastOut.type > -1 && lastOut.type != STYLE.SANDAIYI) return STYLE.NULL;//别人出的不是三带一自己不能出三带一
    if(spCount > 4) return STYLE.ERROR;//只有手牌不够三带二的时候才能出三带一
    if(lastOut.cards.length > 0){
        if(outCards.length != 4) return STYLE.NULL;//别人出3带一的时候自己牌数不够压不住
        if(pzfbqk.length != 2 || pzfbqk[0] != 1 || pzfbqk[1] != 3) return STYLE.ERROR;
        if(lastOut.cards.length > 0){
            let sortedOuts = this.sortOut(outCards);
            let sortedlasts = this.sortOut(lastOut.cards);
            // console.warn("是否三带一   sortedOuts "+JSON.stringify(sortedOuts)+"  sortedlasts "+JSON.stringify(sortedlasts))
            if(this.getValuepx(sortedOuts[1]) <= this.getValuepx(sortedlasts[1])){
                //点数不够大的三带一压不住
                return STYLE.NULL;
            }
        }
    }
    else{
        //自己是本轮第一个出牌的玩家，手牌只剩555这种3张一样的虽然牌数不够组成三带一（只有3的牌没有带的牌）是可以打出去的
        if(pzfbqk.length == 1  && outCards.length == 3) return STYLE.SANDAIYI;
        if(pzfbqk.length != 2 || pzfbqk[0] != 1 || pzfbqk[1] != 3) return STYLE.ERROR;
        else if(spCount > outCards.length) return STYLE.ERROR; 
    }
    return STYLE.SANDAIYI;
}

// 是否三带二 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isSanDaiEr = function (outCards,pzfbqk,lastOut,spCount) {
    // console.warn("是否三带二 出的牌 "+JSON.stringify(outCards)+"  牌值分布情况  "+JSON.stringify(pzfbqk)+"  上家有效出牌   "+JSON.stringify(lastOut)+"  手牌个数"+spCount);
    // console.warn("是否三带二 222 "+lastOut.cards.length); 
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.SANDAIER) return STYLE.NULL;//别人出的不是三带二自己不能出三带二
    // console.warn("是否三带二 333 "+lastOut.cards.length); 
    if(lastOut.cards.length > 0 || spCount >= 5){
        if(outCards.length != 5) return STYLE.ERROR;
        if(pzfbqk.length != 2 && pzfbqk.length != 3) return STYLE.ERROR;//既不是3带一对也不是三带2单
        if(pzfbqk.length == 2) {
            if(pzfbqk[0] != 2 || pzfbqk[1] != 3){
                // 不是3带一对
                if(pzfbqk[0] != 1 || pzfbqk[1] != 4){
                    // 不是炸弹带一单
                    return STYLE.ERROR;
                }
            }
            else{
                //至此是3带1对了  
            }
        }
        if(pzfbqk.length == 3) {
            if(pzfbqk[0] != 1 || pzfbqk[1] != 1 || pzfbqk[2] != 3){
                // 不是3带2单
                return STYLE.ERROR;
            }
            else{
                //至此是3带2单了  
            }
        }
        if(lastOut.cards.length > 0){
            // let lastOutCards = this.deepCloneTL(lastOut.cards);
            // let lastfbqk = this.getPokeValueArr(lastOutCards);//牌值分布情况
            //下面这个if是控制3带2单可不可以压三带一对
            // if(lastfbqk.length < pzfbqk.length){
            //     //自己的三带2单压不住别人的三带1对
            //     return STYLE.NULL;
            // }

            let sortedOuts = this.sortOut(outCards);
            let sortedlasts = this.sortOut(lastOut.cards);
            if(this.getValuepx(sortedOuts[2]) <= this.getValuepx(sortedlasts[2])){
                //点数不够大的连对压不住
                return STYLE.NULL;
            }
        }
    }
    else{
        //自己是本轮第一个出牌的玩家，手牌只剩555这种3张一样的虽然牌数不够组成三带一（只有3的牌没有带的牌）是可以打出去的
        if(pzfbqk.indexOf(3) == -1) return STYLE.ERROR;
        else if(spCount > outCards.length) return STYLE.ERROR; 
    }
    // console.warn("是否三带二")
    return STYLE.SANDAIER;
}

// 是否四带二 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isSiDaiEr = function (outCards,pzfbqk,lastOut,spCount) {
    if(this.isZDBKC) return STYLE.ERROR;//炸弹不可拆时四带2不能出四带2
    if(!this.isCanSiDaiEr) return STYLE.ERROR;//没有勾选四带2不能出四带2
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.SIDAIER) return STYLE.NULL;//别人出的不是四带二自己不能出四带二
    if(lastOut.cards.length > 0 || spCount >= 6){
        if(outCards.length != 6) return STYLE.ERROR;
        if(pzfbqk.length != 2 && pzfbqk.length != 3) return STYLE.ERROR;//既不是4带一对也不是4带2单
        if(pzfbqk.length == 2) {
            if(pzfbqk[0] != 2 || pzfbqk[1] != 4){
                // 不是4带一对
                return STYLE.ERROR;
            }
            else{
                //至此是4带1对了  
            }
        }
        if(pzfbqk.length == 3) {
            if(pzfbqk[0] != 1 || pzfbqk[1] != 1 || pzfbqk[2] != 4){
                // 不是4带2单
                return STYLE.ERROR;
            }
            else{
                //至此是3带2单了  
            }
        }
        if(lastOut.cards.length > 0){
            // let lastOutCards = this.deepCloneTL(lastOut.cards);
            // let lastfbqk = this.getPokeValueArr(lastOutCards);//牌值分布情况
            // if(lastfbqk.length < pzfbqk.length){
            //     //自己的四带2单压不住别人的四带1对
            //     return STYLE.NULL;
            // }
            let sortedOuts = this.sortOut(outCards);
            let sortedlasts = this.sortOut(lastOut.cards);
            if(this.getValuepx(sortedOuts[2]) <= this.getValuepx(sortedlasts[2])){
                //点数不够大的连对压不住
                return STYLE.NULL;
            }
        }
    }
    else{
        //自己是本轮第一个出牌的玩家，手牌只剩55556这种5张虽然牌数不够组成是否四带二（只有4的牌没有带的牌）是可以打出去的
        if(pzfbqk.indexOf(4) == -1) return STYLE.ERROR;
        else{
            if(pzfbqk.length == 1) return STYLE.ZHADAN;//只出了个4个一样的算是炸弹
            else{
                //手上剩333345出33334的话手牌没有出完不能算是4带2打下去
                if(spCount > outCards.length) return STYLE.ERROR; 
            }
        }
    }
    return STYLE.SIDAIER;
}

// 是否四带三 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isSiDaiSan = function (outCards,pzfbqk,lastOut,spCount) {
    if(this.isZDBKC) return STYLE.ERROR;//炸弹不可拆时四带2不能出四带2
    if(!this.isSiCanDaiSan) return STYLE.ERROR;//没有勾选四带3不能出四带3
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.SIDAISAN) return STYLE.NULL;//别人出的不是四带三自己不能出四带三
    if(lastOut.cards.length > 0 || spCount >= 7){
        if(outCards.length != 7) return STYLE.ERROR;
        if(pzfbqk.length != 2 && pzfbqk.length != 3 && pzfbqk.length != 4) return STYLE.ERROR;//既不是4带一豹也不是4带1对1单也不是四带3单
        if(pzfbqk.length == 2) {
            if(pzfbqk[0] != 3 || pzfbqk[1] != 4){
                // 不是4带一豹子
                return STYLE.ERROR;
            }
            else{
                //至此是4带1对了  
            }
        }
        if(pzfbqk.length == 3) {
            if(pzfbqk[0] != 1 || pzfbqk[1] != 2 || pzfbqk[2] != 4){
                // 不是4带1对1单
                return STYLE.ERROR;
            }
            else{
                //至此是3带2单了  
            }
        }
        if(pzfbqk.length == 4) {
            if(pzfbqk[0] != 1 || pzfbqk[1] != 1 || pzfbqk[2] != 1 || pzfbqk[3] != 4){
                // 不是4带3单
                return STYLE.ERROR;
            }
            else{
                //至此是3带2单了  
            }
        }
        if(lastOut.cards.length > 0){
            // let lastOutCards = this.deepCloneTL(lastOut.cards);
            // let lastfbqk = this.getPokeValueArr(lastOutCards);//牌值分布情况
            // if(lastfbqk.length < pzfbqk.length){
            //     //自己的四带3单（四带1对1单）压不住别人的四带1对1单（四带1豹子）
            //     console.warn("走到这里了吗？？？？");
            //     return STYLE.NULL;
            // }
            let sortedOuts = this.sortOut(outCards);
            let sortedlasts = this.sortOut(lastOut.cards);
            if(this.getValuepx(sortedOuts[3]) <= this.getValuepx(sortedlasts[3])){
                //点数不够大的连对压不住
                return STYLE.NULL;
            }
        }
    }
    else{
        //自己是本轮第一个出牌的玩家，手牌只剩555567这种5张虽然牌数不够组成是否四带三（只有4的牌没有带的牌）是可以打出去的
        if(pzfbqk.indexOf(4) == -1) return STYLE.ERROR;
        else{
            if(pzfbqk.length == 1) return STYLE.ZHADAN;//只出了个4个一样的算是炸弹
            else{
                //手上剩333345出33334的话手牌没有出完不能算是4带2打下去
                if(spCount > outCards.length) return STYLE.ERROR; 
            }
        }
    }
    return STYLE.SIDAISAN;
}

// 是否飞机 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isFeiJi = function (outCards,pzfbqk,lastOut,spCount) {
    // console.warn("是否飞机 出的牌 "+JSON.stringify(outCards)+"  牌值分布情况  "+JSON.stringify(pzfbqk)+"  上家有效出牌   "+JSON.stringify(lastOut)+"  手牌个数"+spCount); 
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.FEIJI) return STYLE.NULL;//别人出的不是飞机自己不能出飞机
    let keCount = 0;
    for (var i = 0; i < pzfbqk.length; i++) {
        if(pzfbqk[i] == 3) keCount++
    }
    // console.warn("是否飞机 keCount "+keCount+"  pzfbqk "+JSON.stringify(pzfbqk))
    if(keCount < 2) return STYLE.ERROR;//豹子个数不够飞机
    let sortedOuts = this.sortOut(outCards);
    let sortedlasts = this.sortOut(lastOut.cards);
    // console.warn("是否飞机   sortedOuts "+JSON.stringify(sortedOuts)+"  sortedlasts "+JSON.stringify(sortedlasts))
    let yxKeCount = 0;//飞机里有效的豹子个数
    let ofjz = 0;    
    var ng = _.groupBy(outCards, function (n) { 
        let value = n % 100;
        if(value == 1) value = 14;
        if(value == 2) value = 15;
        return value; 
    });
    let xxc = _.sortBy(ng, function(o) { return o.length; });
    let bzpzfb = [];
    for (var i = 0; i < xxc.length; i++) {
        if(xxc[i].length == 3) bzpzfb[bzpzfb.length] = this.getValuepx(xxc[i][0])
    }
    // console.warn("是否飞机   xxc "+JSON.stringify(xxc)+"  bzpzfb "+JSON.stringify(bzpzfb))
    if(bzpzfb[3] && bzpzfb[2]+1 == bzpzfb[3] && bzpzfb[3]+1 == bzpzfb[4]){
        yxKeCount = 3;
        ofjz = bzpzfb[4];
    }  
    else if(bzpzfb[2] && bzpzfb[1]+1 == bzpzfb[2] && bzpzfb[2]+1 == bzpzfb[3]){
        yxKeCount = 3;
        ofjz = bzpzfb[3];
    }
    else if(bzpzfb[0]+1 == bzpzfb[1] && bzpzfb[1]+1 == bzpzfb[2]){
        yxKeCount = 3;
        ofjz = bzpzfb[2];
    } 
    else if(bzpzfb[0]+1 == bzpzfb[1] || bzpzfb[1]+1 == bzpzfb[2]){
        if(bzpzfb[0]+1 == bzpzfb[1]) ofjz = bzpzfb[1];
        else if(bzpzfb[1]+1 == bzpzfb[2]) ofjz = bzpzfb[2];
        yxKeCount = 2;
    } 
    if(outCards.length > 15 && keCount >= 4){
        if(bzpzfb[1]+1 == bzpzfb[2] && bzpzfb[2]+1 == bzpzfb[3] && bzpzfb[3]+1 == bzpzfb[4]){
            yxKeCount = 4;
            ofjz = bzpzfb[4];
        }
        else if(bzpzfb[0]+1 == bzpzfb[1] && bzpzfb[1]+1 == bzpzfb[2] && bzpzfb[2]+1 == bzpzfb[3]){
            yxKeCount = 4;
            ofjz = bzpzfb[3];
        } 
    }
    // console.warn("是否飞机 keCount "+keCount+"  yxKeCount "+yxKeCount)
    if(yxKeCount == 0) return STYLE.ERROR;//飞机里有效的豹子个数不够（飞机里两个豹子点数未相邻）
    // console.warn("走到这里了000   spCount "+spCount +"  outCards.length   "+outCards.length);
    if(spCount > outCards.length){
        if(outCards.length%5 == 0){
            // console.warn("走到这里了111  yxKeCount  "+yxKeCount) 
            yxKeCount = outCards.length/5;
        }
        else{
            // console.warn("走到这里了222  张数不对")
            return STYLE.ERROR;//张数不对
        }
    }
    let fjNeedCount = yxKeCount*5;//飞机需要的牌总张数
    // console.warn("走到这里了333  yxKeCount  "+yxKeCount+"  fjNeedCount  "+fjNeedCount)
    if(lastOut.cards.length > 0 && outCards.length != lastOut.cards.length) return STYLE.ERROR;//张数不对
    if(lastOut.cards.length > 0 || spCount >= fjNeedCount){
        if(outCards.length != fjNeedCount) {
            // console.warn("走到这里了，所以报错222  outCards.length  "+outCards.length);
            return STYLE.ERROR;//张数不对
        }
        let lpzfbqk = this.getPokeValueArr(lastOut.cards);//上次有效出牌牌值分布情况
        let lofjz = 0; 
        var lng = _.groupBy(lastOut.cards, function (n) { 
            let value = n % 100;
            if(value == 1) value = 14;
            if(value == 2) value = 15;
            return value; 
        });
        let lxxc = _.sortBy(lng, function(o) { return o.length; });
        let lbzpzfb = [];
        for (var i = 0; i < lxxc.length; i++) {
            if(lxxc[i].length == 3) lbzpzfb[lbzpzfb.length] = this.getValuepx(lxxc[i][0])
        }
        // console.warn("是否飞机   lxxc "+JSON.stringify(lxxc)+"  lbzpzfb "+JSON.stringify(lbzpzfb))
        if(lbzpzfb[0]+1 == lbzpzfb[1] && lbzpzfb[1]+1 == lbzpzfb[2]){
            lofjz = lbzpzfb[2];
        } 
        else if(lbzpzfb[0]+1 == lbzpzfb[1] || lbzpzfb[1]+1 == lbzpzfb[2]){
            if(lbzpzfb[0]+1 == lbzpzfb[1]) lofjz = lbzpzfb[1];
            else if(lbzpzfb[1]+1 == lbzpzfb[2]) lofjz = lbzpzfb[2];
        } 
        // console.warn("点数不够大的飞机压不住  ",ofjz , lofjz);
        if(ofjz <= lofjz){
            //点数不够大的飞机压不住
            return STYLE.NULL;
        }
    }
    else{
        //自己是本轮第一个出牌的玩家，手牌只剩55566678这种8张虽然牌数不够组成飞机（只有飞机豹子的牌没有带的牌）是可以打出去的
        // console.warn("是否飞机 死在这里了？？？   outCards.length "+outCards.length+"  fjNeedCount "+fjNeedCount)
        if(outCards.length > fjNeedCount) return STYLE.ERROR;//张数不对
    }
    return STYLE.FEIJI;
}

// 是否顺子 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isShunZi = function (outCards,pzfbqk,lastOut,spCount) {
    // console.warn("顺子判断  至此出的牌是个合法的顺子了 "+JSON.stringify(outCards)+"   "+JSON.stringify(lastOut.cards));
    if(lastOut.cards.length > 0 && lastOut.type != STYLE.SHUNZI) return STYLE.NULL;//别人出的不是飞机自己不能出飞机
    if(outCards.length != pzfbqk.length || outCards.length < 5) return STYLE.ERROR;//出的牌不全是单牌
    for (var i = 1; i < outCards.length; i++) {
        if(this.getValuepx(outCards[i]) != this.getValuepx(outCards[0])+i){
            return STYLE.ERROR;
        }
        else{
            //牌面数值2（逻辑牌值15）不能去做顺子
            if(this.getValuepx(outCards[i]) == 15) return STYLE.ERROR;
        }
    }
    //至此出的牌是个合法的顺子了
    if(lastOut.cards.length > 0){
        if(outCards.length != lastOut.cards.length){
            //本次出牌牌数和上次出牌数不一样，不能压
            return STYLE.NULL;
        }
        else{
            if(this.getValuepx(outCards[0]) <= this.getValuepx(lastOut.cards[0])){
                //张数一样点数不够大的顺子压不住
                return STYLE.NULL;
            }
        }
    }
    return STYLE.SHUNZI;
}

// 是否炸弹 出的牌,牌值分布情况,上家有效出牌,手牌个数
proto.isZhaDan = function (outCards,pzfbqk,lastOut,spCount) {
    if(outCards.length != 4) return STYLE.ERROR;
    for (var i = 1; i < outCards.length; i++) {
        if(this.getValuepx(outCards[i]) != this.getValuepx(outCards[0])){
            return STYLE.ERROR;
        }
    }
    // console.warn("至此是个正确的炸弹");
    //至此是个正确的炸弹
    if(lastOut.cards.length > 0){
        // console.warn("炸弹压不住  ",this.getValuepx(outCards[0]) , this.getValuepx(lastOut.cards[0]));
        if(lastOut.type == STYLE.ZHADAN){
            if(this.getValuepx(outCards[0]) <= this.getValuepx(lastOut.cards[0])) {
                return STYLE.NULL;//点数不够大的炸弹压不住
            }
        }
    }
    // console.warn("判断炸弹成功  ");
    return STYLE.ZHADAN;
}

////TL++得到一张牌的剩余张数  用于胡牌提示提示该张的剩余张数
proto.getACardSYZS = function (card,_handCards,allhuCards,outCards) {
    ////下面这段是适合胡牌提示里用的剩余牌数统计
    let yjcxdzs = 0;////该牌已经出现的张数
    for (var i = 0; i < _handCards.length; i++) {
        if(card == _handCards[i]) yjcxdzs++;////该牌已经出现在自己手牌里的张数
    }
    
    for (var i = 0; i < outCards.length; i++) {
        if(outCards[i].length == 0) continue;////该玩家没有碰杠牌
        // console.warn("2得到一张牌的剩余张数   打出去的牌",card,yjcxdzs,i,JSON.stringify(_.clone(outCards[i])));
        for (var k = 0; k < outCards[i].length; k++) {
            if(card == outCards[i][k]) yjcxdzs++;////该牌已经出现在所有打出去牌里的张数;
        }
    }
    let zs = 4
    let syzs = zs - yjcxdzs;////剩余张数 = 总张数 - 已经出现的张数
    // console.warn("333得到一张牌的剩余张数",card,syzs);
    return syzs;
};