SOURCE

//8张炸弹的表
var cards_8 = {
    1:[1,1,2,2,3,3,4,4],
    2:[5,5,6,6,7,7,8,8], 
    3:[9,9,10,10,11,11,12,12],              //3
    4:[13,13,14,14,15,15,16,16],            //4
    5:[17,17,18,18,19,19,20,20],            //5
    6:[21,21,22,22,23,23,24,24],            //6
    7:[25,25,26,26,27,27,28,28],            //7
    8:[29,29,30,30,31,31,32,32],            //8
    9:[33,33,34,34,35,35,36,36],            //9
    10:[37,37,38,38,39,39,40,40],           //10
    11:[41,41,42,42,43,43,44,44],           //J
    12:[45,45,46,46,47,47,48,48],           //Q
    13:[49,49,50,50,51,51,52,52]           //K
    //14:[53,53,54,54]                   
};
    
//7张炸弹的表
var cards_7 = {
    1: {
        1:[1,1,2,2,3,3,4],
        2:[1,1,2,2,3,4,4],
        3:[1,1,2,3,3,4,4],
        4:[1,2,2,3,3,4,4]
    },
    2:{
        1:[5,5,6,6,7,7,8], 
        2:[5,5,6,6,7,8,8], 
        3:[5,5,6,7,7,8,8], 
        4:[5,6,6,7,7,8,8]
    },
    3:{
        1:[9,9,10,10,11,11,12],   
        2:[9,9,10,10,11,12,12],  
        3:[9,9,10,11,11,12,12],  
        4:[9,10,10,11,11,12,12]  
    },
    4:{
        1:[13,13,14,14,15,15,16], 
        2:[13,13,14,14,15,16,16], 
        3:[13,13,14,15,15,16,16],
        4:[13,14,14,15,15,16,16]
    },
    5:{
        1:[17,17,18,18,19,19,20],            //5
        2:[17,17,18,18,19,20,20],
        3:[17,17,18,19,19,20,20],
        4:[17,18,18,19,19,20,20]
    },
    6:{
        1:[21,21,22,22,23,23,24],            //6
        2:[21,21,22,22,23,24,24],
        3:[21,21,22,23,23,24,24],
        4:[21,22,22,23,23,24,24]
    },
    7:{
        1:[25,25,26,26,27,27,28],            //7
        2:[25,25,26,26,27,28,28],
        3:[25,25,26,27,27,26,28],
        4:[25,26,26,27,27,28,28]
    },
    8:{
        1:[29,29,30,30,31,31,32],            //8
        2:[29,29,30,30,31,32,32],
        3:[29,29,30,31,31,32,32],
        4:[29,30,30,31,31,32,32]
    },
    9:{
        1:[33,33,34,34,35,35,36],            //9
        2:[33,33,34,34,35,36,36],            //9
        3:[33,33,34,35,35,36,36],            //9
        4:[33,34,34,35,35,36,36]            //9
    },
    10:{
        1:[37,37,38,38,39,39,40],           //10
        2:[37,37,38,38,39,40,40],           //10
        3:[37,37,38,39,39,40,40],           //10
        4:[37,38,38,39,39,40,40]           //10
    },
    11:{
        1:[41,41,42,42,43,43,44],           //J
        2:[41,41,42,42,43,44,44], 
        3:[41,41,42,43,43,44,44], 
        4:[41,42,42,43,43,44,44] 
    },
    12:{
        1:[45,45,46,46,47,47,48],           //Q
        2:[45,45,46,46,47,48,48],
        3:[45,45,46,47,47,48,48],
        4:[45,46,46,47,47,48,48]
    },
    13:{
        1:[49,49,50,50,51,51,52],           //K
        2:[49,49,50,50,51,51,52],
        3:[49,49,50,51,51,52,52],
        4:[49,50,50,51,51,52,52]
    },
    // 14:[53,53,54,54]                   
};  
    
//6张炸弹的表
var cards_6 = {
    1:{
        1:[1,1,2,2,3,3],
        2:[1,1,2,2,4,4],
        3:[1,1,3,3,4,4],
        4:[2,2,3,3,4,4],
        5:[1,2,3,3,4,4],
        6:[1,2,2,3,4,4],
        7:[1,2,2,3,3,4],
        8:[1,1,2,3,4,4],
        9:[1,1,2,3,3,4],
        10:[1,1,2,2,3,4]
    },
    2:{
        1:[5,5,6,6,7,7],
        2:[5,5,6,6,8,8],
        3:[5,5,7,7,8,8],
        4:[6,6,7,7,8,8],
        5:[5,6,7,7,8,8],
        6:[5,6,6,7,8,8],
        7:[5,6,6,7,7,8],
        8:[5,5,6,7,8,8],
        9:[5,5,6,7,7,8],
        10:[5,5,6,6,7,8]
    },
     3:{
        1:[9,9,10,10,11,11], 
        2:[9,9,10,10,12,12],
        3:[9,9,11,11,12,12],
        4:[10,10,11,11,12,12],
        5:[9,10,11,11,12,12],
        6:[9,10,10,11,12,12],
        7:[9,10,10,11,11,12],
        8:[9,9,10,11,12,12],
        9:[9,9,10,11,11,12],
        10:[9,9,10,10,11,12]  
     },
     4:{
        1:[13,13,14,14,15,15],
        2:[13,13,14,14,16,16],
        3:[13,13,15,15,16,16],
        4:[14,14,15,15,16,16],
        5:[13,14,15,15,16,16],
        6:[13,14,14,15,16,16],
        7:[13,14,14,15,15,16],
        8:[13,13,14,15,16,16],
        9:[13,13,14,15,15,16],
        10:[13,13,14,14,15,16]
    },
    5:{
        1:[17,17,18,18,19,19],
        2:[17,17,18,18,20,20],
        3:[17,17,19,19,20,20],
        4:[18,18,19,19,20,20],
        5:[17,18,19,19,20,20],
        6:[17,18,18,19,20,20],
        7:[17,18,18,19,19,20],
        8:[17,17,18,19,20,20],
        9:[17,17,18,19,19,20],
        10:[17,17,18,18,19,20]
    }, 
    6:{
        1:[21,21,22,22,23,23],
        2:[21,21,22,22,24,24],
        3:[21,21,23,23,24,24],
        4:[22,22,23,23,24,24],
        5:[21,22,23,23,24,24],
        6:[21,22,22,23,24,24],
        7:[21,22,22,23,23,24],
        8:[21,21,22,23,24,24],
        9:[21,21,22,23,23,24],
        10:[21,21,22,22,23,24]
    }, 
    7:{
        1:[25,25,26,26,27,27],
        2:[25,25,26,26,28,28],
        3:[25,25,27,27,28,28],
        4:[26,26,27,27,28,28],
        5:[25,26,27,27,28,28],
        6:[25,26,26,27,28,28],
        7:[25,26,26,27,27,28],
        8:[25,25,26,27,28,28],
        9:[25,25,26,27,27,28],
        10:[25,25,26,26,27,28]
    }, 
    8:{
        1:[29,29,30,30,31,31],
        2:[29,29,30,30,32,32],
        3:[29,29,31,31,32,32],
        4:[30,30,31,31,32,32],
        5:[29,30,31,31,32,32],
        6:[29,30,30,31,32,32],
        7:[29,30,30,31,31,32],
        8:[29,29,30,31,32,32],
        9:[29,29,30,31,31,32],
        10:[29,29,30,30,31,32]
    }, 
    9:{
        1:[33,33,34,34,35,35],
        2:[33,33,34,34,36,36],
        3:[33,33,35,35,36,36],
        4:[34,34,35,35,36,36],
        5:[33,34,35,35,36,36],
        6:[33,34,34,35,36,36],
        7:[33,34,34,35,35,36],
        8:[33,33,34,35,36,36],
        9:[33,33,34,35,35,36],
        10:[33,33,34,34,35,36]
    }, 
    10:{
        1:[37,37,38,38,39,39],
        2:[37,37,38,38,40,40],
        3:[37,37,39,39,40,40],
        4:[38,38,39,39,40,40],
        5:[37,38,39,39,40,40],
        6:[37,38,38,39,40,40],
        7:[37,38,38,39,39,40],
        8:[37,37,38,39,49,40],
        9:[37,37,38,39,39,40],
        10:[37,37,38,38,39,40]
    }, 
    11:{
        1:[41,41,42,42,43,43],
        2:[41,41,42,42,44,44],
        3:[41,41,43,43,44,44],
        4:[42,42,43,43,44,44],
        5:[41,42,43,43,44,44],
        6:[41,42,42,43,44,44],
        7:[41,42,42,43,43,44],
        8:[41,41,42,43,44,44],
        9:[41,41,42,43,43,44],
        10:[41,41,42,42,43,44]
    }, 
    12:{
        1:[45,45,46,46,47,47],
        2:[45,45,46,46,48,48],
        3:[45,45,47,47,48,48],
        4:[46,46,47,47,48,48],
        5:[45,46,47,47,48,48],
        6:[45,46,46,47,48,48],
        7:[45,46,46,47,47,48],
        8:[45,45,46,47,48,48],
        9:[45,45,46,47,47,48],
        10:[45,45,46,46,47,48]
    }, 
    13:{
        1:[49,49,50,50,51,51],
        2:[49,49,50,50,52,52],
        3:[49,49,51,51,52,52],
        4:[50,50,51,51,52,52],
        5:[49,50,51,51,52,52],
        6:[49,50,50,51,52,52],
        7:[49,50,50,51,51,52],
        8:[49,49,50,51,52,52],
        9:[49,49,50,51,51,52],
        10:[49,49,50,50,51,52]
    }
};

// 4张王的表
var cards_4 = {
    1:[53,53,54,54]
}

//3张王的表
var cards_3 = {
    1:{
        1:[53,54,54],
        2:[53,53,54]
    }  
}

// //2张王的表
// var cards_2 = {
//     1:[53,53],
//     2:[53,54],
//     3:[54,54]
// }

//console.log("cards_7============================"+JSON.stringify(cards_7[1][1]));

var cardCounts = [1,6,6,7,6,6,3,1,4,6,8,7,6,5,6,1,6,1,8,6,7,1,6,7,6,6,8,1,6];       //3 和4 是代表3个王 和4个王   678代表普通的牌
var randNus = [];
var rand8 = [];         //标记8表中那些key值已经被随机到了
var rand7 = [];         //标记7表中哪些key值已经被随机到了
var rand6 =[];          //标记6表中哪些key值已经被随机到了
// var rand4 = [];         //标记4表中是否已经随机到了
// var rand3= [];          //标记3表中是否已经随机到了
var rand3and4 = false;        //标记3 或者4 是否已经随机到了
//var rand2 = [];             //标记2表中哪些key是否已经随机到了
var cardsA = [];            //A玩家的牌
var cardsB = [];            //B玩家的牌
var cardsC = [];            //C玩家的牌
var cardsD = [];            //D玩家的牌

//概率 3,3,3,3(炸弹)
//第一个玩家随机炸弹概率
var AzhanDanRand = Math.floor(Math.random() * (3 - 1 + 1)) + 1;
console.log("A炸弹概率============================"+AzhanDanRand);
for(var i = 0;i < AzhanDanRand;i++)
{
    //求出每次炸弹个个数
    var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
    var cardCount = cardCounts[randNum - 1];
    console.log("AcardCount============================"+cardCount);
    if(cardCount == 8 || cardCount == 6 || cardCount == 7)
    {
        var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
        if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
        {
            if(cardCount == 8)
            {
                rand8.push(randNum_);
                for(var j = 0; j <cards_8[randNum_].length;j++)
                {
                    cardsA.push(cards_8[randNum_][j]);
                }
            }
            else if(cardCount == 7)
            {
                rand7.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                for(var j = 0; j < cards_7[randNum_][randNum__].length;j++)
                {
                    cardsA.push(cards_7[randNum_][randNum__][j]);
                }
            }
            else if(cardCount == 6)
            {
                rand6.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                for(var j = 0; j < cards_6[randNum_][randNum__].length;j++)
                {
                    cardsA.push(cards_6[randNum_][randNum__][j]);
                }
            }
        }
        else
        {
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsA.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount ==7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k< cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsA.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsA.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
                
            }
        }
    }
    else if(cardCount == 4 || cardCount == 3)
    {
        if(!rand3and4)
        {
            if(cardCount == 4)
            {
                cardsA.push(53);
                cardsA.push(53);
                cardsA.push(54);
                cardsA.push(54);
            }
            else if(cardCount == 3)
            {
                var randNum__ = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
                if(randNum__ == 1)
                {
                    cardsA.push(53);
                    cardsA.push(54);
                    cardsA.push(54);
                }
                else
                {
                     cardsA.push(53);
                    cardsA.push(53);
                    cardsA.push(54);
                }
            }
            rand3and4 = true;
        }
        else
        {
            
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsA.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsA.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsA.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
            }
        }
    }
   // console.log("A炸弹牌的个数=================1==========="+randNum);
//console.log("A炸弹牌的个数================2============"+cardCount);
}
console.log("A玩家的牌=============1==============="+JSON.stringify(cardsA));
console.log("A玩家的牌===============2============="+cardsA.length);

var BzhanDanRand = Math.floor(Math.random() * (3 - 1 + 1)) + 1;
console.log("B炸弹概率============================"+BzhanDanRand);
for(var i = 0;i < BzhanDanRand;i++)
{
    //求出每次炸弹个个数
    var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
    var cardCount = cardCounts[randNum - 1];
    console.log("BcardCount============================"+cardCount);
    if(cardCount == 8 || cardCount == 6 || cardCount == 7)
    {
        var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
        if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
        {
            if(cardCount == 8)
            {
                rand8.push(randNum_);
                for(var j = 0; j <cards_8[randNum_].length;j++)
                {
                    cardsB.push(cards_8[randNum_][j]);
                }
            }
            else if(cardCount == 7)
            {
                rand7.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                for(var j = 0; j < cards_7[randNum_][randNum__].length;j++)
                {
                    cardsB.push(cards_7[randNum_][randNum__][j]);
                }
            }
            else if(cardCount == 6)
            {
                rand6.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                for(var j = 0; j < cards_6[randNum_][randNum__].length;j++)
                {
                    cardsB.push(cards_6[randNum_][randNum__][j]);
                }
            }
        }
        else
        {
            while(1)
            {
                 var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsB.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsB.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsB.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                     break;
                }
               
            }
        }
    }
    else if(cardCount == 4 || cardCount == 3)
    {
        if(!rand3and4)
        {
            if(cardCount == 4)
            {
                cardsB.push(53);
                cardsB.push(53);
                cardsB.push(54);
                cardsB.push(54);
            }
            else if(cardCount == 3)
            {
                var randNum__ = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
                if(randNum__ == 1)
                {
                    cardsB.push(53);
                    cardsB.push(54);
                    cardsB.push(54);
                }
                else
                {
                    cardsB.push(53);
                    cardsB.push(53);
                    cardsB.push(54);
                }
            }
            rand3and4 = true;
        }
        else
        {
            
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsB.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsB.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsB.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
            }
        }
    }
   // console.log("A炸弹牌的个数=================1==========="+randNum);
//console.log("A炸弹牌的个数================2============"+cardCount);
}
console.log("B玩家的牌=============1==============="+JSON.stringify(cardsB));
console.log("B玩家的牌===============2============="+cardsB.length);

var CzhanDanRand = Math.floor(Math.random() * (3 - 1 + 1)) + 1;
console.log("C炸弹概率============================"+CzhanDanRand);
for(var i = 0;i < CzhanDanRand;i++)
{
    //求出每次炸弹个个数
    var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
    var cardCount = cardCounts[randNum - 1];
    console.log("CcardCount============================"+cardCount);
    if(cardCount == 8 || cardCount == 6 || cardCount == 7)
    {
        var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
        if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
        {
            if(cardCount == 8)
            {
                rand8.push(randNum_);
                for(var j = 0; j <cards_8[randNum_].length;j++)
                {
                    cardsC.push(cards_8[randNum_][j]);
                }
            }
            else if(cardCount == 7)
            {
                rand7.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                for(var j = 0; j < cards_7[randNum_][randNum__].length;j++)
                {
                    cardsC.push(cards_7[randNum_][randNum__][j]);
                }
            }
            else if(cardCount == 6)
            {
                rand6.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                for(var j = 0; j < cards_6[randNum_][randNum__].length;j++)
                {
                    cardsC.push(cards_6[randNum_][randNum__][j]);
                }
            }
        }
        else
        {
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsC.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsC.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsC.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                     break;
                }
               
            }
        }
    }
    else if(cardCount == 4 || cardCount == 3)
    {
        if(!rand3and4)
        {
            if(cardCount == 4)
            {
                cardsC.push(53);
                cardsC.push(53);
                cardsC.push(54);
                cardsC.push(54);
            }
            else if(cardCount == 3)
            {
                var randNum__ = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
                if(randNum__ == 1)
                {
                    cardsC.push(53);
                    cardsC.push(54);
                    cardsC.push(54);
                }
                else
                {
                    cardsC.push(53);
                    cardsC.push(53);
                    cardsC.push(54);
                }
            }
            rand3and4 = true;
        }
        else
        {
            
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsC.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsC.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsC.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
            }
        }
    }
   // console.log("A炸弹牌的个数=================1==========="+randNum);
//console.log("A炸弹牌的个数================2============"+cardCount);
}
console.log("C玩家的牌=============1==============="+JSON.stringify(cardsC));
console.log("C玩家的牌===============2============="+cardsC.length);


var DzhanDanRand = Math.floor(Math.random() * (3 - 1 + 1)) + 1;
console.log("D炸弹概率============================"+DzhanDanRand);
for(var i = 0;i < DzhanDanRand;i++)
{
    //求出每次炸弹个个数
    var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
    var cardCount = cardCounts[randNum - 1];
    console.log("D炸弹张数============================"+cardCount);
    if(cardCount == 8 || cardCount == 6 || cardCount == 7)
    {
        var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
        if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
        {
            if(cardCount == 8)
            {
                rand8.push(randNum_);
                for(var j = 0; j <cards_8[randNum_].length;j++)
                {
                    cardsD.push(cards_8[randNum_][j]);
                }
            }
            else if(cardCount == 7)
            {
                rand7.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                for(var j = 0; j < cards_7[randNum_][randNum__].length;j++)
                {
                    cardsD.push(cards_7[randNum_][randNum__][j]);
                }
            }
            else if(cardCount == 6)
            {
                rand6.push(randNum_);
                var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                for(var j = 0; j < cards_6[randNum_][randNum__].length;j++)
                {
                    cardsD.push(cards_6[randNum_][randNum__][j]);
                }
            }
        }
        else
        {
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;

                randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0;  k <cards_8[randNum_].length;k++)
                        {
                            cardsD.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsD.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsD.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
                
            }
        }
    }
    else if(cardCount == 4 || cardCount == 3)
    {
        if(!rand3and4)
        {
            if(cardCount == 4)
            {
                cardsD.push(53);
                cardsD.push(53);
                cardsD.push(54);
                cardsD.push(54);
            }
            else if(cardCount == 3)
            {
                var randNum__ = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
                if(randNum__ == 1)
                {
                    cardsD.push(53);
                    cardsD.push(54);
                    cardsD.push(54);
                }
                else
                {
                    cardsD.push(53);
                    cardsD.push(53);
                    cardsD.push(54);
                }
            }
            rand3and4 = true;
        }
        else
        { 
            while(1)
            {
                var randNum = Math.floor(Math.random() * (cardCounts.length - 1 + 1)) + 1;
                var cardCount = cardCounts[randNum - 1];
                if(cardCount == 3 || cardCount == 4) continue;
                var randNum_ = Math.floor(Math.random() * (13 - 1 + 1)) + 1;
                if(rand8.indexOf(randNum_) == -1 && rand7.indexOf(randNum_) == -1 && rand6.indexOf(randNum_) == -1)
                {
                    if(cardCount == 8)
                    {
                        rand8.push(randNum_);
                        for(var k = 0; k <cards_8[randNum_].length;k++)
                        {
                            cardsD.push(cards_8[randNum_][k]);
                        }
                    }
                    else if(cardCount == 7)
                    {
                        rand7.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_7[randNum_][randNum__].length;k++)
                        {
                            cardsD.push(cards_7[randNum_][randNum__][k]);
                        }
                    }
                    else if(cardCount == 6)
                    {
                        rand6.push(randNum_);
                        var randNum__ = Math.floor(Math.random() * (10 - 1 + 1)) + 1;
                        for(var k = 0; k < cards_6[randNum_][randNum__].length;k++)
                        {
                            cardsD.push(cards_6[randNum_][randNum__][k]);
                        }
                    }
                    break;
                }
            }
        }
    }
   // console.log("A炸弹牌的个数=================1==========="+randNum);
//console.log("A炸弹牌的个数================2============"+cardCount);
}
console.log("D玩家的牌=============1==============="+JSON.stringify(cardsD));
console.log("D玩家的牌===============2============="+cardsD.length);

var disCountA = 27 - cardsA.length;
var disCountB = 27 - cardsB.length;
var disCountC = 27 - cardsC.length;
var disCountD = 27 - cardsD.length;

// console.log("相差牌=========A=========="+disCountA);
// console.log("相差牌=========B=========="+disCountB);
// console.log("相差牌=========C=========="+disCountC);
// console.log("相差牌=========D=========="+disCountD);

var tmpCard = [];
for(var i = 0;i <cardsA.length;i++)
{
    tmpCard.push(cardsA[i]);
}
for(var i = 0;i <cardsB.length;i++)
{
    tmpCard.push(cardsB[i]);
}
for(var i = 0;i <cardsC.length;i++)
{
    tmpCard.push(cardsC[i]);
}
for(var i = 0;i <cardsD.length;i++)
{
    tmpCard.push(cardsD[i]);
}
var card = [];
for (var i = 1;i <= 54;i++)
{
    card.push(i);
    card.push(i);
}

// console.log("card=============1==============="+JSON.stringify(card));
// console.log("card=============2==============="+card.length);
// console.log("tmpCard=============1==============="+JSON.stringify(tmpCard));
// console.log("tmpCard=============2==============="+tmpCard.length);

var tmpCardNew = [];
var kingCard = [];
for(var i = 1;i <= 54;i++)
{
    if(tmpCard.indexOf(i) == -1)
    {
        if(i != 53 && i != 54)
        {
            tmpCardNew.push(i);
            tmpCardNew.push(i);
        }
       else{
            kingCard.push(i);
            kingCard.push(i);
       }
    }
    else
    {
        var count = 0;
        for(var j = 0; j < tmpCard.length;j++)
        {
            if(tmpCard[j] == i)
            {
                count++;
            }
        }
        if(count == 1)
        {
            if(i != 53 && i != 54)
                tmpCardNew.push(i);
            else
                kingCard.push(i);
        }
    }
}

 console.log("tmpCardNew=============1==============="+JSON.stringify(tmpCardNew));
 console.log("tmpCardNew=============2==============="+tmpCardNew.length);

//  for (var i = 0; i < tmpCardNew.length; i ++) {
//     var randIndex = i + Math.floor(Math.random() * (tmpCardNew.length - i));
//     var temp = tmpCardNew[i];
//     tmpCardNew[i] = tmpCardNew[randIndex];
//     tmpCardNew[randIndex] = temp;
// }


//  for (var i = 0; i < tmpCardNew.length - 1; i +=1 ){
//     var randIndex = i + Math.floor(Math.random() * (tmpCardNew.length - i));
//     var temp = tmpCardNew[i];
//     tmpCardNew[i] = tmpCardNew[randIndex];
//     tmpCardNew[randIndex] = temp;
// }

//  for (var i = 0; i < tmpCardNew.length - 7; i +=7 ){
//     var randIndex = i + Math.floor(Math.random() * (tmpCardNew.length - i));
//     var temp = tmpCardNew[i];
//     tmpCardNew[i] = tmpCardNew[randIndex];
//     tmpCardNew[randIndex] = temp;
// }

var a = [1,2,3,4,5,6,7,8,9,10,11,12,13];
for (var i = 0; i < a.length - 1; i +=1 ){
    var randIndex = i + Math.floor(Math.random() * (a.length - i));
    var temp = a[i];
    a[i] = a[randIndex];
    a[randIndex] = temp;
}

var c ={
    1:[],
    2:[],
    3:[],
    4:[],
    5:[],
    6:[],
    7:[],
    8:[],
    9:[],
    10:[],
    11:[],
    12:[],
    13:[]
}

for(var i = 0;i < tmpCardNew.length;i++)
{
    var ceilNum = Math.ceil(tmpCardNew[i] / 4);
    c[ceilNum].push(tmpCardNew[i]);
}
console.log("tmpCardNew=============c========1======="+JSON.stringify(c));

for(var i = 1;i <= 13;i++)
{
    var tmpcard = c[i];
    c[i] = c[a[i - 1]];
     c[a[i - 1]] = tmpcard;
}

var tmp1 = [];          //记录随机的数据
var tmp2 = [];          //单独记录随机数据超过3个的数据
console.log("tmpCardNew=============c=========2======"+JSON.stringify(c));
for(var i = 1;i <= 13;i++)
{
    if(c[i].length > 6)
    {
        var rand = Math.floor(Math.random() * (6 - 4 + 1)) + 4;
        console.log("rand============222===length============="+rand);
        for(var j =0;j < rand;j++)
        {
            tmp1.push(c[i][j]);
        }
        for(var j = rand;j < c[i].length;j++)
        {
            tmp2.push(c[i][j]);
        }
    }
    else
    {
        for(var j = 0; j < c[i].length;j++)
        {
            tmp1.push(c[i][j]);
        }
    }
}

var tmpCard22 = [];
for(var i = 0;i < tmp1.length;i++)
{
    tmpCard22.push(tmp1[i]);
}

for(var i = 0;i < tmp2.length;i++)
{
    tmpCard22.push(tmp2[i]);
}

tmpCardNew = tmpCard22;
 //console.log("kingCard=============1==============="+JSON.stringify(kingCard));
 //console.log("kingCard=============2==============="+kingCard.length);
console.log("tmpCardNew=============3==============="+JSON.stringify(tmpCardNew));
console.log("tmpCardNew=============4==============="+tmpCardNew.length);

var tmpKing = [];
if(kingCard.length == 4)
    {
        var rand_1 = Math.floor(Math.random() * (3 - 2 + 1)) + 2;
        console.log("rand_1============================"+rand_1);
        if(rand_1 == 2)
        {
            var rand_2 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
           // console.log("rand_2=============1==============="+ rand_2);
            // 12 13  23
            var rand_3 = Math.floor(Math.random() * (3 - 1 + 1)) + 1;
            if(rand_3 == 1)
            {
                tmpCardNew.splice(rand_2 - 1,0,kingCard[0],kingCard[1]);
                tmpKing.push(kingCard[2]);
                tmpKing.push(kingCard[3]);
            }    
            else if(rand_3 == 2)
            {
                tmpCardNew.splice(rand_2 - 1,0,kingCard[0],kingCard[2]);
                 tmpKing.push(kingCard[1]);
                tmpKing.push(kingCard[3]);
            }   
            else if(rand_3 == 3)
            {
                tmpCardNew.splice(rand_2 - 1,0,kingCard[2],kingCard[3]);
                tmpKing.push(kingCard[0]);
                tmpKing.push(kingCard[1]);
            }
            var rand_4 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_4 - 1,0,tmpKing[0]);
             var rand_5 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_5 - 1,0,tmpKing[1]);  
        }
        else if(rand_1 == 3)
        {
            var rand_2 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            //console.log("rand_2=============2==============="+rand_2);
            // 12 13  23
            var rand_3 = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
            if(rand_3 == 1)
            {
                tmpCardNew.splice(rand_2 - 1,0,kingCard[0],kingCard[1],kingCard[2]);
                tmpKing.push(kingCard[2]);
            }
            else if(rand_3 == 2)
            {
                tmpCardNew.splice(rand_2 - 1,0,kingCard[0],kingCard[2],kingCard[3]);
                tmpKing.push(kingCard[1]);
            }
            var rand_4 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_4 - 1,0,tmpKing[0]);
        }
        else if(rand_1 == 4)
        {
            var rand_2 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_2 - 1,0,kingCard[0]);
            //console.log("rand_2=============3==============="+rand_2);
            //tmpCardNew.splice(rand_2 - 1,0,kingCard[0],kingCard[1],kingCard[2],kingCard[3]);
             var rand_3 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_3 - 1,0,kingCard[1]);
             var rand_4 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_4 - 1,0,kingCard[2]);
             var rand_5 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
            tmpCardNew.splice(rand_5 - 1,0,kingCard[3]);
        }
    }
else if(kingCard.length == 1)
{
    var rand_4 = Math.floor(Math.random() * (tmpCardNew.length - 1 + 1)) + 1;
        tmpCardNew.splice(rand_4 - 1,0,kingCard[0]);
}
 console.log("tmpCardNew=============5==============="+JSON.stringify(tmpCardNew));
 console.log("tmpCardNew=============6==============="+tmpCardNew.length);

var tmpCardsNew = [];
var idx = 0;
//塞A的牌
for(var i = 0; i < cardsA.length;i++)
{
    tmpCardsNew.push(cardsA[i]);
}
//补齐A的差牌
for(var i = 0; i <disCountA;i++)
{
    tmpCardsNew.push(tmpCardNew[idx]);
    idx++;
}

//B玩家的牌
for(var i = 0; i < cardsB.length;i++)
{
    tmpCardsNew.push(cardsB[i]);
}
//补齐B的差牌
for(var i = 0; i <disCountB;i++)
{
    tmpCardsNew.push(tmpCardNew[idx]);
    idx++;
}

//c玩家的牌
for(var i = 0; i < cardsC.length;i++)
{
    tmpCardsNew.push(cardsC[i]);
}
//补齐C的差牌
for(var i = 0; i <disCountC;i++)
{
    tmpCardsNew.push(tmpCardNew[idx]);
    idx++;
}

//D玩家的牌
for(var i = 0; i < cardsD.length;i++)
{
    tmpCardsNew.push(cardsD[i]);
}
//补齐D的差牌
for(var i = 0; i <disCountD;i++)
{
    tmpCardsNew.push(tmpCardNew[idx]);
    idx++;
}

console.log("新的牌======1==="+JSON.stringify(tmpCardsNew));

console.log("新的牌======2==="+ tmpCardsNew.length);


console 命令行工具 X clear

                    
>
console