hnhzServer/app/shuiguo/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);

// 构造方法
var Logic = function () {
    this.over = 0;//当前局数
    this.dairuMax = 100000;//每天可带入最大额度（钻石）
    this.prizePool = 10000000;
    this.cellList = [10];//底分倍率列表
    this.nowCell = 0.1;//当前底分倍率
    this.toTaskQuanReate = 1;//押注额转换为任务券的比例（10钻=1分给1个任务券）把之前的0.01改为0.1是为了不让任务券出现小数
    this.yzjjckcReate = 0;//押注总额进入奖池扣除的比例（如总押注10钻=1分时全输了对应挡位奖池数量增加9.5个钻）
    this.fqjjckcReate = 0;//有任务券发放时进入奖池扣除的比例
    this.jcdwzhwzs = 100;//奖池单位：1/100钻（即1钻=100奖池单位）
    //为了奖池不出现小数，所以奖池的单位是1/100钻
    // 下面这4个变量是为了实现下面这个规则
    //大橙子大芒果大铃铛这三个在10，15，20中随机取倍数  大西瓜大星星大七七这三个在20，30，40中随机取倍数
    this.xbss = [10,15,20];//小倍数列表
    this.dbss = [20,30,40];//大倍数列表
    this.xbsps = [0,12,6,18,1,13];//小倍数即在10，15，20中随机取倍数的牌（大橙子大芒果大铃铛这三个）
    this.dbsps = [7,19,15];//大倍数即在20，30，40中随机取倍数的牌（大西瓜大星星大七七这三个）
    this.xpPool = [2,5,8,11,14,17,20,23];//小牌牌值数组（如小苹果小橙子等都是小牌）
    this.dpPool = [0,1,3,4,6,7,10,12,13,15,16,18,19,22];//大牌牌值数组（如大苹果大橙子等都是大牌）
    this.cardsPool = [//牌池[编号,名称,倍率,对应下注列表的下标]
        [0,"大橙子",10,1],
        [1,"大铃铛",20,3],
        [2,"小王王",50,7],
        [3,"大王王",100,7],
        [4,"大苹果",5,0],
        [5,"小苹果",3,0],
        [6,"大芒果",15,2],
        [7,"大西瓜",20,4],
        [8,"小西瓜",3,4],
        [9,"幸运运",0,8],
        [10,"大苹果",5,0],
        [11,"小橙子",3,1],
        [12,"大橙子",10,1],
        [13,"大铃铛",20,3],
        [14,"小七七",3,6],
        [15,"大七七",40,6],
        [16,"大苹果",5,0],
        [17,"小芒果",3,2],
        [18,"大芒果",15,2],
        [19,"大星星",30,5],
        [20,"小星星",3,5],
        [21,"幸运运",0,8],
        [22,"大苹果",5,0],
        [23,"小铃铛",3,3]
    ];
    //发牌区间列表，用于随机数转换成发牌,如：随机数在[0,37)区间内发0号牌，随机数在[37,56)区间内发1号牌，随机数在[56,61)区间内发2号牌
    this.fpqjList = [
        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 36,//02号牌:出10次小王王位置：上侧从左数第2张,',
        // 42,//03号牌:出6次大王王位置：上侧从左数第3张,',
        // 82,//04号牌:出40次大苹果位置：上侧从左数第4张,',
        // 162,//05号牌:出80次小苹果位置：上侧从左数第5张,',
        // 175,//06号牌:出13次大芒果位置：右上角,',
        // 188,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 268,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 325,//09号牌:出57次幸运运位置：右侧从左数第3张,',
        // 365,//10号牌:出40次大苹果位置：右侧从左数第4张,',
        // 445,//11号牌:出80次小橙子位置：右侧从左数第5张,',
        // 458,//12号牌:出13次大橙子位置：右下角,',
        // 471,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 551,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 564,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 604,//16号牌:出40次大苹果位置：下侧从左数第4张,',
        // 684,//17号牌:出80次小芒果位置：下侧从左数第5张,',
        // 697,//18号牌:出13次大芒果位置：左下角,',
        // 710,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 790,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 847,//21号牌:出57次幸运运位置：左侧从左数第3张,',
        // 887,//22号牌:出40次大苹果位置：左侧从左数第4张,',
        // 967,//23号牌:出80次小铃铛位置：左侧从左数第5张,',
        // 977,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 982,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出18次特殊牌大四喜（4个大苹果 ） ,' ]

        // 19,//00号牌:出19次大橙子位置：左上角,',
        // 38,//01号牌:出19次大铃铛位置：上侧从左数第1张,',
        // 47,//02号牌:出9次小王王位置：上侧从左数第2张,',
        // 52,//03号牌:出5次大王王位置：上侧从左数第3张,',
        // 80,//04号牌:出28次大苹果位置：上侧从左数第4张,',
        // 160,//05号牌:出80次小苹果位置：上侧从左数第5张,',
        // 179,//06号牌:出19次大芒果位置：右上角,',
        // 198,//07号牌:出19次大西瓜位置：右侧从左数第1张,',
        // 278,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 338,//09号牌:出60次幸运运位置：右侧从左数第3张,',
        // 366,//10号牌:出28次大苹果位置：右侧从左数第4张,',
        // 446,//11号牌:出80次小橙子位置：右侧从左数第5张,',
        // 465,//12号牌:出19次大橙子位置：右下角,',
        // 484,//13号牌:出19次大铃铛位置：下侧从左数第1张,',
        // 564,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 583,//15号牌:出19次大七七位置：下侧从左数第3张,',
        // 611,//16号牌:出28次大苹果位置：下侧从左数第4张,',
        // 691,//17号牌:出80次小芒果位置：下侧从左数第5张,',
        // 710,//18号牌:出19次大芒果位置：左下角,',
        // 729,//19号牌:出19次大星星位置：左侧从左数第1张,',
        // 809,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 869,//21号牌:出60次幸运运位置：左侧从左数第3张,',
        // 897,//22号牌:出28次大苹果位置：左侧从左数第4张,',
        // 977,//23号牌:出80次小铃铛位置：左侧从左数第5张,',
        // 987,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 992,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出8次特殊牌大四喜（4个大苹果 ） ,' ]
        // 
        
        // 15,//00号牌:出15次大橙子位置：左上角,',
        // 30,//01号牌:出15次大铃铛位置：上侧从左数第1张,',
        // 38,//02号牌:出8次小王王位置：上侧从左数第2张,',
        // 42,//03号牌:出4次大王王位置：上侧从左数第3张,',
        // 70,//04号牌:出28次大苹果位置：上侧从左数第4张,',
        // 150,//05号牌:出80次小苹果位置：上侧从左数第5张,',
        // 165,//06号牌:出15次大芒果位置：右上角,',
        // 180,//07号牌:出15次大西瓜位置：右侧从左数第1张,',
        // 260,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 339,//09号牌:出79次幸运运位置：右侧从左数第3张,',
        // 367,//10号牌:出28次大苹果位置：右侧从左数第4张,',
        // 447,//11号牌:出80次小橙子位置：右侧从左数第5张,',
        // 462,//12号牌:出15次大橙子位置：右下角,',
        // 477,//13号牌:出15次大铃铛位置：下侧从左数第1张,',
        // 557,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 572,//15号牌:出15次大七七位置：下侧从左数第3张,',
        // 600,//16号牌:出28次大苹果位置：下侧从左数第4张,',
        // 680,//17号牌:出80次小芒果位置：下侧从左数第5张,',
        // 695,//18号牌:出15次大芒果位置：左下角,',
        // 710,//19号牌:出15次大星星位置：左侧从左数第1张,',
        // 790,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 869,//21号牌:出79次幸运运位置：左侧从左数第3张,',
        // 897,//22号牌:出28次大苹果位置：左侧从左数第4张,',
        // 977,//23号牌:出80次小铃铛位置：左侧从左数第5张,',
        // 987,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 992,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000,//26号牌:出8次特殊牌大四喜（4个大苹果 ） ,'


        // 15,//00号牌:出15次大橙子位置：左上角,',
        // 30,//01号牌:出15次大铃铛位置：上侧从左数第1张,',
        // 40,//02号牌:出10次小王王位置：上侧从左数第2张,',
        // 44,//03号牌:出4次大王王位置：上侧从左数第3张,',
        // 69,//04号牌:出25次大苹果位置：上侧从左数第4张,',
        // 159,//05号牌:出90次小苹果位置：上侧从左数第5张,',
        // 174,//06号牌:出15次大芒果位置：右上角,',
        // 189,//07号牌:出15次大西瓜位置：右侧从左数第1张,',
        // 269,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 336,//09号牌:出67次幸运运位置：右侧从左数第3张,',
        // 361,//10号牌:出25次大苹果位置：右侧从左数第4张,',
        // 451,//11号牌:出90次小橙子位置：右侧从左数第5张,',
        // 466,//12号牌:出15次大橙子位置：右下角,',
        // 481,//13号牌:出15次大铃铛位置：下侧从左数第1张,',
        // 561,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 576,//15号牌:出15次大七七位置：下侧从左数第3张,',
        // 601,//16号牌:出25次大苹果位置：下侧从左数第4张,',
        // 691,//17号牌:出90次小芒果位置：下侧从左数第5张,',
        // 706,//18号牌:出15次大芒果位置：左下角,',
        // 721,//19号牌:出15次大星星位置：左侧从左数第1张,',
        // 801,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 868,//21号牌:出67次幸运运位置：左侧从左数第3张,',
        // 893,//22号牌:出25次大苹果位置：左侧从左数第4张,',
        // 983,//23号牌:出90次小铃铛位置：左侧从左数第5张,',
        // 991,//24号牌:出8次特殊牌小三元（橘子，芒果，铃铛）,',
        // 996,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出4次特殊牌大四喜（4个大苹果 ） ,' ]

        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 34,//02号牌:出8次小王王位置：上侧从左数第2张,',
        // 37,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 60,//04号牌:出23次大苹果位置：上侧从左数第4张,',
        // 140,//05号牌:出80次小苹果位置：上侧从左数第5张,',
        // 153,//06号牌:出13次大芒果位置：右上角,',
        // 166,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 246,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 348,//09号牌:出102次幸运运位置：右侧从左数第3张,',
        // 371,//10号牌:出23次大苹果位置：右侧从左数第4张,',
        // 451,//11号牌:出80次小橙子位置：右侧从左数第5张,',
        // 464,//12号牌:出13次大橙子位置：右下角,',
        // 477,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 557,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 570,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 593,//16号牌:出23次大苹果位置：下侧从左数第4张,',
        // 673,//17号牌:出80次小芒果位置：下侧从左数第5张,',
        // 686,//18号牌:出13次大芒果位置：左下角,',
        // 699,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 779,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 881,//21号牌:出102次幸运运位置：左侧从左数第3张,',
        // 904,//22号牌:出23次大苹果位置：左侧从左数第4张,',
        // 984,//23号牌:出80次小铃铛位置：左侧从左数第5张,',
        // 992,//24号牌:出8次特殊牌小三元（橘子，芒果，铃铛）,',
        // 996,//25号牌:出4次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出4次特殊牌大四喜（4个大苹果 ） ,' ]

        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 35,//02号牌:出9次小王王位置：上侧从左数第2张,',
        // 38,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 58,//04号牌:出20次大苹果位置：上侧从左数第4张,',
        // 143,//05号牌:出85次小苹果位置：上侧从左数第5张,',
        // 156,//06号牌:出13次大芒果位置：右上角,',
        // 169,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 254,//08号牌:出85次小西瓜位置：右侧从左数第2张,',
        // 344,//09号牌:出90次幸运运位置：右侧从左数第3张,',
        // 364,//10号牌:出20次大苹果位置：右侧从左数第4张,',
        // 449,//11号牌:出85次小橙子位置：右侧从左数第5张,',
        // 462,//12号牌:出13次大橙子位置：右下角,',
        // 475,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 560,//14号牌:出85次小七七位置：下侧从左数第2张,',
        // 573,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 593,//16号牌:出20次大苹果位置：下侧从左数第4张,',
        // 678,//17号牌:出85次小芒果位置：下侧从左数第5张,',
        // 691,//18号牌:出13次大芒果位置：左下角,',
        // 704,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 789,//20号牌:出85次小星星位置：左侧从左数第2张,',
        // 879,//21号牌:出90次幸运运位置：左侧从左数第3张,',
        // 899,//22号牌:出20次大苹果位置：左侧从左数第4张,',
        // 984,//23号牌:出85次小铃铛位置：左侧从左数第5张,',
        // 992,//24号牌:出8次特殊牌小三元（橘子，芒果，铃铛）,',
        // 996,//25号牌:出4次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出4次特殊牌大四喜（4个大苹果 ） ,' ]

        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 35,//02号牌:出9次小王王位置：上侧从左数第2张,',
        // 38,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 59,//04号牌:出21次大苹果位置：上侧从左数第4张,',
        // 144,//05号牌:出85次小苹果位置：上侧从左数第5张,',
        // 157,//06号牌:出13次大芒果位置：右上角,',
        // 170,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 255,//08号牌:出85次小西瓜位置：右侧从左数第2张,',
        // 341,//09号牌:出86次幸运运位置：右侧从左数第3张,',
        // 362,//10号牌:出21次大苹果位置：右侧从左数第4张,',
        // 447,//11号牌:出85次小橙子位置：右侧从左数第5张,',
        // 460,//12号牌:出13次大橙子位置：右下角,',
        // 473,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 558,//14号牌:出85次小七七位置：下侧从左数第2张,',
        // 571,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 592,//16号牌:出21次大苹果位置：下侧从左数第4张,',
        // 677,//17号牌:出85次小芒果位置：下侧从左数第5张,',
        // 690,//18号牌:出13次大芒果位置：左下角,',
        // 703,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 788,//20号牌:出85次小星星位置：左侧从左数第2张,',
        // 874,//21号牌:出86次幸运运位置：左侧从左数第3张,',
        // 895,//22号牌:出21次大苹果位置：左侧从左数第4张,',
        // 980,//23号牌:出85次小铃铛位置：左侧从左数第5张,',
        // 990,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 996,//25号牌:出6次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出4次特殊牌大四喜（4个大苹果 ） ,' ]


        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 35,//02号牌:出9次小王王位置：上侧从左数第2张,',
        // 38,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 59,//04号牌:出21次大苹果位置：上侧从左数第4张,',
        // 144,//05号牌:出85次小苹果位置：上侧从左数第5张,',
        // 157,//06号牌:出13次大芒果位置：右上角,',
        // 170,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 255,//08号牌:出85次小西瓜位置：右侧从左数第2张,',
        // 341,//09号牌:出86次幸运运位置：右侧从左数第3张,',
        // 362,//10号牌:出21次大苹果位置：右侧从左数第4张,',
        // 447,//11号牌:出85次小橙子位置：右侧从左数第5张,',
        // 460,//12号牌:出13次大橙子位置：右下角,',
        // 473,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 558,//14号牌:出85次小七七位置：下侧从左数第2张,',
        // 571,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 592,//16号牌:出21次大苹果位置：下侧从左数第4张,',
        // 677,//17号牌:出85次小芒果位置：下侧从左数第5张,',
        // 690,//18号牌:出13次大芒果位置：左下角,',
        // 703,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 788,//20号牌:出85次小星星位置：左侧从左数第2张,',
        // 874,//21号牌:出86次幸运运位置：左侧从左数第3张,',
        // 895,//22号牌:出21次大苹果位置：左侧从左数第4张,',
        // 980,//23号牌:出85次小铃铛位置：左侧从左数第5张,',
        // 990,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 995,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000,//26号牌:出5次特殊牌大四喜（4个大苹果 ） ,' ]



        // 13,//00号牌:出13次大橙子位置：左上角,',
        // 26,//01号牌:出13次大铃铛位置：上侧从左数第1张,',
        // 35,//02号牌:出9次小王王位置：上侧从左数第2张,',
        // 38,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 59,//04号牌:出21次大苹果位置：上侧从左数第4张,',
        // 143,//05号牌:出84次小苹果位置：上侧从左数第5张,',
        // 156,//06号牌:出13次大芒果位置：右上角,',
        // 169,//07号牌:出13次大西瓜位置：右侧从左数第1张,',
        // 254,//08号牌:出85次小西瓜位置：右侧从左数第2张,',
        // 340,//09号牌:出86次幸运运位置：右侧从左数第3张,',
        // 361,//10号牌:出21次大苹果位置：右侧从左数第4张,',
        // 446,//11号牌:出85次小橙子位置：右侧从左数第5张,',
        // 459,//12号牌:出13次大橙子位置：右下角,',
        // 472,//13号牌:出13次大铃铛位置：下侧从左数第1张,',
        // 557,//14号牌:出85次小七七位置：下侧从左数第2张,',
        // 570,//15号牌:出13次大七七位置：下侧从左数第3张,',
        // 591,//16号牌:出21次大苹果位置：下侧从左数第4张,',
        // 676,//17号牌:出85次小芒果位置：下侧从左数第5张,',
        // 689,//18号牌:出13次大芒果位置：左下角,',
        // 702,//19号牌:出13次大星星位置：左侧从左数第1张,',
        // 787,//20号牌:出85次小星星位置：左侧从左数第2张,',
        // 873,//21号牌:出86次幸运运位置：左侧从左数第3张,',
        // 894,//22号牌:出21次大苹果位置：左侧从左数第4张,',
        // 979,//23号牌:出85次小铃铛位置：左侧从左数第5张,',
        // 989,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 994,//25号牌:出5次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出6次特殊牌大四喜（4个大苹果 ） ,' ]




        // 14,//00号牌:出14次大橙子位置：左上角,',
        // 28,//01号牌:出14次大铃铛位置：上侧从左数第1张,',
        // 38,//02号牌:出10次小王王位置：上侧从左数第2张,',
        // 41,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 64,//04号牌:出23次大苹果位置：上侧从左数第4张,',
        // 145,//05号牌:出81次小苹果位置：上侧从左数第5张,',
        // 159,//06号牌:出14次大芒果位置：右上角,',
        // 173,//07号牌:出14次大西瓜位置：右侧从左数第1张,',
        // 253,//08号牌:出80次小西瓜位置：右侧从左数第2张,',
        // 334,//09号牌:出81次幸运运位置：右侧从左数第3张,',
        // 357,//10号牌:出23次大苹果位置：右侧从左数第4张,',
        // 445,//11号牌:出88次小橙子位置：右侧从左数第5张,',
        // 459,//12号牌:出14次大橙子位置：右下角,',
        // 473,//13号牌:出14次大铃铛位置：下侧从左数第1张,',
        // 553,//14号牌:出80次小七七位置：下侧从左数第2张,',
        // 567,//15号牌:出14次大七七位置：下侧从左数第3张,',
        // 590,//16号牌:出23次大苹果位置：下侧从左数第4张,',
        // 678,//17号牌:出88次小芒果位置：下侧从左数第5张,',
        // 692,//18号牌:出14次大芒果位置：左下角,',
        // 706,//19号牌:出14次大星星位置：左侧从左数第1张,',
        // 786,//20号牌:出80次小星星位置：左侧从左数第2张,',
        // 867,//21号牌:出81次幸运运位置：左侧从左数第3张,',
        // 890,//22号牌:出23次大苹果位置：左侧从左数第4张,',
        // 978,//23号牌:出88次小铃铛位置：左侧从左数第5张,',
        // 988,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 994,//25号牌:出6次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出6次特殊牌大四喜（4个大苹果 ） ,' 


        // 14,//00号牌:出14次大橙子位置：左上角,',
        // 28,//01号牌:出14次大铃铛位置：上侧从左数第1张,',
        // 38,//02号牌:出10次小王王位置：上侧从左数第2张,',
        // 41,//03号牌:出3次大王王位置：上侧从左数第3张,',
        // 64,//04号牌:出23次大苹果位置：上侧从左数第4张,',
        // 145,//05号牌:出81次小苹果位置：上侧从左数第5张,',
        // 159,//06号牌:出14次大芒果位置：右上角,',
        // 173,//07号牌:出14次大西瓜位置：右侧从左数第1张,',
        // 251,//08号牌:出78次小西瓜位置：右侧从左数第2张,',
        // 338,//09号牌:出87次幸运运位置：右侧从左数第3张,',
        // 361,//10号牌:出23次大苹果位置：右侧从左数第4张,',
        // 447,//11号牌:出86次小橙子位置：右侧从左数第5张,',
        // 461,//12号牌:出14次大橙子位置：右下角,',
        // 475,//13号牌:出14次大铃铛位置：下侧从左数第1张,',
        // 553,//14号牌:出78次小七七位置：下侧从左数第2张,',
        // 567,//15号牌:出14次大七七位置：下侧从左数第3张,',
        // 590,//16号牌:出23次大苹果位置：下侧从左数第4张,',
        // 676,//17号牌:出86次小芒果位置：下侧从左数第5张,',
        // 690,//18号牌:出14次大芒果位置：左下角,',
        // 704,//19号牌:出14次大星星位置：左侧从左数第1张,',
        // 782,//20号牌:出78次小星星位置：左侧从左数第2张,',
        // 869,//21号牌:出87次幸运运位置：左侧从左数第3张,',
        // 892,//22号牌:出23次大苹果位置：左侧从左数第4张,',
        // 978,//23号牌:出86次小铃铛位置：左侧从左数第5张,',
        // 988,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        // 994,//25号牌:出6次特殊牌大三元（西瓜，双星，77）,',
        // 1000//26号牌:出6次特殊牌大四喜（4个大苹果 ） ,' ]


        14,//00号牌:出14次大橙子位置：左上角,',
        28,//01号牌:出14次大铃铛位置：上侧从左数第1张,',
        38,//02号牌:出10次小王王位置：上侧从左数第2张,',
        41,//03号牌:出3次大王王位置：上侧从左数第3张,',
        64,//04号牌:出23次大苹果位置：上侧从左数第4张,',
        144,//05号牌:出80次小苹果位置：上侧从左数第5张,',
        158,//06号牌:出14次大芒果位置：右上角,',
        172,//07号牌:出14次大西瓜位置：右侧从左数第1张,',
        254,//08号牌:出82次小西瓜位置：右侧从左数第2张,',
        329,//09号牌:出75次幸运运位置：右侧从左数第3张,',
        352,//10号牌:出23次大苹果位置：右侧从左数第4张,',
        442,//11号牌:出90次小橙子位置：右侧从左数第5张,',
        456,//12号牌:出14次大橙子位置：右下角,',
        470,//13号牌:出14次大铃铛位置：下侧从左数第1张,',
        552,//14号牌:出82次小七七位置：下侧从左数第2张,',
        566,//15号牌:出14次大七七位置：下侧从左数第3张,',
        589,//16号牌:出23次大苹果位置：下侧从左数第4张,',
        679,//17号牌:出90次小芒果位置：下侧从左数第5张,',
        693,//18号牌:出14次大芒果位置：左下角,',
        707,//19号牌:出14次大星星位置：左侧从左数第1张,',
        789,//20号牌:出82次小星星位置：左侧从左数第2张,',
        864,//21号牌:出75次幸运运位置：左侧从左数第3张,',
        887,//22号牌:出23次大苹果位置：左侧从左数第4张,',
        977,//23号牌:出90次小铃铛位置：左侧从左数第5张,',
        987,//24号牌:出10次特殊牌小三元（橘子，芒果，铃铛）,',
        993,//25号牌:出6次特殊牌大三元（西瓜，双星，77）,',
        1000//26号牌:出7次特殊牌大四喜（4个大苹果 ） ,' ]
    ];
    if(this.cardsPool.length != this.fpqjList.length - 3){//因为有3个特殊牌型
        console.error("牌池数组长度不等于发牌区间数组长度 ",this.cardsPool.length , this.fpqjList.length);
    }
    this.cardAllCount = this.cardsPool.length;//牌池总张数
    this.cardKindCount = 17;//牌类型总数(8大8小1幸运)
    //任务中reachs的说明 ["大苹果","大橙子","大芒果","大铃铛","大西瓜","大星星","大七七","大王王","幸运运","小苹果","小橙子","小芒果","小铃铛","小西瓜","小星星","小七七","小王王"];
    this.renwuPool = [//任务池列表
        // {
        //     index:0,//该条任务编号
        //     isOpen:1,//该条任务是否开放0：不开放，1：开放
        //     des:"这是任务的说明0",//该条任务说明
        //     sTime: 1676044800000,//该条任务开始时间
        //     eTime: 1785513600000,//该条任务结束时间  
        //     times: 10,//该条任务每日可领取+已完成总次数上限
        //     cost:1000,//领取该条任务时需要消耗的任务券数量
        //     reachs:[1],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:100//该条任务达成之后的奖品数量
        // },
        // {
        //     index:1,
        //     isOpen:1,
        //     des:"这是任务的说明1",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 3,      
        //     cost:5000,
        //     reachs:[3],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:500
        // },
        // {
        //     index:2,
        //     isOpen:1,
        //     des:"这是任务的说明2",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 10,      
        //     cost:10000,
        //     reachs:[1],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:1050
        // },
        // {
        //     index:3,
        //     isOpen:1,
        //     des:"这是任务的说明3",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 5,      
        //     cost:50000,
        //     reachs:[2],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:5500
        // },
        // {
        //     index:4,
        //     isOpen:1,
        //     des:"这是任务的说明4",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 2,      
        //     cost:10000,
        //     reachs:[4],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:1000
        // },
        // {
        //     index:5,
        //     isOpen:1,
        //     des:"这是任务的说明5",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 1,      
        //     cost:50000,
        //     reachs:[5],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:5000
        // },
        // {
        //     index:6,
        //     isOpen:1,
        //     des:"这是任务的说明6",
        //     sTime: 1676044800000,     
        //     eTime: 1785513600000, 
        //     times: 1,      
        //     cost:100000,
        //     reachs:[7],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
        //     reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        //     rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        //     rewards:10000
        // }
        //上面是原来的那套任务系统
        {
            index:0,//该条任务编号
            isOpen:1,//该条任务是否开放0：不开放，1：开放
            des:"0消耗1千要求1个大苹果奖0.5钻10次",//该条任务说明
            sTime: 1676044800000,//该条任务开始时间
            eTime: 1785513600000,//该条任务结束时间  
            times: 10,//该条任务每日可领取+已完成总次数上限
            cost:1000,//领取该条任务时需要消耗的任务券数量
            reachs:[0],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:0.5//该条任务达成之后的奖品数量
        },
        {
            index:1,
            isOpen:1,
            des:"1消耗1万要求1个大橙子奖5钻10次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 10,      
            cost:10000,
            reachs:[1],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:5
        },
        {
            index:2,
            isOpen:1,
            des:"2消耗5万要求1个大芒果奖25钻5次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 5,      
            cost:50000,
            reachs:[2],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:1,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:25
        },
        {
            index:3,
            isOpen:1,
            des:"3消耗5千要求2个大苹果奖5元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:5000,
            reachs:[0],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:500
        },
        {
            index:4,
            isOpen:1,
            des:"4消耗5千要求3个大苹果奖5元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:5000,
            reachs:[0],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[3],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:500
        },
        {
            index:5,
            isOpen:1,
            des:"5消耗5千要求4个大苹果奖5元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:5000,
            reachs:[0],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[4],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:500
        },
        {
            index:6,
            isOpen:1,
            des:"6消耗1万要求2个大芒果奖10元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:10000,
            reachs:[2],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:1000
        },
        {
            index:7,
            isOpen:1,
            des:"7消耗1万要求3个大芒果奖10元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:10000,
            reachs:[2],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[3],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:1000
        },
        {
            index:8,
            isOpen:1,
            des:"8消耗2万要求2个大橙子奖20元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:20000,
            reachs:[1],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:2000
        },
        {
            index:9,
            isOpen:1,
            des:"9消耗3万要求1个大铃铛奖30元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:30000,
            reachs:[3],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:3000
        },
        {
            index:10,
            isOpen:1,
            des:"10消耗4万要求1个大西瓜奖40元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:40000,
            reachs:[4],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:4000
        },
        {
            index:11,
            isOpen:1,
            des:"11消耗5万要求1个大星星奖50元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:50000,
            reachs:[5],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:5000
        },
        {
            index:12,
            isOpen:1,
            des:"12消耗6万要求1个大七七奖60元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:60000,
            reachs:[6],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[1],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:6000
        },
        {
            index:13,
            isOpen:1,
            des:"12消耗7万要求2个大铃铛奖70元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:70000,
            reachs:[3],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:7000
        },
        {
            index:14,
            isOpen:1,
            des:"12消耗8万要求2个大西瓜奖80元1次",
            sTime: 1676044800000,     
            eTime: 1785513600000, 
            times: 1,      
            cost:80000,
            reachs:[4],//达成该条任务所需的条件列表[1(1号牌),2(出现2次)]
            reachC:[2],//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt:2,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards:8000
        }
    ]
};

// 导出类
module.exports = Logic;

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

// 填充数组
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.getIsAJsonStr = function (str) {
    // console.warn("判断的是否是JSON字符串。  "+str);
    if (typeof str == 'string') {
        try {
            var obj = JSON.parse(str);
            if (typeof obj == 'object' && obj) {
                return true;
            } else {
                //不是就返回false
              return false;
            }
        } 
        catch (e) {
            return false;
        }
    }
    return false;
}
//////TL++ 深复制一个object类型的数据
proto.deepCloneTL2 = function (objArr){
    let objClone = null;
    // console.warn(".............?????????000  ");
    if(Array.isArray(objArr)){
        objClone = []
        for (var i = 0; i < objArr.length; i++) {
            let jsStr = JSON.stringify(objArr[i]);
            if(this.getIsAJsonStr(jsStr)){
                let xi = JSON.parse(jsStr);
                objClone[objClone.length] = xi;
            }
        }
    }
    return objClone;
};


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

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

// 获取一张发牌
proto.getASendCard = function (isSendFirst) {
    if(isSendFirst){
        //是首次发牌，下面这种写法是整副牌随机发牌
        let ra = Math.floor(Math.random()*1000);//[0,999]
        for (var i = 0; i < this.fpqjList.length; i++) {
            // console.warn("?????????????   "+i+"   "+this.fpqjList[i]+"   "+this.fpqjList[i+1]);
            if(i == 0){
                if(ra >= 0 && ra < this.fpqjList[i]){
                    return i;
                }
            }
            else{
                if(ra >= this.fpqjList[i-1] && ra < this.fpqjList[i]){
                    return i;
                }
            }
        }
        console.error("首次发牌出错了  ra  "+ra+"   "+JSON.stringify(this.fpqjList));
    }
    else{
        //不是首次发牌，下面这种写法是整副牌中符合条件的牌中随机发牌
        let ra = Math.floor(Math.random()*1000);//[0,999]
        for (var i = 0; i < this.fpqjList.length; i++) {
            // console.warn("?????????????   "+i+"   "+this.fpqjList[i]+"   "+this.fpqjList[i+1]);
            if(i == 0){
                if(ra >= 0 && ra < this.fpqjList[i]){
                    return i;
                }
            }
            else{
                if(ra >= this.fpqjList[i-1] && ra < this.fpqjList[i]){
                    return i;
                }
            }
        }
        console.error("非首次发牌出错了  ra  "+ra+"   "+JSON.stringify(this.fpqjList));
    }
    return -1
};

// 获取发牌结果数组
proto.getSendCards = function (yazhus,adjust) {
    let cards = [];
    cards[0] = this.getASendCard(true);
    if(adjust == 1 || adjust == 2) {
        let newC = this.getAdjustCard(yazhus,adjust);
        console.error("在此调控发牌了    ",cards[0] , newC,adjust);
        cards[0] = newC;
    }

    // let sjs = Math.floor(Math.random()*5);//[0,5]
    // let sjs2 = Math.floor(Math.random()*3);//[0,2]
    // if(sjs == 1) cards[0] = 9;
    // else if(sjs == 2) cards[0] = 21;
    // else if(sjs == 3) cards[0] = sjs2+24;
    // else if(sjs == 4) cards[0] = 2+sjs2%2;
    // // cards[0] = 9;//this.over-1;//设置发牌，正式时记得删除
    
    let tspx = 0;//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
    if(cards[0] > 23){
        if(cards[0] == 24) tspx = 1;
        else if(cards[0] == 25) tspx = 2;
        else if(cards[0] == 26) tspx = 3;
        cards[0] = Math.floor(Math.random()*2) > 0 ? 9 : 21;
        // console.warn("出特殊牌型了  ",tspx);
    }
    // console.warn("获取发牌结果数组  "+JSON.stringify(cards));
    // let sjs = Math.floor(Math.random()*5);//[0,4]
    // if(sjs <= 1) cards[0] = 9;
    // else if(sjs == 2) cards[0] = 21;
    // cards[0] = 9;//this.over-1;//设置发牌，正式时记得删除
    let addSendCounts = 0;//需要额外发牌的总张数

    if(cards[0] == 9 || cards[0] == 21){
        //此刻需要发多张牌
        if(tspx == 0) {
            let zssjs = Math.floor(Math.random()*100)+1;//[0,4]
            if(zssjs > 90) addSendCounts = 4;//5%的概率送4张
            else if(zssjs > 80) addSendCounts = 3;//20%的概率送3张
            else if(zssjs > 70) addSendCounts = 2;//35%的概率送2张
            else if(zssjs > 10) addSendCounts = 1;//35%的概率送1张
            else if(zssjs > 0) addSendCounts = 0;//5%的概率送0张
        }
        else if(tspx == 1 || tspx == 2) addSendCounts = 3;
        else if(tspx == 3) addSendCounts = 4;
    }

    if(tspx == 0){
        for (var i = 0; i < addSendCounts; i++) {
            let zfdp = this.getASendCard(false);//幸运之后增发的牌不能是小三元这种特殊牌
            let ishf = true;
            if(zfdp == 9 || zfdp == 21) ishf = false;//幸运之后增发的牌不能是幸运牌
            if(zfdp >= this.cardsPool.length) ishf = false;//幸运之后增发的牌不能是小三元这种特殊牌
            if(ishf) cards[cards.length] = zfdp;
        }
    }
    else if(tspx == 1) { //小三元"（橘子，芒果，铃铛）,
        let xsy = [];
        xsy[0] = Math.floor(Math.random()*2) > 0 ? 0 : 12;
        xsy[1] = Math.floor(Math.random()*2) > 0 ? 1 : 13;
        xsy[2] = Math.floor(Math.random()*2) > 0 ? 6 : 18;
        cards = cards.concat(xsy);//小三元"（橘子，芒果，铃铛）,
    }
    else if(tspx == 2) cards = cards.concat([7,15,19]);//大三元"（西瓜，双星，77）,
    else if(tspx == 3) cards = cards.concat([4,10,16,22]);//大四喜"（4个大苹果 ） 
    // console.warn("发牌结果  "+JSON.stringify(cards));
    // let csp = [
    //     [9,2,5,8,11],
    //     [9,0,1,3,4],
    //     [9,2,5,8],
    //     [9,0,1,3],
    // ]
    // let sj = Math.floor(Math.random()*4);//[0,3]
    // cards = csp[sj];

    // cards = [9,16,22,5];
    // 设置手牌的地方
    // tspx = 0;
    return {
        tspx:tspx,//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
        cards:_.uniq(cards)
    }
};

//调控牌
proto.getAdjustCard = function (yazhus,adjust) {
    let yzdm = [];//押注的门
    for (var i = 0; i < yazhus.length; i++) {
        if(yazhus[i]) yzdm[yzdm.length] = i;
    }
    let wyzdp = [];//未押中的牌
    let yyzdp = [];//已押中的牌
    for (var i = 0; i < this.cardsPool.length; i++) {
        let xzdyxb = this.cardsPool[i][3];//下注对应下标
        if(xzdyxb == 8) continue;//调控时不发幸运牌
        if(yzdm.indexOf(xzdyxb) == -1) wyzdp[wyzdp.length] = this.cardsPool[i][0];
        else yyzdp[yyzdp.length] = this.cardsPool[i][0];
    }
    // console.warn("  wyzdp   yyzdp   ",wyzdp,yyzdp);
    if(adjust == 1) {//牌调小(在未押中的牌里面随机挑一张)
        if(wyzdp.length == 0) {
            for (var i = 0; i < this.xpPool.length; i++) {
                if(this.xpPool[i] == 2) continue;//小王不参与牌调小时候的发牌
                wyzdp[wyzdp.length] = this.xpPool[i];
            }
        }
        wyzdp = _.shuffle(wyzdp);////随机打乱一个数组
        // console.warn("  wyzdp   this.xpPool   ",wyzdp,this.xpPool);
        return wyzdp[0];
    }
    else if(adjust == 2) {//牌调大(在他押的牌里面随机找个大的给他)
        let xyyzdp = [];
        for (var i = 0; i < yyzdp.length; i++) {
            if(this.dpPool.indexOf(yyzdp[i]) != -1){
               xyyzdp[xyyzdp.length] = yyzdp[i];
            }
        }
        if(xyyzdp.length == 0){
            console.error("tiaop出错了111 ",xyyzdp);
            xyyzdp = _.cloneDeep(yyzdp);
        }
        xyyzdp = _.shuffle(xyyzdp);////随机打乱一个数组
        // console.warn("  xyyzdp   this.dpPool   ",xyyzdp,this.dpPool);
        return xyyzdp[0];
    }
    console.error("tiaop出错了222 ");
    return -1;
}
//得到本局发牌的倍数信息  因为下面这个规则增加的这个方法
//大橙子大芒果大铃铛这三个在10，15，20中随机取倍数  大西瓜大星星大七七这三个在20，30，40中随机取倍数
//转到幸运的时候倍数灯就停了，幸运之后的大橙子大芒果大铃铛大西瓜大星星大七七这6个均按照luck时的倍数
proto.getBeiShuInfo = function (cards,adjust) {
    let bsIndex = Math.floor(Math.random()*3);//倍数下标[0,2]
    if(adjust == 3 || adjust == 4) console.error("在此调控倍数了    ",adjust , bsIndex);
    if(adjust == 3) bsIndex = 0;//倍数调小
    else if(adjust == 4) bsIndex = 2;//倍数调大
    return bsIndex;
    // let res = {
    //     beishus:[],//本次发牌对应的倍数
    //     bsIndexs:[]//本次发牌对应的倍数下标
    // }
    // let bsindex = Math.floor(Math.random()*4);//倍数下标[0,3]
    // for (var i = 0; i < cards.length; i++) {
    //     if(this.xbsps.indexOf(cards[i]) != -1){
    //         res.beishus[i] = this.xbss[bsindex];
    //         res.bsIndexs[i] = bsindex;
    //     }
    //     else if(this.dbsps.indexOf(cards[i]) != -1){
    //         res.beishus[i] = this.dbss[bsindex];
    //         res.bsIndexs[i] = bsindex;
    //     }
    //     else {
    //         res.beishus[i] = -1;
    //         res.bsIndexs[i] = -1;
    //     }
    // }
    // return res;
};

// 初始手牌
proto.handCards = function (yazhus,over,mqdw,jcPools,ownerUid) {
    // console.warn("初始手牌");
    this.over = over;
    var result = {
        cards: [],//本次的发牌
        tspx: 0,//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
        bsIndex:-1,//本次发牌对应的倍数下标
        bcfpdydyzxbs:[],//本次发牌对应的押注下注下标
        zjdypxbs:[],//这局结果对应的牌值列表，用于计算获得列表判断任务
        winList:[],//本局各门赢得列表
        xxydList:[],//本局详细赢得列表（按照苹果举例，上面是大苹果和小苹果赢得总和，这个是大苹果和小苹果分别赢得的）
        win:0//本次赢的分数
    };
    let adjust = this.getAdjust(mqdw,jcPools);
    let uids = [100171,100202,100464,100465];
    let intownerUid = parseInt(ownerUid) || 0;
    let xbs = uids.indexOf(intownerUid);
    console.warn("??????????????===============  ",ownerUid == 100171,typeof ownerUid, adjust,ownerUid,xbs,(uids.indexOf(ownerUid) != -1));
    if(adjust >= 0 && xbs != -1){
        let sjs = Math.floor(Math.random()*100) + 1;//[1,100]
        if(sjs <= 45){
            let sjs2 = Math.floor(Math.random()*2) + 1;//[1,100]
            if(sjs2 == 1) adjust = 1;
            else adjust = 3;
            console.warn("cccccccyyyyyyyytttttttkkkkkk ",ownerUid,adjust);
        }
    }
    let cardRes = this.getSendCards(yazhus,adjust);//本局发牌的倍数信息
    result.cards = cardRes.cards;//本次发牌
    result.tspx = cardRes.tspx;//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
    // result.cards[0] = Math.floor(Math.random()*this.cardAllCount);////// 区间[0,cardAllCount-1]取整数
    result.bsIndex = this.getBeiShuInfo(result.cards,adjust);
    let cardsInfos = [];//本局的发牌信息
    let zjdyzxbs = [];//这局结果对应的押注列表下标，用于计算押注列表中每门押注是否压中
    let zjdyzxbs2 = [];//这局结果对应的牌类型下标 用于计算区分大苹果小苹果赢得的分
    let zjdypxbs = [];//这局结果对应的牌值列表，用于计算获得列表判断任务[[牌值列表1，牌值列表1对应的个数]，[牌值列表2，牌值列表2对应的个数]]
    //例如发牌结果=[9,16,22,5](幸运运，大苹果，大苹果，小苹果)时，则 zjdyzxbs = [8,0,0,0] zjdyzxbs2=[8,0,0,9] zjdypxbs = [[8,1],[0,2],[9,1]]
    // console.warn("???????=====   ",result.cards);
    for (var i = 0; i < result.cards.length; i++) {
        cardsInfos[cardsInfos.length] = this.cardsPool[result.cards[i]]
        if(this.xbsps.indexOf(result.cards[i]) != -1){
            //这张牌是小倍率的牌
            cardsInfos[cardsInfos.length-1][2] = this.xbss[result.bsIndex];
        }
        else if(this.dbsps.indexOf(result.cards[i]) != -1){
            //这张牌是大倍率的牌
            cardsInfos[cardsInfos.length-1][2] = this.dbss[result.bsIndex];
        }
        zjdyzxbs[zjdyzxbs.length] = this.cardsPool[result.cards[i]][3];
        let pk = this.cardsPool[result.cards[i]][3];//牌类型
        let pz = result.cards[i];//牌值
        if(pz == 5) pk = 9;//小苹果
        else if(pz == 11) pk = 10;//小橙子
        else if(pz == 17) pk = 11;//小芒果
        else if(pz == 23) pk = 12;//小铃铛
        else if(pz == 8) pk = 13;//小西瓜
        else if(pz == 20) pk = 14;//小星星
        else if(pz == 14) pk = 15;//小七七
        else if(pz == 2) pk = 16;//小王王
        let czxb = -1;//pk存在的下标
        for (var j = 0; j < zjdypxbs.length; j++) {
            if(zjdypxbs[j][0] == pk){
                czxb = j;
                break;
            }
        }
        if(czxb >= 0) zjdypxbs[czxb][1]++;
        else zjdypxbs[zjdypxbs.length] = [pk,1];
        zjdyzxbs2[zjdyzxbs2.length] = pk;
    }
    result.bcfpdydyzxbs = zjdyzxbs;//本次发牌对应的押注下注下标
    result.zjdypxbs = zjdypxbs;//这局结果对应的牌值列表，用于计算获得列表判断任务
    // console.warn("发牌函数  本局发的牌  "+JSON.stringify(result.cards)+"  牌的详细信息  "+JSON.stringify(cardsInfos));
    // console.warn("发牌函数  这局结果对应的押注列表下标 "+JSON.stringify(zjdyzxbs)+"  这局结果对应的牌值列表 "+JSON.stringify(zjdypxbs));
    let xxydList = [];//本局详细赢得列表（按照苹果举例，上面是大苹果和小苹果赢得总和，这个是大苹果和小苹果分别赢得的）
    for (var i = 0; i < yazhus.length; i++) {
        let bmyzsy = 0;//本局游戏玩家押注列表中本门押注赢的分数
        if(yazhus[i]){
            let xb = zjdyzxbs.indexOf(i);
            if(xb != -1){
                //至此该下注下标i已经下注并且已押中，
                let bs = 0;//倍数
                for (var j = 0; j < zjdyzxbs.length; j++) {
                    if(i == zjdyzxbs[j]) {
                        bs += cardsInfos[j][2];//本次发牌的详细信息中第j张押中了
                    }
                }
                if(bs < 1) console.error("算分这里出错了 ",bs,yazhus[i],zjdyzxbs);
                //押注列表中本门押中了
                let bmydfs = yazhus[i] * bs;//本门赢得分数
                // console.warn("发牌函数  押注列表中下标 "+i+"  门押中了 获奖 "+bmydfs);
                bmyzsy += bmydfs;

                //下面是分别计算大苹果小苹果赢得的分数
                let dbs = 0;//大水果倍数
                let xbs = 0;//小水果倍数
                for (var j = 0; j < zjdyzxbs2.length; j++) {
                    if(i == zjdyzxbs2[j]){
                        dbs += cardsInfos[j][2];
                    }
                    if(i + 9 == zjdyzxbs2[j]){
                        xbs += cardsInfos[j][2];
                    }
                }
                if(dbs > 0){
                    let bmddydfs = yazhus[i] * dbs;//本门大的赢得分数
                    xxydList[xxydList.length] = [i,bmddydfs];
                }
                if(xbs > 0){
                    let bmxdydfs = yazhus[i] * xbs;//本门小的赢得分数
                    xxydList[xxydList.length] = [i+9,bmxdydfs];
                }
            }
        }
        result.winList[i] = bmyzsy;
        // console.warn("发牌函数  本局结果赢的列表 "+i+"   "+bmyzsy);
    }
    result.xxydList = xxydList;
    result.win = _.sum(result.winList)
    // console.warn("发牌函数  结果 "+JSON.stringify(result));
    return result;
};

//////得到目前挡位
proto.getMQDW = function (bczxz,level){
    // console.warn("得到目前挡位  ",bczxz,level,level.length);
    let dqdw = -1;
    for (var i = level.length - 1; i >= 0 ; i--) {
        // console.warn("得到目前挡位----  ",i,bczxz,level[i]);
        if(bczxz >= level[i]){
            // console.warn("得到目前挡位?????  ",i);
            dqdw = i;
            break;
        }
    }
    return dqdw;
}

//////得到调控信息，0不调，1牌调小，2牌调大，3倍数调小，4倍数调大
proto.getAdjust = function (mqdw,jcPools){
    // console.warn("得到调控信息  ",mqdw,jcPools);
    if(!jcPools) return 0;//没有奖池信息
    if(mqdw < 0 || mqdw >= jcPools.pools.length) return 0;//挡位不合法
    let mqdwcsz = jcPools.cspools[mqdw];//目前挡位初始值
    let mqdwxzz = jcPools.pools[mqdw];//目前挡位现在值
    let mqdwsx1 = jcPools.topLimits1[mqdw];//目前挡位上限值1
    let mqdwxx1 = jcPools.lowLimits1[mqdw];//目前挡位下限值1
    if(mqdwxzz < mqdwsx1 && mqdwxzz > mqdwxx1) return 0;//目前该挡位奖池合理不需要调控
    let tkType = 0;//调控类型。0：不调控，1：调小，2：调大
    if(mqdwxzz >= mqdwsx1) tkType = 2;
    else if(mqdwxzz <= mqdwxx1) tkType = 1;
    if(tkType == 0){
        console.error("判断出错了 ",mqdw,jcPools);
        return 0;
    }
    let tkqj = [];//调控区间[调牌比例，调倍率比例]
    let sjs = Math.floor(Math.random()*100) + 1;//[1,100]
    if(tkType == 1){//调小
        let tkdw = -1;
        if(mqdwxzz <= jcPools.lowLimits3[mqdw]) tkdw = 2;
        else if(mqdwxzz <= jcPools.lowLimits2[mqdw]) tkdw = 1;
        else if(mqdwxzz <= jcPools.lowLimits1[mqdw]) tkdw = 0;
        if(tkdw < 0){
            console.error("判断出错了111 ",mqdw,jcPools);
            return 0;
        }
        let qjc = [//区间池
            [jcPools.paiLowRate1[mqdw],jcPools.bsLowRate1[mqdw]],
            [jcPools.paiLowRate2[mqdw],jcPools.bsLowRate2[mqdw]],
            [jcPools.paiLowRate3[mqdw],jcPools.bsLowRate3[mqdw]]
        ];//区间池
        tkqj = [qjc[tkdw][0],qjc[tkdw][0]+qjc[tkdw][1]];
        if(sjs > tkqj[1]) return 0;
        else if(sjs > tkqj[0]) return 3;//倍数调小
        else return 1;//牌调小
    }
    else if(tkType == 2){//调大
        let tkdw = -1;
        if(mqdwxzz >= jcPools.topLimits3[mqdw]) tkdw = 2;
        else if(mqdwxzz >= jcPools.topLimits2[mqdw]) tkdw = 1;
        else if(mqdwxzz >= jcPools.topLimits1[mqdw]) tkdw = 0;
        if(tkdw < 0){
            console.error("判断出错了222 ",mqdw,jcPools);
            return 0;
        }
        let qjc = [
            [jcPools.paiTopRate1[mqdw],jcPools.bsTopRate1[mqdw]],
            [jcPools.paiTopRate2[mqdw],jcPools.bsTopRate2[mqdw]],
            [jcPools.paiTopRate3[mqdw],jcPools.bsTopRate3[mqdw]]
        ];//区间池
        tkqj = [qjc[tkdw][0],qjc[tkdw][0]+qjc[tkdw][1]];
        if(sjs > tkqj[1]) return 0;
        else if(sjs > tkqj[0]) return 4;//倍数调大
        else return 2;//牌调大
    }
    console.error("判断出错了333 ",mqdw,jcPools);
    return 0
}

//TL++,得到今日0点的时间戳
proto.getTodaySJC = function (){
    var today = new Date();
    today.setHours(0);
    today.setMinutes(0);
    today.setSeconds(0);
    today.setMilliseconds(0);
    let jrsjc = today.getTime();
    // console.warn("111得到今日0点的时间戳   ",jrsjc, typeof jrsjc);
    return jrsjc;
};

//得到是否一样的任务
proto.getIsSameRW = function (info,item){
    let isSame = true;
    if(info.cost != item.cost) isSame = false;
    if(isSame && info.rewardt != item.rewardt) isSame = false;
    if(isSame && info.rewards != item.rewards) isSame = false;
    if(isSame && !this.getListIsSame(info.reachs,item.reachs)){
        isSame = false;//任务完成要求类型不一致
    }
    if(isSame && !this.getListIsSame(info.reachC,item.reachC)){
        isSame = false;//任务完成要求个数不一致
    }
    return isSame;
};
//////得到水果玩家今日任务池信息（为了实现每个玩家每天的任务随机）只在玩家每天第一次打开任务面板的时候执行
proto.getWJJRRWC = function (_ylrwList,klqhbjl){
    // console.warn("得到水果玩家今日任务池信息  ",klqhbjl,_ylrwList);
    let ylrwListOld = this.deepCloneTL2(_ylrwList);
    //_ylrwList数组元素中有_id属性但是SGJRWCItemchema结构中没有这个字段，所以在保存数据库时会出错，为了不出错就要删除_id
    let ylrwList = [];
    for (var i = 0; i < ylrwListOld.length; i++) {
        let xi = ylrwListOld[i];
        if(xi.hasOwnProperty('_id')){
            delete xi._id
        }
        ylrwList[ylrwList.length] = xi;
    }
    
    // console.warn("得到水果玩家今日任务池信息222  ",klqhbjl,ylrwList,_ylrwList);
    let syklqhbjl = klqhbjl;//玩家剩余可领红包奖励
    let jlzsrwxbs = [];//当前任务池奖励钻石的任务下标
    let jlhbrwxbs = [];//当前任务池奖励红包的任务下标
    for (var i = 0; i < this.renwuPool.length; i++) {
        if(this.renwuPool[i].rewardt == 1) jlzsrwxbs[jlzsrwxbs.length] = i;
        else if(this.renwuPool[i].rewardt == 2) jlhbrwxbs[jlhbrwxbs.length] = i;
    }
    let ylzsrwList = [];//已领钻石任务在当前任务池下标列表
    let ylhbrwList = [];//已领红包任务在当前任务池下标列表
    let ylhbrwList2 = [];//未领奖红包任务在当前任务池下标列表
    let resZSRWS = [];//该玩家已领但是不在当前任务池中的钻石任务池
    let resHBRWS = [];//该玩家已领但是不在当前任务池中的红包任务池
    for (var i = 0; i < ylrwList.length; i++) {
        let item = ylrwList[i];
        let btylrwzrwczdxb = -1;//本条已领任务在目前任务池中的下标，=-1时表示不在任务池当中
        for (var j = 0; j < this.renwuPool.length; j++) {
            let info = this.renwuPool[j];
            if(this.getIsSameRW(info,item)){
                btylrwzrwczdxb = j;
                break;
            }
        }
        if(btylrwzrwczdxb < 0){//本条已领任务不在任务池当中
            //因为任务列表当中已经没有这条任务了，所以重置这条任务的index和可领取次数
            let newitem = item;
            newitem.index = -1;
            newitem.times = 1;
            if(item.rewardt == 1) resZSRWS[resZSRWS.length] = newitem;
            else if(item.rewardt == 2) resHBRWS[resHBRWS.length] = newitem;
        }
        else{//本条已领任务还在任务池当中
            if(item.rewardt == 1) {
                ylzsrwList[ylzsrwList.length] = btylrwzrwczdxb;
            }
            else if(item.rewardt == 2) {
                ylhbrwList[ylhbrwList.length] = btylrwzrwczdxb;
                if(item.state < 3){
                    ylhbrwList2[ylhbrwList2.length] = btylrwzrwczdxb;
                }
            }
        }

    }
    // console.warn("玩家已领但不在任务池中的任务  ",resZSRWS,resHBRWS);
    // console.warn("已领任务在当前任务池下标列表  ",ylzsrwList,ylhbrwList);
    let zsrwmbgs = 3;//钻石任务目标个数
    let hbrwmbgs = 5;//红包任务目标个数
    if(resZSRWS.length + ylzsrwList.length < zsrwmbgs){
        for (var i = 0; i < jlzsrwxbs.length; i++) {
            if(resZSRWS.length + ylzsrwList.length >= zsrwmbgs) break;//每天展示3条红包任务
            if(ylzsrwList.indexOf(jlzsrwxbs[i]) == -1){
                ylzsrwList[ylzsrwList.length] = jlzsrwxbs[i];
            }
        }
    }
    let ylhbrwklhbs = 0;//已领红包任务可领红包数
    for (var i = 0; i < resHBRWS.length; i++) {
        if(resHBRWS[i].rewardt == 2) ylhbrwklhbs += resHBRWS[i].rewards;
    }
    for (var i = 0; i < ylhbrwList2.length; i++) {
        let item = this.renwuPool[ylhbrwList2[i]];
        if(item.rewardt == 2) ylhbrwklhbs += item.rewards;
    }
    let syklhbrwhbs = syklqhbjl - ylhbrwklhbs;//剩余可领红包任务的红包数
    // console.warn("总可领红包数   "+ syklqhbjl+"  已领任务可领红包数  "+ylhbrwklhbs+"  剩余可领红包数  "+syklhbrwhbs);
    let xybcdhbrwxb = [];//需要补充的红包任务下标
    if(syklhbrwhbs > 0){
        jlhbrwxbs = _.shuffle(jlhbrwxbs);////随机打乱一个数组
        // console.warn("得到水果玩家今日任务池信息大乱之后    ",klqhbjl,jlhbrwxbs);
        if(resHBRWS.length + ylhbrwList.length < hbrwmbgs){
            let xybcdhbrws = [];//需要补充的红包任务[[下标,红包数额]]
            let xybchbzse = 0;//需要补充红包总数额
            for (var i = 0; i < jlhbrwxbs.length; i++) {
                if(resHBRWS.length + ylhbrwList.length + xybcdhbrws.length>= hbrwmbgs) break;//每天展示3条红包任务
                if(ylhbrwList.indexOf(jlhbrwxbs[i]) == -1){
                    let ghbse = this.renwuPool[jlhbrwxbs[i]].rewards;//该红包数额
                    xybchbzse += ghbse;
                    xybcdhbrws[xybcdhbrws.length] = [jlhbrwxbs[i],ghbse];
                }
            }
            // console.warn("需要补充的红包任务  ",xybchbzse,xybcdhbrws);
            if(syklhbrwhbs >= xybchbzse){
                for (var i = 0; i < xybcdhbrws.length; i++) {
                    xybcdhbrwxb[xybcdhbrwxb.length] = xybcdhbrws[i][0];
                }
            }
            else{
                //补充的红包任务的总红包数额太大，需要按照额度大小进行剔除
                let pxzh = xybcdhbrws.sort((a,b) =>{return a[1] - b[1]})//按照红包数额排序
                // console.warn("按照红包数额排序  ",xybcdhbrws,pxzh);
                for (var i = 0; i < xybcdhbrws.length; i++) {
                    if(syklhbrwhbs > xybcdhbrws[i][1]){
                        syklhbrwhbs-= xybcdhbrws[i][1];
                        xybcdhbrwxb[xybcdhbrwxb.length] = xybcdhbrws[i][0];
                    }
                }
                // console.warn("需要补充的红包任务下标  ",syklhbrwhbs,xybcdhbrwxb);
                // if(xybcdhbrwxb.length > 0) syklhbrwhbs = _.shuffle(syklhbrwhbs);////随机打乱一个数组
            }
        }
    }
    ylhbrwList = ylhbrwList.concat(xybcdhbrwxb);//总的红包任务下标数组=已领红包任务下标数组 拼接 补充红包任务下标数组
    // console.warn("已领任务在当前任务池下标列表  ",ylzsrwList,ylhbrwList);
    let allres = resZSRWS.concat(resHBRWS);
    let allxbs = ylzsrwList.concat(ylhbrwList);
    //for (var i = 0; i < allxbs.length; i++) {
    for (var i = 0; i < 3; i++) {
        let info = this.renwuPool[allxbs[i]];
        let item = {
            index: info.index,  //该条任务编号
            des: info.des,   // 任务描述
            times: info.times,  //该条任务今日可领总次数
            cost: info.cost, // 该条任务需要的消耗
            reachs: _.cloneDeep(info.reachs),   //达成该条任务所需的条件列表[1(1号牌),2(2号牌)]]
            reachC: _.cloneDeep(info.reachC),   //达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
            rewardt: info.rewardt,  //该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
            rewards: info.rewards,  //该条任务达成之后的奖品数量
        }
        allres[allres.length] = item;
    }
    // console.warn("今日该玩家任务列表  ",allres);
    return allres;
};

//////得到任务列表，以及获得每个任务已领次数
proto.getTasksInfo = function (ylList,rwPool){
    // console.warn("得到任务列表，以及获得每个任务已领次数  ",ylList,rwPool);
    // let res = this.deepCloneTL(this.renwuPool);
    let res = this.deepCloneTL2(rwPool);
    for (var i = 0; i < res.length; i++) {
        res[i]['ylcs'] = 0;//已领次数
        res[i]['wwccs'] = 0;//未完成次数
        res[i]['wccs'] = 0;//完成次数
        res[i]['fjzcs'] = 0;//发奖中次数
        res[i]['yljcs'] = 0;//已领奖次数
        let info = res[i];
        for (var j = 0; j < ylList.length; j++) {
            let item = ylList[j];
            // console.warn("得到任务列表，以及获得每个任务已领次数 ",i,JSON.stringify(info),JSON.stringify(item));
            let isSame = this.getIsSameRW(info,item);
            if(isSame) {
                // console.warn("让你无找到了");
                res[i].ylcs++;
                if(item.state == 0) res[i].wwccs++;
                if(item.state == 1) res[i].wccs++;
                if(item.state == 2) res[i].fjzcs++;
                if(item.state == 3) res[i].yljcs++;
            }
        }
    }
    // console.warn("得到任务列表，返回  ",res);
    return res;
};

//////某个任务最多领取次数
proto.getATaskAllCount = function (item,_alltasks){
    let alltasks = this.renwuPool
    if(_alltasks) alltasks = _alltasks
    let targetInfo = null;//目标任务信息
    for (var i = 0; i < alltasks.length; i++) {
        let info = alltasks[i];
        let isSame = this.getIsSameRW(info,item);
        if(isSame) {
            targetInfo = info;
            break;
        }
    }
    if(!targetInfo){
        //没有找到目标任务的配置，基本上是因为任务配置更新了导致玩家点击的任务在目前任务配置中不存在了
        return {count:-1,msg:"未找到目标任务"};
    }
    //至此目标任务存在
    // if(targetInfo.sTime >= targetInfo.eTime) {
    //     return {count:-2,msg:"任务起始时间配置错误"};
    // }
    // if(!targetInfo.isOpen) {
    //     return {count:-3,msg:"任务目前处于未开放状态"};
    // }
    // let nowTime = Date.now();
    // if(nowTime < targetInfo.sTime) {
    //     return {count:-4,msg:"任务目前未开始领取"};
    // }
    // if(nowTime > targetInfo.eTime) {
    //     return {count:-5,msg:"任务目前已结束领取"};
    // }
    if(!(targetInfo.times > 0)) {
        return {count:0,msg:"任务可领取次数出错了"};
    }
    return {
        count:targetInfo.times,
        cost:targetInfo.cost,
        msg:"",
        des:targetInfo.des
    }; 
    // return targetInfo;
};


// 测试发牌
proto.testSendCards = function () {
    let csfpcs = 100000000;//测试发牌次数
    let res = [];//发牌结果
    let xyfdp = [];//幸运发的牌
    let tspxcs = [];
    for (var i = 0; i < csfpcs; i++) {
        let cardRes = this.getSendCards([],0);//本局发牌的倍数信息
        // console.warn("cardRes     ",cardRes);
        let cards = cardRes.cards;//本次发牌
        let tspx = cardRes.tspx;//本次特殊牌型类型
        // if(res[cards[0]]) res[cards[0]][1]++;
        // else res[cards[0]] = [cards[0],1];
        // if(cards.length > 0){
        //     //这把发的是幸运
        //     for (var j = 1; j < cards.length; j++) {
        //         if(xyfdp[cards[j]]) xyfdp[cards[j]][1]++;
        //         else xyfdp[cards[j]] = [cards[j],1];
        //     }
        // }

        if(tspx == 0){//普通发牌
            if(res[cards[0]]) res[cards[0]][1]++;
            else res[cards[0]] = [cards[0],1];
            if(cards.length > 0){
                //这把发的是幸运
                for (var j = 1; j < cards.length; j++) {
                    if(xyfdp[cards[j]]) xyfdp[cards[j]][1]++;
                    else xyfdp[cards[j]] = [cards[j],1];
                }
            }
        }
        if(tspx == 1){//小三元
            if(res[24]) res[24][1]++;
            else res[24] = [24,1];
        }
        if(tspx == 2){//大三元
            if(res[25]) res[25][1]++;
            else res[25] = [25,1];
        }
        if(tspx == 3){//大四喜
            if(res[26]) res[26][1]++;
            else res[26] = [26,1];
        }
    }
    // console.warn("测试发牌幸运的结果   "+JSON.stringify(xyfdp));
    let cszcs = 0;
    for (var i = 0; i < res.length; i++) {
        cszcs += res[i][1]
    }
    console.warn("测试发牌的结果   "+cszcs+"  次  "+JSON.stringify(res));
    
    console.warn("幸运发牌的结果   "+JSON.stringify(xyfdp));
    // let cxcsInfo = [];//出现次数合计信息
    // for (var i = 0; i < this.cardsPool.length; i++) {
    //     if(i == 9 || i == 21) {
    //         cxcsInfo[cxcsInfo.length] = res[i];
    //         continue;
    //     }
    //     let ptcs = res[i][1] || 0;//普通次数
    //     let xycs = xyfdp[i][1] || 0;//幸运次数
    //     let zcs = ptcs+xycs
    //     cxcsInfo[cxcsInfo.length] = [res[i][0],zcs]
    // }
    // console.warn("测试发牌合计之后的结果   "+JSON.stringify(cxcsInfo));
    let cxxq = [];//出现次数详情
    cxxq[0] = "100万次测试发牌中各个牌出现的次数"
    for (var i = 0; i < res.length; i++) {
        let ph = res[i][0];//牌号
        let cs = res[i][1];//出现次数
        let zb = cs * 100 / csfpcs; //所占百分比
        let name = "";
        if(i < 24) {
            name = this.cardsPool[ph][1];
        }
        else{
            if(i == 24) name = "小三元";
            else if(i == 25) name = "大三元";
            else if(i == 26) name = "小四喜";
        }
        cxxq[cxxq.length] = "" + ph + "号牌(" + name + ")出现了  " + cs + "  次,占比： " + zb + "  %";
    }
    // console.warn("测试发牌的出现详情   "+JSON.stringify(cxxq));
    console.warn("测试发牌的出现详情   ",cxxq);

    let xycxxq = [];//出现次数详情
    xycxxq[0] = "100万次幸运发牌中各个牌出现的次数"
    for (var i = 0; i < xyfdp.length; i++) {
        if(!xyfdp[i]) continue;
        let ph = xyfdp[i][0];//牌号
        let cs = xyfdp[i][1];//出现次数
        let zb = cs * 100 / csfpcs; //所占百分比
        let name = "";
        if(i < 24) {
            name = this.cardsPool[ph][1];
        }
        else{
            if(i == 24) name = "小三元";
            else if(i == 25) name = "大三元";
            else if(i == 26) name = "小四喜";
        }
        xycxxq[xycxxq.length] = "" + ph + "号牌(" + name + ")出现了  " + cs + "  次,占比： " + zb + "  %";
    }
    // console.warn("测试发牌的出现详情   "+JSON.stringify(xycxxq));
    console.warn("幸运发牌的出现详情   ",xycxxq);

    let zhzhlist = [];
    let pzlb = ["大苹果","大橙子","大芒果","大铃铛","大西瓜","大星星","大七七","大王王","幸运运","小苹果","小橙子","小芒果","小铃铛","小西瓜","小星星","小七七","小王王","小三元","大三元","大四喜"];
    for (var i = 0; i < pzlb.length; i++) {
        let name = pzlb[i];
        let cs = 0;
        if(i ==0) cs = res[4][1] + res[10][1] + res[16][1] + res[22][1];
        else if(i ==1) cs = res[0][1] + res[12][1];
        else if(i ==2) cs = res[6][1] + res[18][1];
        else if(i ==3) cs = res[1][1] + res[13][1];
        else if(i ==4) cs = res[7][1];
        else if(i ==5) cs = res[19][1];
        else if(i ==6) cs = res[15][1];
        else if(i ==7) cs = res[3][1];
        else if(i ==8) cs = res[9][1] + res[21][1];
        else if(i ==9) cs = res[5][1];
        else if(i ==10) cs = res[11][1];
        else if(i ==11) cs = res[17][1];
        else if(i ==12) cs = res[23][1];
        else if(i ==13) cs = res[8][1];
        else if(i ==14) cs = res[20][1];
        else if(i ==15) cs = res[14][1];
        else if(i ==16) cs = res[2][1];
        else if(i ==17) cs = res[24][1];
        else if(i ==18) cs = res[25][1];
        else if(i ==19) cs = res[26][1];
        zhzhlist[i] = [name,cs]
    }
    console.warn("测试发牌整合之后出现的次数1  ",zhzhlist);
    let xyzhzhlist = [];
    for (var i = 0; i < pzlb.length; i++) {
        // if(i == 8 ) continue;//|| i >= 17
        let name = pzlb[i];
        let cs = 0;
        if(i ==0) cs = xyfdp[4][1] + xyfdp[10][1] + xyfdp[16][1] + xyfdp[22][1];
        else if(i ==1) cs = xyfdp[0][1] + xyfdp[12][1];
        else if(i ==2) cs = xyfdp[6][1] + xyfdp[18][1];
        else if(i ==3) cs = xyfdp[1][1] + xyfdp[13][1];
        else if(i ==4) cs = xyfdp[7][1];
        else if(i ==5) cs = xyfdp[19][1];
        else if(i ==6) cs = xyfdp[15][1];
        else if(i ==7) cs = xyfdp[3][1];
        else if(i ==8) {//cs = xyfdp[9][1] + xyfdp[21][1];
            if(xyfdp[9]) cs += xyfdp[9][1];
            if(xyfdp[21]) cs += xyfdp[21][1]
        }
        else if(i ==9) cs = xyfdp[5][1];
        else if(i ==10) cs = xyfdp[11][1];
        else if(i ==11) cs = xyfdp[17][1];
        else if(i ==12) cs = xyfdp[23][1];
        else if(i ==13) cs = xyfdp[8][1];
        else if(i ==14) cs = xyfdp[20][1];
        else if(i ==15) cs = xyfdp[14][1];
        else if(i ==16) cs = xyfdp[2][1];
        else if(i ==17 && xyfdp[24]) cs = xyfdp[24][1];
        else if(i ==18 && xyfdp[25]) cs = xyfdp[25][1];
        else if(i ==19 && xyfdp[26]) cs = xyfdp[26][1];
        xyzhzhlist[i] = [name,cs]
    }
    console.warn("幸运发牌整合之后出现的次数1  ",xyzhzhlist);
}
// 测试发牌
// proto.testSendCards2 = function () {
//     let csfpcs = 1000000;//测试发牌次数
//     let res = [];//发牌结果
//     let xyfdp = [];//幸运发的牌
//     for (var i = 0; i < csfpcs; i++) {
//         let cardRes = this.getSendCards([],0);//本局发牌的倍数信息
//         let cards = cardRes.cards;//本次发牌
//         if(res[cards[0]]) res[cards[0]][1]++;
//         else res[cards[0]] = [cards[0],1];
//         if(cards.length > 0){
//             //这把发的是幸运
//             for (var j = 1; j < cards.length; j++) {
//                 if(xyfdp[cards[j]]) xyfdp[cards[j]][1]++;
//                 else xyfdp[cards[j]] = [cards[j],1];
//             }
//         }
//     }
//     console.warn("测试发牌幸运的结果   "+JSON.stringify(xyfdp));
//     console.warn("测试发牌的结果   "+JSON.stringify(res));
//     let cxcsInfo = [];//出现次数合计信息
//     for (var i = 0; i < this.cardsPool.length; i++) {
//         if(i == 9 || i == 21) {
//             cxcsInfo[cxcsInfo.length] = res[i];
//             continue;
//         }
//         let ptcs = res[i][1] || 0;//普通次数
//         let xycs = xyfdp[i][1] || 0;//幸运次数
//         let zcs = ptcs+xycs
//         cxcsInfo[cxcsInfo.length] = [res[i][0],zcs]
//     }
//     console.warn("测试发牌合计之后的结果   "+JSON.stringify(cxcsInfo));
//     let cxxq = [];//出现次数详情
//     cxxq[0] = "100万次测试发牌中各个牌出现的次数"
//     for (var i = 0; i < res.length; i++) {
//         let ph = res[i][0];//牌号
//         let cs = res[i][1];//出现次数
//         let zb = cs*100/csfpcs; //所占百分比
//         let name = this.cardsPool[ph][1]  
//         cxxq[cxxq.length] = ""+ph+"号牌(" + name+")出现了  "+cs+"  次,占比： "+zb+"  %";
//     }
//     // console.warn("测试发牌的出现详情   "+JSON.stringify(cxxq));
//     console.warn("测试发牌的出现详情   ",cxxq);

//     let zhzhlist = [];
//     let pzlb = ["大苹果","大橙子","大芒果","大铃铛","大西瓜","大星星","大七七","大王王","幸运运","小苹果","小橙子","小芒果","小铃铛","小西瓜","小星星","小七七","小王王"];
//     for (var i = 0; i < pzlb.length; i++) {
//         let name = pzlb[i];
//         let cs = 0;
//         if(i ==0) cs = cxcsInfo[4][1] + cxcsInfo[10][1] + cxcsInfo[16][1] + cxcsInfo[22][1];
//         else if(i ==1) cs = cxcsInfo[0][1] + cxcsInfo[12][1];
//         else if(i ==2) cs = cxcsInfo[6][1] + cxcsInfo[18][1];
//         else if(i ==3) cs = cxcsInfo[1][1] + cxcsInfo[13][1];
//         else if(i ==4) cs = cxcsInfo[7][1];
//         else if(i ==5) cs = cxcsInfo[19][1];
//         else if(i ==6) cs = cxcsInfo[15][1];
//         else if(i ==7) cs = cxcsInfo[3][1];
//         else if(i ==8) cs = cxcsInfo[9][1] + cxcsInfo[21][1];
//         else if(i ==9) cs = cxcsInfo[5][1];
//         else if(i ==10) cs = cxcsInfo[11][1];
//         else if(i ==11) cs = cxcsInfo[17][1];
//         else if(i ==12) cs = cxcsInfo[23][1];
//         else if(i ==13) cs = cxcsInfo[8][1];
//         else if(i ==14) cs = cxcsInfo[20][1];
//         else if(i ==15) cs = cxcsInfo[14][1];
//         else if(i ==16) cs = cxcsInfo[2][1];
//         zhzhlist[i] = [name,cs]
//     }
//     console.warn("测试发牌整合之后出现的次数1  ",zhzhlist);
//     // let mmsyLisgt = [];//每门赢的
//     // for (var i = 0; i < 9; i++) {
//     //     let cs = 0
//     //     if(i ==0) cs = cxcsInfo[0][1] + cxcsInfo[9][1];
//     //     else if(i ==1) cs = cxcsInfo[1][1]*5 + cxcsInfo[10][1]*3;
//     //     else if(i ==2) cs = cxcsInfo[2][1]*10 + cxcsInfo[11][1]*3;
//     //     else if(i ==3) cs = cxcsInfo[3][1]*15 + cxcsInfo[12][1]*3;
//     //     else if(i ==4) cs = cxcsInfo[4][1]*20 + cxcsInfo[13][1]*3;
//     //     else if(i ==5) cs = cxcsInfo[5][1]*20 + cxcsInfo[14][1]*3;
//     //     else if(i ==6) cs = cxcsInfo[6][1]*30 + cxcsInfo[15][1]*3;
//     //     else if(i ==7) cs = cxcsInfo[7][1]*0 + cxcsInfo[16][1]*3;
//     //     else if(i ==8) cs = cxcsInfo[8][1];
//     //     mmsyLisgt[i]
//     // }

//     // let zjdyzxbs = [];//这局结果对应的押注列表下标，用于计算押注列表中每门押注是否压中
//     // let zjdypxbs = [];//这局结果对应的牌值列表，用于计算获得列表判断任务
//     // for (var i = 0; i < result.cards.length; i++) {
//     //     cardsInfos[cardsInfos.length] = this.cardsPool[result.cards[i]]
//     //     zjdyzxbs[zjdyzxbs.length] = this.cardsPool[result.cards[i]][3];
//     //     let pk = this.cardsPool[result.cards[i]][3];//牌类型
//     //     let pz = result.cards[i];//牌值
//     //     if(pz == 5) pk = 9;//小苹果
//     //     else if(pz == 11) pk = 10;//小橙子
//     //     else if(pz == 17) pk = 11;//小芒果
//     //     else if(pz == 23) pk = 12;//小铃铛
//     //     else if(pz == 8) pk = 13;//小西瓜
//     //     else if(pz == 20) pk = 14;//小星星
//     //     else if(pz == 14) pk = 15;//小七七
//     //     else if(pz == 2) pk = 16;//小王王
//     //     zjdypxbs[zjdypxbs.length] = pk;
//     // }
//     // result.bcfpdydyzxbs = zjdyzxbs;//本次发牌对应的押注下注下标
//     // result.zjdypxbs = zjdypxbs;//这局结果对应的牌值列表，用于计算获得列表判断任务
//     // console.warn("发牌函数  本局发的牌  "+JSON.stringify(result.cards)+"  牌的详细信息  "+JSON.stringify(cardsInfos));
//     // for (var i = 0; i < yazhus.length; i++) {
//     //     let bmyzsy = 0;//本局游戏玩家押注列表中本门押注赢的分数
//     //     if(yazhus[i]){
//     //         let xb = zjdyzxbs.indexOf(i);
//     //         if(xb != -1){
//     //             //押注列表中本门押中了
//     //             let bmydfs = cardsInfos[xb][2] * yazhus[i];//本门赢得分数
//     //             console.warn("发牌函数  押注列表中下标 "+i+"  门押中了 获奖 "+bmydfs);
//     //             bmyzsy*0 += bmydfs;
//     //*3         }
//     //     }
//     //     result.winList[i] = bmyzsy;
//     //     console.warn("发牌函数  本局结果赢的列表 "+i+"   "+bmyzsy);
//     // }
//     // result.win = _.sum(result.winList)

// }

// 判断的是否是JSON字符串
proto.getIsAJsonStr = function (str) {
    if (typeof str == 'string') {
        try {
            var obj = JSON.parse(str);
            if (typeof obj == 'object' && obj) {
                return true;
            } else {
                //不是就返回false
              return false;
            }
        } 
        catch (e) {
            return false;
        }
    }
    return false;
}

//////得到押大小调控信息，0不调，1调小，2调大
proto.getYDXAdjust = function (mqdw,jcPools){
    // console.warn("得到押大小调控信息  ",mqdw,jcPools);
    if(!jcPools) return 0;//没有奖池信息
    if(mqdw < 0 || mqdw >= jcPools.pools.length) return 0;//挡位不合法
    let mqdwcsz = jcPools.ydxcspools[mqdw];//目前挡位初始值
    let mqdwxzz = jcPools.ydxpools[mqdw];//目前挡位现在值
    let mqdwsx1 = jcPools.ydxtopLimits1[mqdw];//目前挡位上限值1
    let mqdwxx1 = jcPools.ydxlowLimits1[mqdw];//目前挡位下限值1
    if(mqdwxzz < mqdwsx1 && mqdwxzz > mqdwxx1) return 0;//目前该挡位奖池合理不需要调控
    let tkType = 0;//调控类型。0：不调控，1：调小，2：调大
    if(mqdwxzz >= mqdwsx1) tkType = 2;
    else if(mqdwxzz <= mqdwxx1) tkType = 1;
    if(tkType == 0){
        console.error("ydx判断出错了 ",mqdw,jcPools);
        return 0;
    }
    let sjs = Math.floor(Math.random()*100) + 1;//[1,100]
    if(tkType == 1){//调小
        let tkdw = -1;
        if(mqdwxzz <= jcPools.ydxlowLimits3[mqdw]) tkdw = 2;
        else if(mqdwxzz <= jcPools.ydxlowLimits2[mqdw]) tkdw = 1;
        else if(mqdwxzz <= jcPools.ydxlowLimits1[mqdw]) tkdw = 0;
        if(tkdw < 0){
            console.error("ydx判断出错了111 ",mqdw,jcPools);
            return 0;
        }
        let qjc = [//区间池
            jcPools.ydxLowRate1[mqdw],
            jcPools.ydxLowRate2[mqdw],
            jcPools.ydxLowRate3[mqdw]
        ];//区间池
        if(sjs > qjc[tkdw]) return 0;
        else return 1;//调小
    }
    else if(tkType == 2){//调大
        let tkdw = -1;
        if(mqdwxzz <= jcPools.ydxtopLimits3[mqdw]) tkdw = 2;
        else if(mqdwxzz <= jcPools.ydxtopLimits2[mqdw]) tkdw = 1;
        else if(mqdwxzz <= jcPools.ydxtopLimits1[mqdw]) tkdw = 0;
        if(tkdw < 0){
            console.error("ydx判断出错了222 ",mqdw,jcPools);
            return 0;
        }
        let qjc = [
            jcPools.ydxTopRate1[mqdw],
            jcPools.ydxTopRate2[mqdw],
            jcPools.ydxTopRate3[mqdw]
        ];//区间池
        if(sjs > qjc[tkdw]) return 0;
        else return 2;//调大
    }
    console.error("ydx判断出错了333 ",mqdw,jcPools);
    return 0
}

// 计算划分结果
proto.getHuafenRes = function (type,value,mqdw,jcPools) {
    //是首次发牌，下面这种写法是整副牌随机发牌
    let number = Math.floor(Math.random()*13)+1;//[1,13]
    let adjust = this.getYDXAdjust(mqdw,jcPools);
    // console.warn("计算划分结果  number  adjust ",number,adjust);
    if(adjust == 1) {//调小
        if(type == 1) number = Math.floor(Math.random()*7)+1+6;//[7,13]
        else if(type == 2) number = Math.floor(Math.random()*7)+1;//[1,7]
    }
    if(adjust == 2) {//调大
        if(type == 1) number = Math.floor(Math.random()*6)+1;//[1,6]
        else if(type == 2) number = Math.floor(Math.random()*6)+1+7;//[8,13]
    }
    if(adjust > 0) console.error("押大小被调控了  number  adjust ",number,adjust);
    // number = 1;
    let win = 0;
    let addTaskQuan = 0;
    if(type == 1){
        //押小
        if(1 <= number && number <= 6){
            //押中了
            win = value;
        }
        else{
            //未押中
            win = value*-1;
        }
    }
    else if(type == 2){
        //押大
        if(8 <= number && number <= 13){
            //押中了
            win = value;
        }
        else{
            //未押中
            win = value*-1;
        }
    }
    addTaskQuan = value*this.toTaskQuanReate;
    let res = {
        number:number,
        win:win,
        addTaskQuan:addTaskQuan
    }
    return res;
}

//TL++,得到指定时间戳（_time）当日0点的时间戳
proto.getzdLDSJC = function (_time){
    var today = new Date(_time);
    today.setHours(0);
    today.setMinutes(0);
    today.setSeconds(0);
    today.setMilliseconds(0);
    let jrsjc = today.getTime();
    // console.warn("111得到今日0点的时间戳   ",jrsjc, typeof jrsjc);
    return jrsjc;
};

//更新获得列表 用于任务相关判断
proto.updateGetList = function (_nowtime,_time,_getList,_zjdypxbs,_wjrwxylb){
    let hdlbsfgq = true;//获得列表是否过期
    if(_nowtime < 1713456000000){//2024-4-19之前一天过期一次，获得列表会无上限的增加，之后永不过期但是没领任务的话不计入获得列表
        if(_time > 0 && this.getzdLDSJC(_nowtime) == this.getzdLDSJC(_time)) hdlbsfgq = false;//一天过期
    }
    else{//2024-4-18之前一天过期一次，获得列表会无上限的增加，之后永不过期但是没领任务的话不计入获得列表
        hdlbsfgq = false;
    }
    // hdlbsfgq = false;//测试用的，正式服需要去掉，获得列表永不过期（不清空）
    let getList = [];
    for (var i = 0; i < this.cardKindCount; i++) {
        if(hdlbsfgq) getList[i] = 0;
        else {
            if(i < _getList.length) getList[i] = _getList[i];
            else getList[i] = 0;
        }
        let czxb = -1;//pk存在的下标
        for (var j = 0; j < _zjdypxbs.length; j++) {
            if(_zjdypxbs[j][0] == i){
                czxb = j;
                break;
            }
        }
        if(czxb >= 0) {
            if(_nowtime < 1713456000000){//2024-4-19之前一天过期一次，之后永不过期
                getList[i] += _zjdypxbs[czxb][1];
            }
            else{
                if(_wjrwxylb[i] > 0 && _wjrwxylb[i] >= getList[i] + _zjdypxbs[czxb][1]){
                    //领取了对应任务且未达上限才计入获得列表
                    getList[i] += _zjdypxbs[czxb][1];
                }
                else{
                    //未领取对应任务或已达上限时获得列表按0或上限计
                    getList[i] = _wjrwxylb[i];//超过上限的话按照上限算
                }
            }
            // console.warn("更新获得列表  玩家已领未完成任务需要的任务要求列表  ",hdlbsfgq,getList);
        }
    }
    // console.warn("更新获得列表    ",getList.length,_getList.length,getList,_getList);
    return getList;
};

//得到总的获得列表 用于统计
proto.getAllGetList = function (_getList,_zjdypxbs){
    for (var i = 0; i < this.cardKindCount; i++) {
        let czxb = -1;//pk存在的下标
        if(!_getList[i]) _getList[i] = 0;
        for (var j = 0; j < _zjdypxbs.length; j++) {
            if(_zjdypxbs[j][0] == i){
                czxb = j;
                break;
            }
        }
        if(czxb >= 0) _getList[i] += _zjdypxbs[czxb][1];
    }
};

//得到各详细项总赢得总额列表(区分大小不包含特殊项)列表 用于统计
proto.getGXXXYDZEList = function (_getList,_zjdypxbs){
    // console.warn("得到各详细项总赢得总额列表   ",_getList,_zjdypxbs);
    for (var i = 0; i < this.cardKindCount; i++) {
        let czxb = -1;//pk存在的下标
        if(!_getList[i]) _getList[i] = 0;
        for (var j = 0; j < _zjdypxbs.length; j++) {
            if(_zjdypxbs[j][0] == i){
                czxb = j;
                break;
            }
        }
        if(czxb >= 0) _getList[i] += _zjdypxbs[czxb][1];
    }
};

//得到已完成的任务信息
proto.getOverTask = function (_getList,_ylrwList){
    // console.warn("得到已完成的任务信息  ",JSON.stringify(_getList),JSON.stringify(_ylrwList));
    let getList = _.cloneDeep(_getList);
    let overList = [];
    for (var i = 0; i < _ylrwList.length; i++) {
        let info = _ylrwList[i];
        let iswc = true;
        for (var j = 0; j < info.reachs.length; j++) {
            let index = info.reachs[j];
            let yqcount = info.reachC[j];
            if(getList[index] < yqcount){
                iswc = false;
                break
            }
        }
        if(iswc){
            overList[overList.length] = i;
            for (var j = 0; j < info.reachs.length; j++) {
                let index = info.reachs[j];
                let yqcount = info.reachC[j];
                getList[index] -= yqcount
            }
        }
    }
    return {overList:overList,getList:getList}
};

// 得到两个数组是否一致
proto.getListIsSame = function (list1,list2){
    if(list1.length != list2.length) return false;
    for (var i = 0; i < list1.length; i++) {
        if(!(list1[i] === list2[i])) return false;
    }
    return true;
};

//得到排名奖励
proto.getpmjl = function (index){
    let mc = index + 1;//名次=数组下标+1
    let diamond = 0;
    if(mc == 1) diamond = 20000;
    else if(mc == 2) diamond = 10000;
    else if(mc == 3) diamond = 5000;
    else if(mc >= 4 && mc <= 5) diamond = 2000;
    else if(mc >= 6 && mc <= 10) diamond = 1000;
    return diamond;
};

// 计算两个数小数的结果 _type:1:加法,1:减法,1:乘法,1:除法,
proto.jisuanFloat = function (_float1,_float2,type){
    //得到float转换为整数和倍数
    let getZSHBS = function (_float){
        let floats = _float.toString();
        let xsdxb = floats.indexOf(".");//_float的小数点下标
        let xsws = 0;//_float的小数位数
        if(xsdxb != -1) xsws = floats.length - 1 - xsdxb;
        let zsStr = floats.replace('.', "");//这里不能直接使用乘号（*）会出错的
        let zs = Number(zsStr);//_float转换之后的整数
        let bs = Math.pow(10,xsws);//_float转换成整数需要的倍数
        // console.warn("得到float转换为整数和倍数   _float "+_float+"  zs "+zs+"  bs "+bs+"  floats "+floats)
        return{
            zs:zs,//整数
            bs:bs,//倍数
        }
    }
    let float1 = _float1;
    let float2 = _float2;
    // console.warn("计算两个数小数   _float1 "+_float1+"  _float2 "+_float2+"  float1 "+float1+"  float2 "+float2);
    let info1 = getZSHBS(float1);//float1转换为整数之后的整数和倍数
    let info2 = getZSHBS(float2);//float2转换为整数之后的整数和倍数
    let zs1 = info1.zs;
    let bs1 = info1.bs;
    let zs2 = info2.zs;
    let bs2 = info2.bs;
    let maxBs = bs1;
    if(bs2 > bs1) maxBs = bs2;
    let zsjg = null;//整数结果
    if(type == 1){//加法
        if(bs1 == bs2) zsjg = zs1 + zs2;
        else if(bs1 > bs2) zsjg = zs1 + zs2 * (bs1 / bs2);
        else if(bs1 < bs2) zsjg = zs1 * (bs2 / bs1) + zs2;
    }
    else if(type == 2){//减法
        if(bs1 == bs2) zsjg = zs1 - zs2;
        else if(bs1 > bs2) zsjg = zs1 - zs2 * (bs1 / bs2);
        else if(bs1 < bs2) zsjg = zs1 * (bs2 / bs1) - zs2;
    }
    else if(type == 3){//乘法
        zsjg = (zs1 * zs2) / (bs1 * bs2);
        maxBs = 1;
    }
    else if(type == 4){//除法
        zsjg = (zs1 * bs2) / (zs2 * bs1);
        maxBs = 1;
    }
    let zzjg = zsjg / maxBs;////最终结果
    return zzjg
};

//测试小数结果是否正确
proto.testFloat = function (){
    // let xx = 4.40+1.11;
    // let xx1 = 100.11-100;
    // let xx2 = 100.11-100.01;
    // let xx3 = 1.1*100;
    // let xx4 = 2.01*100;
    ////小数计算会错误？？？？？？？？？？？？    5.510000000000001 0.10999999999999943 0.09999999999999432 110.00000000000001 200.99999999999997
    // let xx = this.jisuanFloat(4.40,1.11,1);
    // let xx1 = this.jisuanFloat(100.11,100,2);
    // let xx2 = this.jisuanFloat(100.11,100.01,2);
    // let xx3 = this.jisuanFloat(1.1,100,3);
    // let xx4 = this.jisuanFloat(2.01,100,3);
    ////小数计算会错误？？？？？？？？？？？？    5.51 0.11 0.1 110 201
    // let xx = this.jisuanFloat(4,1,1);
    // let xx1 = this.jisuanFloat(100,10,1);
    // let xx2 = this.jisuanFloat(100.11,1.1,1);
    // let xx3 = this.jisuanFloat(2.1,100,1);
    // let xx4 = this.jisuanFloat(2.01,100.1,1);
    // ////小数计算会错误？？？？？？？？？？？？    5 110 101.21 102.1 102.11
    // let xx = this.jisuanFloat(4,1,2);
    // let xx1 = this.jisuanFloat(100,10,2);
    // let xx2 = this.jisuanFloat(100.11,1.1,2);
    // let xx3 = this.jisuanFloat(2.1,100,2);
    // let xx4 = this.jisuanFloat(2.01,100.1,2);
    // ////小数计算会错误？？？？？？？？？？？？    3 90 99.01 -97.9 -98.09
    
    // let xx = this.jisuanFloat(4,1,4);
    // let xx1 = this.jisuanFloat(100,10.1,4);
    // let xx2 = this.jisuanFloat(100.11,1.1,4);
    // let xx3 = this.jisuanFloat(2.1,100,4);
    // let xx4 = this.jisuanFloat(2.01,100.1,4);
    ////小数计算会错误？？？？？？？？？？？？    4 9.900990099009901 91.00909090909092 0.021 0.02007992007992008
    // console.warn("小数计算会错误？？？？？？？？？？？？   ",xx,xx1,xx2,xx3,xx4);

    //牌的倍数数组
    let bslist = [10,20,50,100,5,3,15,20,3,0,5,3,10,20,3,40,5,3,15,30,3,0,5,3];//共371倍
    //牌的倍数分布情况
    // let bsfbqk = [//{bs:倍数,gs:个数,gl:概率百分数}
    //     {bs:3,gs:7,gl:33.33},//4.24
    //     {bs:5,gs:1,gl:20},//20-2.4
    //     {bs:10,gs:1,gl:10},//10-1.2
    //     {bs:15,gs:1,gl:6.66},//6.66-1.125
    //     {bs:20,gs:1,gl:5},//5-0.6
    //     {bs:20,gs:1,gl:5},//5-0.6
    //     {bs:30,gs:1,gl:3.33},//3.33-0.225
    //     {bs:40,gs:1,gl:2.5},//2.5-0.3
    //     {bs:50,gs:1,gl:2},
    //     {bs:100,gs:1,gl:1},
    //     {bs:100,gs:2,gl:1}//这是幸运
    // ]

    // let bsfbqk = [//{bs:倍数,gs:个数,gl:概率百分数}
    //     {bs:3,gs:7,gl:46.66},//4.2  4.66  xpg13.3 xxg6.6
    //     {bs:5,gs:1,gl:18.8},//20-1.2
    //     {bs:10,gs:1,gl:9.4},//10-0.6
    //     {bs:15,gs:1,gl:6.26},//6.66-0.4
    //     {bs:20,gs:1,gl:4.7},//5-0.3
    //     {bs:20,gs:1,gl:4.7},//5-0.3
    //     {bs:30,gs:1,gl:3.13},//3.33-0.2
    //     {bs:40,gs:1,gl:2.35},//2.5-0.15
    //     {bs:50,gs:1,gl:2},
    //     {bs:100,gs:1,gl:1},
    //     {bs:100,gs:2,gl:1}//这是幸运
    // ]

    // let qujian = [47,140,150,200,250,300,350,400,450,500,550,600,650,700,750,800,850,900,950,960,970,980,990,1000];//发牌区间列表，用于随机数转换成发牌
    // let bsfbqk = [//{bs:倍数,gs:个数,gl:概率百分数}
    //     {bs:3,gs:7,gl:46.2},//4.24
    //     {bs:5,gs:1,gl:17.6},//20-2.4
    //     {bs:10,gs:1,gl:8.8},//10-1.2
    //     {bs:15,gs:1,gl:5.535},//6.66-1.125
    //     {bs:20,gs:1,gl:4.4},//5-0.6
    //     {bs:20,gs:1,gl:4.4},//5-0.6
    //     {bs:30,gs:1,gl:3.105},//3.33-0.225
    //     {bs:40,gs:1,gl:2.2},//2.5-0.3
    //     {bs:50,gs:1,gl:2},
    //     {bs:100,gs:1,gl:1},
    //     {bs:100,gs:2,gl:1}//这是幸运
    // ]
    // let zgl = 0 ;
    // for (var i = 0; i < bsfbqk.length; i++) {
    //     zgl = this.jisuanFloat(zgl,bsfbqk[i].dcs,1);
    //     zgl = this.jisuanFloat(zgl,bsfbqk[i].xcs,1);
    // }

    // let qj = [47,23,20,47,31,46,5,47,47,23,23,47,31,31,5,47];
    // console.warn("总和========   "+_.sum(qj));
    // console.warn("总次数-----------  "+zgl);


    //上面那种方式没有下面这种方式合理
    // let bsfbqk = [//{bs:倍数,gs:个数,dcs:出现大的次数,xcs:出现小的次数}  78%  943
    //     {bs:5,gs:1,dcs:156,xcs:73},//苹果
    //     {bs:10,gs:1,dcs:78,xcs:73},//橙子
    //     {bs:15,gs:1,dcs:52,xcs:73},//芒果
    //     {bs:20,gs:1,dcs:39,xcs:73},//铃铛
    //     {bs:20,gs:1,dcs:39,xcs:73},//西瓜
    //     {bs:30,gs:1,dcs:26,xcs:73},//星星
    //     {bs:40,gs:1,dcs:19,xcs:80},//七七
    //     {bs:100,gs:1,dcs:5,xcs:9},//王王
    //     {bs:100,gs:1,dcs:2,xcs:0},//幸运
    // ]

    // let bsfbqk = [//{bs:倍数,gs:个数,dcs:出现大的次数,xcs:出现小的次数}  76%  980
    //     {bs:5,gs:1,dcs:152,xcs:80},//苹果
    //     {bs:10,gs:1,dcs:76,xcs:80},//橙子
    //     {bs:15,gs:1,dcs:50,xcs:83},//芒果
    //     {bs:20,gs:1,dcs:38,xcs:80},//铃铛
    //     {bs:20,gs:1,dcs:38,xcs:80},//西瓜
    //     {bs:30,gs:1,dcs:25,xcs:83},//星星
    //     {bs:40,gs:1,dcs:19,xcs:80},//七七
    //     {bs:100,gs:1,dcs:5,xcs:9},//王王
    //     {bs:100,gs:1,dcs:2,xcs:0},//幸运
    // ]

    //倍数及千次出现次数分布情况
    let bsfbqk = [//{bs:倍数,gs:个数,dcs:出现大的次数,xcs:出现小的次数}  74%  1000
        {bs:5,gs:1,dcs:148,xcs:86},//苹果
        {bs:10,gs:1,dcs:74,xcs:86},//橙子
        {bs:15,gs:1,dcs:49,xcs:88},//芒果
        {bs:20,gs:1,dcs:37,xcs:86},//铃铛
        {bs:20,gs:1,dcs:37,xcs:86},//西瓜
        {bs:30,gs:1,dcs:25,xcs:83},//星星
        {bs:40,gs:1,dcs:19,xcs:80},//七七
        {bs:100,gs:1,dcs:5,xcs:9},//王王
        {bs:100,gs:1,dcs:2,xcs:0},//幸运
    ]
    //发牌区间分布情况[序号,名称,区间范围]
    let qjfbqk = [
        [0,"大橙子",37,],
        [1,"大铃铛",19,],
        [2,"小王王",5,],
        [3,"大王王",9,],
        [4,"大苹果",37,],
        [5,"小苹果",86,],
        [6,"大芒果",24,],
        [7,"大西瓜",37,],
        [8,"小西瓜",86,],
        [9,"幸运运",1,],
        [10,"大苹果",37,],
        [11,"小橙子",86,],
        [12,"大橙子",37,],
        [13,"大铃铛",18,],
        [14,"小七七",80,],
        [15,"大七七",19,],
        [16,"大苹果",37,],
        [17,"小芒果",88,],
        [18,"大芒果",25,],
        [19,"大星星",25,],
        [20,"小星星",83,],
        [21,"幸运运",1,],
        [22,"大苹果",37,],
        [23,"小铃铛",86,]
    ]
    
    let zcs = 0 ;
    for (var i = 0; i < bsfbqk.length; i++) {
        zcs = this.jisuanFloat(zcs,bsfbqk[i].dcs,1);
        zcs = this.jisuanFloat(zcs,bsfbqk[i].xcs,1);
    }
    // console.warn("总次数-----------  "+zcs);
    let zonghe = 0;
    let fpqj = [];//发牌区间
    for (var i = 0; i < qjfbqk.length; i++) {
        let dqsz = 0;//当前数值
        if(i > 0) dqsz = fpqj[i-1];
        fpqj[i] = dqsz + qjfbqk[i][2];  
        zonghe+=qjfbqk[i][2]
    }
    // console.warn("得到的发牌区间========   ",zonghe,fpqj.length,JSON.stringify(fpqj));
    // 得到的发牌区间========    24 [36,55,60,69,106,192,216,253,339,340,377,463,500,518,598,617,654,742,767,792,875,876,913,999]


    // let zbs = _.sum(bslist);//总倍数
    // let cxcslb = [];// 出现次数列表
    // for (var i = 0; i < bslist.length; i++) {
    //     // cxcslb[i] = this.jisuanFloat(zbs,bslist[i],4);
    //     cxcslb[i] = zbs/bslist[i];
    // }
    // console.warn("总倍数  "+zbs+"   出现次数列表  "+JSON.stringify(cxcslb));
    // // --总倍数  371   出现次数列表  [3710,7420,18550,37100,1855,1113,5565,7420,1113,0,1855,1113,3710,7420,1113,14840,1855,1113,5565,11130,1113,0,1855,1113]
    // let cxcszslb = [];// 出现次数整数列表
    // let cxcsqzxybs = 100;//出现次数取整需要的倍数
    // let fpzcs = zbs*cxcsqzxybs;//发牌总次数
    // for (var i = 0; i < cxcslb.length; i++) {
    //     cxcszslb[i] = this.jisuanFloat(cxcslb[i],100,3);
    // }
    // console.warn("发牌总次数  "+fpzcs+"   出现次数列表  "+JSON.stringify(cxcszslb));
    // // 发牌总次数  37100   出现次数列表  [3710,7420,18550,37100,1855,1113,5565,7420,1113,0,1855,1113,3710,7420,1113,14840,1855,1113,5565,11130,1113,0,1855,1113]
}