hnhzServer/app/shuiguo/table.js

'use strict';
var https = require('https');
var http = require('http');
var md5 = require('md5');

var util = require('util');
var quick = require('quick-pomelo');
var P = quick.Promise;
var cor = P.coroutine;
var _ = require('lodash');/////是一个一致性、模块化、高性能的 JavaScript 实用工具库。
//// 为什么选择 Lodash ？
//// Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。
//// Lodash 的模块化方法 非常适用于：

//// 遍历 array、object 和 string
//// 对值进行操作和检测
//// 创建符合功能的函数
var uuid = require('node-uuid');
var Logic = require('./logic');
var User = require('./user');
var Score = require('./score');
var conf = require('../config/games').paodekuai || {};
var M = require('../../share/message');
var C = require('../../share/constant');
var paiJuHuiFang = require('../../share/paiJuHuiFang');//////TL++ 牌局回放
var configCommon = require('../../share/configCommon');//////TL++配置相关的公共方法
var setReabte = require('../../share/setReabte');//////TL++记录返利相关的公共方法
var logger = quick.logger.getLogger('fhmj', __filename);

// 桌子状态
var STATE = { FREE: 1, PLAYING: 2, FREE2: 3 , END: 4};//ts++REFREE 二次空闲 END结束

// 结算模式
var MODE = { NORMAL: 1, NOCARD: 2, OFFLINE: 3 };

//ts++结束模式 空闲0,游戏中1, 正常结束3,房主解散3,断线解散4,断线解散5,系统解散6
var ENDMODE = { FREE: 0,PLAYING: 1, OWNEREND: 2,NORMALEND: 3,REGEND: 4, OFFLINEEND: 5, SYSTEMEND: 6  };

// 金币消耗
const COSTS = conf.sit_costs || {};


/////TL++,下面这几行为了记录用户行为
// var log4js2 = require("log4js");////cssj
// var log4js_config2 = require("./logConf.json");
// log4js2.configure(log4js_config2);
// var LogFile2 = log4js2.getLogger('log_file');////cssj

var checkVersion = function () {
    // let confCodeVer = require('../config/VersionConfig').codeVer || {};
    // // console.warn("pdk的table中检查logic版本111   "+JSON.stringify(confCodeVer));
    // if(confCodeVer.sgjLogic){
    //     delete require.cache[require.resolve('../config/VersionConfig')];
    //     let confCodeVer2 = require('../config/VersionConfig').codeVer || {};
    //     // console.warn("pdk的table中检查logic版本222   "+confCodeVer.sgjLogic +"   "+ confCodeVer2.sgjLogic);
    //     if(confCodeVer.sgjLogic && confCodeVer2.sgjLogic && confCodeVer.sgjLogic != confCodeVer2.sgjLogic){
    //         delete require.cache[require.resolve('./logic')];
    //         Logic = require('./logic');
    //         console.warn("sgj的table中的logic更新了   ")
    //     }
    // }
}
// 构造方法
var Table = function (cPlayerId,cUserId,cName,cHead,game, id, cell, round, type,gameKindTL,playerAllCount,upId,other,agentId,yxndlbTime,yxndlbTip) {
    let str3 = "table构造方法.......id:  "+id + " type " + type+"  game  "+game.id;
    logger.warn(str3);////cssj
    checkVersion();
    this.app = game.app;
    this.gameId = 10005;
    this.game = game;
    this.id = id;
    this.recordid = uuid.v1()+'_'+id;//ts++唯一记录
    this.upId = upId;//ts++上局的ID
    this.type = type;
    this.agentId=agentId;
    this.yxndlbTime = yxndlbTime;
    this.yxndlbTip = yxndlbTip;
    var num_cost = 0;
    this.other = other;//////TL++2人3人的游戏规则
    // console.warn("222创建房间的other",other,this.other,"  gameKindTL ",gameKindTL," type " ,type);
    this.cost = num_cost;
    this.over = 0;
    this.round = round;
    this.stime = 0;
    this.ctime = Date.now();
    this.etime = 0;
    // 人数
    this.ccount = playerAllCount;//Logic.CHAIR_COUNT;
    // 房主
    this.ownerChairId = -1;//房主的chairid
    this.ownerId = cPlayerId;//房主Id
    this.ownerUid = cUserId;//房主的userID
    this.ownerName = cName;
    this.ownerHeadUrl = cHead;

    // 数据
    var logic = new Logic(type,gameKindTL,playerAllCount,other);
    this.logic = logic;
    // this.logic.testFloat();
    // this.logic.testSendCards();
    this.score = new Score(this);
    this.users = [];
    this.fpRes = {};//本局的发牌
    this.ydxfpRes = {
        cs:0,//本局押大小的次数，用于实现只能在首次押大小之前点击加分
        type: -1,//本局玩家上次押大小的类型，-1表示还未押过大小,1表示押小2表示押大
        number: -1,//本局玩家上次押大小的发牌，-1表示还未押过大小
    };//本局的押大小发牌
    this.nowDiamond = 0;//玩家目前游戏内的钻石（带入的）
    this.nowDiamond2 = 0;//玩家目前游戏外的钻石（所有的减去带入的）
    this.wjcsDiamond = -1;//玩家进入房间初始的钻石数，用于判断离开的时候是否需要记录钻石变更
    this.yazhus = [];//玩家本次押注情况
    this.win = 0;//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
    this.yxjlid = "";//ts++游戏记录id
    // console.warn("构造方法   "+this.users.length+"   "+JSON.stringify(this.users));
    this.wjrwxylb = [];//玩家已领未完成任务需要的任务要求列表
    //下面是统计每日数据用
    this.zqqCost = 0;  //所有玩家游戏转圈总下注
    this.zqqwin = 0;   //所有玩家游戏转圈总赢得
    this.zqqxh = 0;    //所有玩家游戏转圈总消耗（总下注-总赢得）
    this.ydxCost = 0;  //所有玩家押大小总下注
    this.ydxwin = 0;   //所有玩家押大小总赢得
    this.ydxxh = 0;    //所有玩家押大小总消耗（总下注-总赢得）
    this.ydxzcs = 0;   //该日押大小总次数
    this.allrwq = 0;   //所有奖券产生总量   
    this.rwxhjq1 = 0;  //钻石任务消耗奖券总量（领任务时记录）
    this.rwxhjq2 = 0;  //RMB任务消耗奖券总量（领任务时记录）
    this.rwdcze1 = 0;  //钻石任务兑出总额（领奖时记录）
    this.rwdcze2 = 0;  //RMB（分）任务兑出总额（领奖时记录）
    //下面是统计总数据用
    this.allCost = 0;  //所有玩家总下注
    this.allwin = 0;   //所有玩家总赢得
    this.allxh = 0;    //所有玩家总消耗（总下注-总赢得）
    // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
    this.allyzze = []; //总押注总额列表
    this.allydze = []; //总赢得总额列表(不包含特殊项)
    for (var i = 0; i < 8; i++) {
        this.allyzze[i] = 0; //总押注总额列表
        this.allydze[i] = 0; //总赢得总额列表(不包含特殊项)
    }
    // 下面这两个数据是长度为16的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
    //小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
    this.gxzydze = []; //各项总赢得总额列表(不包含特殊项)
    this.gxcxzcs = []; //各项出现总次数列表(不包含特殊项)
    for (var i = 0; i < this.logic.cardKindCount; i++) {
        this.gxzydze[i] = 0; //各项总赢得总额列表(不包含特殊项)
        this.gxcxzcs[i] = 0; //各项出现总次数列表(不包含特殊项)
    }
    // 下面这两个数据是长度为3的数组，分别代表[小三元,小三元,大四喜]
    this.tsxzydze = [0,0,0];                 //特殊项总赢得总额列表
    this.tsxcxzcs = [0,0,0];                 //特殊项出现总次数列表
    this.mrrstjsj = 0;//每日人数统计时间，用于判断在游戏和押大小时是否需要统计记录昨天的人数信息实现减少数据库访问
    //统计数据至此完
    // 标记
    this.handCards = [];//本局发牌
    this.currentId = -1;
    this.autoReadyTimer = null;//托管中自动准备定时器
    // 底分
    this.cell = cell;
    // 围观者
    this.lookers = [];
    this.phbyfjlrq = 0;  //排行榜已发奖励的日期（0点时间戳）
    this.phbfjTimer = null;//排行榜发奖定时器
    // 状态
    this.state = STATE.FREE;
    //断线 结束定时器
    this.endTimer = null;
    this.calculateTimer = null
    //结束时的继线用户  为了在销毁房间的时候让这些用户退出房间
    this.leaveUsers = [];
    //////以下全为TL++
    /////TL++,补花定时器，防止连续补花太快
    this.PJHF = new paiJuHuiFang();
    this.PaijuHuiFang = [];////TL++,牌局回放
    this.pjhffileName = [];//用于记录玩家牌局回放的json文件名
    this.gameKindTL = gameKindTL || 1;//平搓还是冲刺  = 1代表平搓 = 2代表冲刺
    this.playerAllCount = playerAllCount || 1;//游戏人数  = 2表示2人局 = 3表示3人局 = 4表示4人局
    this.isNeverStart = true;//游戏是否从未开始
    // this.sszjDataList = [];//设置实时战绩的数据
    this.isGameOk=false;//ts++牌局正常结束
    this.agentRebate=0;//ts++本局的返利
    // delete require.cache[require.resolve('../../share/setReabte')];
    // setReabte = require('../../share/setReabte');
    this.lsetReabte = new setReabte(this.app);
    // if(this.lsetReabte.getIsBS(this.agentId,this.ownerName,this.ownerUid)) this.cost = 0;//比赛免费
    this.lconfigCommon = new configCommon(this.app);
};

// 导出状态
Table.STATE = STATE;

//ts++ 结束模式
Table.ENDMODE = ENDMODE;

// 导出类
module.exports = Table;

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


// 是否站满
proto.isFull = function (playerId) {
    // return (this.lookers.length >= 1);
    // console.warn("是否站满   "+this.users.length);
    // console.warn("是否站满   "+JSON.stringify(this.users));
    return false;

    if(this.users.length > 0){
        // console.warn("是否站满222   ",this.users[0].id , playerId);
        if(this.users[0] && this.users[0].id == playerId) return false;
        return true;
    }

};

// 是否准备
proto.isReady = function () {
    for (let user of this.users) {
        if (!user || !user.isReady()) return false;
    }
    return true;
};

// ts++是否二次准备
proto.isReady2 = function () {
    // console.warn("sgjtable  是否二次准备");
    for (let user of this.users) {
        if (!user || !user.isReady2()) return false;
    }
    return true;
};

// 是否全在线
proto.isOnline = function () {
    for (let user of this.users) {
        if (user && user.isOffline()) return false;
    }
    return true;
};

// 重置本局
proto.resetRound = function () {
  
};

// 发送消息
proto.pushMsgAsync = cor(function* (cidOrIds, route, msg) {
    // console.warn("444WWWWWWWTTTTTT",cidOrIds, route, msg);
    var playerIds = [];
    if (Array.isArray(cidOrIds)) playerIds = cidOrIds;
    else {
        if (cidOrIds < 0 || cidOrIds >= this.users.length) {
            for (let user of this.users) {
                if (user) playerIds.push(user.id);
            }
            for (let lker of this.lookers) {
                playerIds.push(lker.id);
            }
        } else {
            let user = this.users[cidOrIds];
            if (user) playerIds.push(user.id);
            // console.warn("555WWWWWWWTTTTTT",cidOrIds, route, user.name);
        }
    }
    if (playerIds.length > 0) {
        let channelId = 'xct:' + this.id;
        // console.warn("666WWWWWWWTTTTTT",cidOrIds, route, playerIds,msg);
        return this.app.controllers.push._pushAsync(channelId, playerIds, route, msg);
    }
});

// 围观消息
proto.lookMsgAsync = cor(function* (route, msg) {
    var playerIds = [];
    for (let lker of this.lookers) {
        playerIds.push(lker.id);
    }
    if (playerIds.length > 0) {
        let channelId = 'xct:' + this.id;
        return this.app.controllers.push._pushAsync(channelId, playerIds, route, msg);
    }
});

// 获得桌子信息
proto.getTableInfo = function () {
    // console.warn(" table 获得桌子信息....  this.state "+this.state);
    // 桌子信息
    var tableInfo = {
        id: this.id,
        gameId: this.gameId,
        cost: this.cost,
        over: this.over,
        users: [],
        lookers: [],
        agentId: this.agentId,
        ownerUserId: this.ownerUid,////TL++,房主的userID
        ownerName: this.ownerName,//////TL++,房主的昵称
        ownerHeadUrl: this.ownerHeadUrl,//////TL++,房主的头像地址
        fpRes: this.fpRes,
        ydxfpRes: this.ydxfpRes,
        win: this.win,
        creatTime : this.ctime,
        nowTime : Date.now(),
        state: this.state,
        cardsPool : this.logic.cardsPool,
        cellList : this.logic.cellList,
        nowCell : this.logic.nowCell,
        yazhus: this.yazhus,
        prizePool: this.logic.prizePool,
        recordid:this.recordid,
        currentId: this.currentId,
        yxndlbTime:this.yxndlbTime,
        yxndlbTip:this.yxndlbTip,
    };
    
    // 桌上玩家
    for (let i = 0; i < this.users.length; ++i) {
        let user = this.users[i];
        if (user) {
            // console.warn("获得桌子信息里面的  user.taskQuan "+user.taskQuan);
            // let score = this.score.getScore(user.id);
            let score = 0;
            let uinfo = {
                account: user.account, name: user.name, sex: user.sex, headurl: user.headurl,
                diamond:user.diamond, state: user.state2, taskQuan: user.taskQuan, 
                drCount: user.drCount,chairId: user.chairId
            };
            console.warn("uinfo:",uinfo)
            tableInfo.users.push(uinfo);
        }
    }
    // 围观玩家
    for (let i = 0; i < this.lookers.length; ++i) {
        let user = this.lookers[i];
        if (user) {
            tableInfo.lookers.push({ account: user.account, name: user.name, sex: user.sex, headurl: user.headurl });
        }
    }
    return tableInfo;
};

// 回到桌子
proto.backAsync = cor(function* (user) {
    let str3 = "table回到桌子.......id:  "+ this.id + " user.chairId: " + user.chairId + " user.name: " + user.name ;
    logger.warn(str3);////cssj
    user.offlinetime=0;//ts++
    var data = { chairId: String(user.chairId) };
    var chairId = user.chairId;
    this.mrrstjsj = 0;//每日人数统计时间，用于判断在游戏和押大小时是否需要统计记录昨天的人数信息实现减少数据库访问
    yield this.tjbjlmryxrs();
    if (chairId != -1) {
        // 加入频道
        var connectorId = user.connectorId || '';
        if (connectorId) {
            let channelId = 'xct:' + this.id;
            yield this.app.controllers.push._joinAsync(channelId, user.id, connectorId);
        }
        // 恢复状态
        // if (this.state == STATE.FREE2) {//ts++二次准备
        //     //user.state = User.STATE.PLAYING;//ts--
        //     user.state2 = User.STATE.READY;
        //     yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.STATE_CHANGE, data: { chairId: String(user.chairId), state: String(user.state2), state2: String(user.state2) } });
        // }
        // user.state = User.STATE.READY;

        user.state2 = User.STATE.READY;
        if(this.state == STATE.PLAYING) user.state2 = User.STATE.PLAYING;
        // yield this.readyGameAsync(user);
        // 取消计时
        if (this.isOnline() && this.endTimer) {
            clearTimeout(this.endTimer);
            this.endTimer = null;
        }

    }
    // this.nowDiamond2 = user.diamond;//玩家目前游戏外的钻石（所有的减去带入的）
    // console.warn(" table 回到桌子....  this.state ",this.state,this.nowDiamond2,user.diamond);
    // 数据处理
    // data.fee = this.score.isFeed(user.id) ? '0' : '1';
    data.fee = '0';
    data.table = this.getTableInfo();
    return { code: C.OK, data: data };
});

// 创建玩家的排行信息
proto.creatPHBItem = cor(function* (user) {
    var paihang = yield this.app.models.SGJPaiHang.findByIdAsync(this.ownerId, 'name headurl');
    if (paihang) {
        if(paihang.name != user.name || paihang.headurl != user.headurl){
            paihang.name = user.name;
            paihang.headurl = user.headurl;
            yield paihang.saveAsync();
        }
    }
    else{
        var newpaihang = new this.app.models.SGJPaiHang({
            _id: this.ownerId, // 标识
            name: user.name,         // 昵称
            headurl: user.headurl,      // 头像
            userId: user.userId,                    // 号码
            cost1: 0,         // 最近一天总下注
            quan1: 0,         // 最近一天总得奖券
            time1: 0,   // 最近游戏那天的0点时间戳
            cost2: 0,         // 次近一天总下注
            quan2: 0,         // 次近一天总得奖券
            time2: 0   // 次近游戏那天的0点时间戳
        });
        // console.warn("创建玩家的排行信息   ");
        yield newpaihang.saveAsync();
    }
});

//重置数据，仅供开发测试时使用
// proto.czsjtest = cor(function* (user) {
//     let fields = 'cost1 quan1 time1 cost2 quan2 time2';
//     var paihang = yield this.app.models.SGJPaiHang.findByIdAsync(this.ownerId, fields);
//     if (paihang) {
//         paihang.cost2 = 0;
//         paihang.quan2 = 0;
//         paihang.time2 = 0;
//         paihang.cost1 = 10;
//         paihang.quan1 = 1;
//         paihang.time1 = 1712073600000;
//         console.warn("重置排行榜数据   ");
//         // yield paihang.saveAsync();
//     }
//     let sgjconfig = yield this.app.models.SGJConfig.findByIdAsync('sgconfigs');
//     if (sgjconfig) {
//         sgjconfig.phbyfjlrq = 0;  //排行榜已发奖励的日期（0点时间戳）
//         yield sgjconfig.saveAsync();
//     }
// })

proto.getYesterdaySJC = function (){
    var today = new Date();
    today.setHours(0);
    today.setMinutes(0);
    today.setSeconds(0);
    today.setMilliseconds(0);
    let jrsjc = today.getTime()- 24 * 60 * 60 * 1000;
    console.warn("getYesterdaySJC:",jrsjc)
    // console.warn("111得到今日0点的时间戳   ",jrsjc, typeof jrsjc);
    return jrsjc;
};

proto.getUSDTSum = cor(function* () {
    var today = new Date();
    today.setHours(0);
    today.setMinutes(0);
    today.setSeconds(0);
    today.setMilliseconds(0);
    let jrsjc = today.getTime()- 24 * 60 * 60 * 1000;

    jrsjc = today.getTime()
    console.warn("jrsjc:",jrsjc)
    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:jrsjc})
    var limit = 1000
    var page = 0
    var skip = 0
    var all = 0
    if (SGJUserTongjis.length >= 1) {
        for(;;) {
            skip = page * limit
            let players = yield this.app.models.Player.findMongoAsync({}, {}, {
                skip: skip,
                limit: Number(limit)
            });
            console.warn("players:",players.length)
            if (players.length > 0) {
                for (let player of players) {
                    console.warn("player.diamond:",player.diamond)
                    all += player.diamond
                    console.warn("all:",all)
                }
            }else {
                break
            }
            page += 1

        }
        SGJUserTongjis[0].usdt = all.toFixed(2)
        yield SGJUserTongjis[0].saveAsync()
    }
});

// 加入桌子
proto.joinAsync = cor(function* (user) {
    // 加入桌子之前
    // yield this.czsjtest();//正式服记得删除
    yield this.tjbjlmryxrs();
    yield this.beforeJoinAsync(user);
    yield this.creatPHBItem(user);
    let taskQuan = 0;//用户的任务券
    let drCount = 0;
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(user.id, 'taskQuan yazhuList jrkbcdrs drCount drTime lastJoinTime');
    if (!this.calculateTimer) {
        this.calculateTimer = this.app.timer.setTimeout(() => this.getUSDTSum(), 100000);
    }
    if (sgjUser) {
        sgjUser.drCount = sgjUser.drCount.toFixed(2)
        sgjUser.taskQuan = sgjUser.taskQuan.toFixed(2)
        taskQuan = sgjUser.taskQuan;
        // console.warn("加入桌子  taskQuan "+taskQuan+"  sgjUser.taskQuan "+sgjUser.taskQuan+"   "+ typeof(taskQuan)+"   "+ typeof(sgjUser.taskQuan) );
        this.yazhus = sgjUser.yazhuList//玩家本场押注情况
        let jrStart = this.logic.getTodaySJC();////今日0时的时间戳

        if(sgjUser.drTime == jrStart) {
            drCount = sgjUser.drCount.toFixed(2);
            console.warn("drCount:",drCount)
            let ssbkdrdd = user.diamond - drCount;//身上比可带入多的钻石
            // console.warn("加入桌子非今天首次000===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs+ "  user.diamond  "+user.diamond);
            if(ssbkdrdd > this.logic.dairuMax - sgjUser.drCount && this.logic.dairuMax - sgjUser.drCount > 0){
                ssbkdrdd = this.logic.dairuMax - sgjUser.drCount
            }
            if(ssbkdrdd < 0){
                //适合比如身上有14w钻石，带入10w之后，被系统扣钻了8w,那这时候数据表的drCount字段就要改了
                console.warn("457:",sgjUser.drCount)
                drCount = user.diamond.toFixed(2);//1分=10钻石，每日上限1w分）
                console.warn("457:",sgjUser.drCount)
                // console.warn("加入桌子非今天首次1===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
            }
            // console.warn("加入桌子非今天首次111===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
            if(ssbkdrdd >= this.logic.nowCell && sgjUser.jrkbcdrs > 0){
                let bckddrd = ssbkdrdd.toFixed(2);//本次可多带入的
                drCount = Number(drCount)+ Number(bckddrd);
                // sgjUser.jrkbcdrs -= bckddrd;
                // yield sgjUser.saveAsync();
                // console.warn("加入桌子非今天首次222===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
            }
        }
        else {
            if(user.diamond >= this.logic.dairuMax){
                drCount = this.logic.dairuMax.toFixed(2);//(钻石)
            }
            else{
                drCount = user.diamond.toFixed(2);//1分=10钻石，每日上限1w分）
                let ssbkdrdd = user.diamond - drCount;//身上比可带入多的钻石
                console.warn("ssbkdrdd:",ssbkdrdd)
                if(ssbkdrdd > this.logic.dairuMax - sgjUser.drCount){
                    ssbkdrdd = this.logic.dairuMax - sgjUser.drCount
                }
                // console.warn("加入桌子首次111===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
                if(ssbkdrdd >= this.logic.nowCell && sgjUser.jrkbcdrs > 0){
                    //let bckddrd = Math.floor(Math.floor(ssbkdrdd / this.logic.nowCell)*this.logic.nowCell);//本次可多带入的
                    let bckddrd = ssbkdrdd.toFixed(2)
                    console.warn("bckddrd:",bckddrd)
                    drCount += bckddrd;
                    // sgjUser.jrkbcdrs -= bckddrd;
                    // yield sgjUser.saveAsync();
                    // console.warn("加入桌子首次222===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
                }
            }
        }
        
    }
    else{
        console.warn("500")
        if(user.diamond >= this.logic.dairuMax){
            drCount = this.logic.dairuMax.toFixed(2);//(钻石)
        }
        else{
            console.warn("user.diamond;",user.diamond)
            drCount = user.diamond.toFixed(2);//1分=10钻石，每日上限1w分）
            console.warn("drCount",drCount)
        }
    }
    user.diamond = user.diamond.toFixed(2)
    let str3 = "加入水果 "+ this.nowDiamond2 +"  ud  "+user.diamond + " drCount " + drCount;      
    if(this.users.length == 0) {
        this.users[0] = user;
        // this.score.addUser(user.id,0,user.userId, user.name, user.sex, user.headurl,user.diamond,this.gameKindTL);
        user.chairId = 0;
        user.state = User.STATE.READY;
        user.state2 = User.STATE.READY;
        user.taskQuan = taskQuan.toFixed(2);
        user.drCount = drCount;
        // console.warn("加入桌子  user.taskQuan222 ",user.taskQuan,user.diamond);
        this.nowDiamond = user.diamond;//玩家目前游戏内的钻石（带入的）
        this.nowDiamond2 = user.diamond;//玩家目前游戏外的钻石（所有的减去带入的）
        str3 += "这里赋值 "+ this.nowDiamond2 +"  ud2  "+user.diamond; 
    }
    logger.warn(str3);////cssj
    // 加入桌子之后

    yield this.afterJoinAsync(user);
    // 数据返回处理
    var data = { chairId: String(user.chairId) };
    // data.fee = this.score.isFeed(user.id) ? '0' : '1';
    data.fee = '0';
    data.table = this.getTableInfo();
    return { code: C.OK, data: data };
});

// 加入桌子之前
proto.beforeJoinAsync = cor(function* (user) {
    var connectorId = user.connectorId || '';
    if (connectorId) {
        let channelId = 'xct:' + this.id;
        return this.app.controllers.push._joinAsync(channelId, user.id, connectorId);
    }
});

// 加入桌子之后
proto.afterJoinAsync = cor(function* (user) {
    // 加入通知
    return this.pushMsgAsync(-1, 'shuiguo_event', {
        type: M.JOIN, data: { account: user.account, userId: user.userId, name: user.name, sex: user.sex, headurl: user.headurl,playerPosList: this.playerPosList }
    });
});

// 玩家断线
proto.offlineAsync = cor(function* (user) {
    let str3 = "table 玩家断线.......id:  "+ this.id + " user.chairId: " + user.chairId + " user.name: " + user.name ;
    logger.warn(str3);////cssj
    if (user.chairId != -1) {
        //user.state = User.STATE.OFFLINE;//ts--
        user.state2 = User.STATE.OFFLINE;//ts++
        // this.leaveUsers.push(user.id);
        user.offlinetime = Date.now();//ts++断线
        var channelId = 'xct:' + this.id;
        // console.warn(" table 玩家断线....  this.state "+this.state);
        yield this.app.controllers.push._quitAsync(channelId, user.id);
        // yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.STATE_CHANGE, data: { chairId: String(user.chairId), state: String(user.state2), state2: String(user.state2) } });
        // 无人在线
        // console.warn("提前结算666");
        //if (this.isOffline()) return this.overTimeAsync(MODE.OFFLINE);
        // console.warn("玩家断线-------定时器启动");
        // 计时结算
        let lxjssj = 600000;//断线解散时间
        if (!this.endTimer) this.endTimer = this.app.timer.setTimeout(() => this.overTimeAsync(ENDMODE.OFFLINEEND),lxjssj);/////断线3分钟自动结算
        // let str4 = "table 玩家断线---id:"+this.id + ",uid"+user.userId+"   "+ this.state;
        // logger.info(str4);////cssj
    }
});

//ts++断线结束定时器
proto.overTimeAsync = cor(function* (endmode) {
    // console.warn("sgtable  断线结束定时器",endmode);
    yield this.endResultAsync(endmode);//ts++ 房主解散  写分
});

// 记录钻石记录
proto.zsbgjlAsync = cor(function* (user, chairId) {
    // console.warn("记录钻石记录----   ",this.wjcsDiamond)
    let str3 = "table 记录钻石记录.......id:  "+ this.id + " wjcsz  " + this.wjcsDiamond + " user.chairId: " + user.chairId + " user.name: " + user.name ;
    logger.warn(str3);////cssj
    // 站起通知
    if(this.wjcsDiamond >= 0){
        let wjxzzs = Number(this.nowDiamond) + Number(this.nowDiamond2);
        let gbsz = wjxzzs - this.wjcsDiamond;
        // let str1 = "table 记录钻石记录111.......id:  "+ this.id + " nd  " + this.nowDiamond + " nd2: " + this.nowDiamond2;
        // logger.warn(str1);////cssj
        // console.warn("记录钻石记录   ",this.wjcsDiamond,wjxzzs,user.diamond,gbsz);
        // let str2 = "table 记录钻石记录222.......id:  "+ this.id + " wjcsz  " + this.wjcsDiamond + " wjxzzs: " + wjxzzs + " ud: " + user.diamond + "  gbsz  "+ gbsz;
        // logger.warn(str2);////cssj
        if(gbsz != 0){
            var diamondrecord = new this.app.models.DiamondRecord({
                _id: uuid.v1(),
                playerId: user.id,
                dType: 20,//水果游戏
                dSource: this.wjcsDiamond,
                dSwap: gbsz.toFixed(2),
                dNow: wjxzzs.toFixed(2),
                tableId: this.recordid
            });
            console.warn("597:",diamondrecord)
            yield diamondrecord.saveAsync();
            this.wjcsDiamond = -1;
            // console.warn("站起桌子之后 保存钻石记录完成  ",this.wjcsDiamond,wjxzzs,user.diamond,gbsz);
        }
    }
    //下面是记录每日统计
    let sjbdlx = 0;//数据变动类型
    if(this.zqqCost > 0) sjbdlx = 1;
    if(this.ydxCost > 0) sjbdlx = 2;
    if(this.rwxhjq1 > 0) sjbdlx = 3;
    if(this.rwxhjq2 > 0) sjbdlx = 4;
    if(this.rwdcze1 > 0) sjbdlx = 5;
    if(this.rwdcze2 > 0) sjbdlx = 6;
    // console.warn(">下面是记录统计数据   ",sjbdlx,this.zqqCost);
    if(sjbdlx > 0){
        let jrStart = ""+this.logic.getTodaySJC();////更新今日0时的时间戳
        var sgmrtj = yield this.app.models.SGJMRTJ.findByIdAsync(jrStart);
        if (sgmrtj) {
            sgmrtj.zqqCost = (Number(sgmrtj.zqqCost)+Number(this.zqqCost)).toFixed(2);  //所有玩家游戏转圈总下注
            sgmrtj.zqqwin = (Number(sgmrtj.zqqwin)+Number(this.zqqwin)).toFixed(2);   //所有玩家游戏转圈总赢得
            sgmrtj.zqqxh = (Number(sgmrtj.zqqxh)+Number(this.zqqxh)).toFixed(2);    //所有玩家游戏转圈总消耗（总赢得 - 总下注）
            sgmrtj.ydxCost = (Number(sgmrtj.ydxCost)+Number(this.ydxCost)).toFixed(2);  //所有玩家押大小总下注
            sgmrtj.ydxwin = (Number(sgmrtj.ydxwin)+Number(this.ydxwin)).toFixed(2);   //所有玩家押大小总赢得
            sgmrtj.ydxxh = (Number(sgmrtj.ydxxh)+Number(this.ydxxh)).toFixed(2);    //所有玩家押大小总消耗（总赢得 - 总下注）
            sgmrtj.ydxzcs = (Number(sgmrtj.ydxzcs)+Number(this.ydxzcs)).toFixed(2);   //该日押大小总次数
            sgmrtj.allrwq = (Number(sgmrtj.allrwq )+ Number(this.allrwq)).toFixed(2);   //所有奖券产生总量

            sgmrtj.rwxhjq1 = (Number(sgmrtj.rwxhjq1)+Number(this.rwxhjq1)).toFixed(2); //钻石任务消耗奖券总量（领任务时记录）
            sgmrtj.rwxhjq2 = (Number(sgmrtj.rwxhjq2)+Number(this.rwxhjq2)).toFixed(2);  //RMB任务消耗奖券总量（领任务时记录）
            sgmrtj.rwdcze1 =  (Number(sgmrtj.rwdcze1)+Number(this.rwdcze1)).toFixed(2);  //钻石任务兑出总额（领奖时记录）
            sgmrtj.rwdcze2 =  (Number(sgmrtj.rwdcze2)+Number(this.rwdcze2)).toFixed(2);  //RMB（分）任务兑出总额（领奖时记录）
            yield sgmrtj.saveAsync();
            // console.warn("更改每日  ",sgmrtj);
        }
        else{
            var sGJMRTJ = new this.app.models.SGJMRTJ({
                _id: jrStart,                  // 标识
                zqqCost: this.zqqCost,  //所有玩家游戏转圈总下注
                zqqwin: this.zqqwin,   //所有玩家游戏转圈总赢得
                zqqxh: this.zqqxh,    //所有玩家游戏转圈总消耗（总赢得 - 总下注）
                ydxCost: this.ydxCost,  //所有玩家押大小总下注
                ydxwin: this.ydxwin,   //所有玩家押大小总赢得
                ydxxh: this.ydxxh,    //所有玩家押大小总消耗（总赢得 - 总下注）
                ydxzcs: this.ydxzcs,   //该日押大小总次数
                allrwq: this.allrwq,   //所有奖券产生总量   
                rwxhjq1: this.rwxhjq1,  //钻石任务消耗奖券总量（领任务时记录）
                rwxhjq2: this.rwxhjq2,  //RMB任务消耗奖券总量（领任务时记录）
                rwdcze1: this.rwdcze1,  //钻石任务兑出总额（领奖时记录）
                rwdcze2: this.rwdcze2,  //RMB（分）任务兑出总额（领奖时记录）
                registerTime: jrStart,// 记录时间（该日0点时间戳）
            });
            yield sGJMRTJ.saveAsync();
            // console.warn("创建每日  ",sGJMRTJ);
        }
        //下面是记录总记录数据
        let sgjztj = yield this.app.models.SGJTongji.findByIdAsync('sgztj');
        if (sgjztj) {
            sgjztj.allCost += this.allCost;  //所有玩家总下注
            sgjztj.allwin += this.allwin;   //所有玩家总赢得
            sgjztj.allxh += this.allxh;    //所有玩家总消耗（总下注-总赢得）
            sgjztj.zqqCost += this.zqqCost;  //所有玩家游戏转圈总下注
            sgjztj.zqqwin += this.zqqwin;   //所有玩家游戏转圈总赢得
            sgjztj.zqqxh += this.zqqxh;    //所有玩家游戏转圈总消耗（总赢得 - 总下注）
            sgjztj.ydxCost += this.ydxCost;  //所有玩家押大小总下注
            sgjztj.ydxwin += this.ydxwin;   //所有玩家押大小总赢得
            sgjztj.ydxxh += this.ydxxh;    //所有玩家押大小总消耗（总赢得 - 总下注）
            sgjztj.allrwq += Number(this.allrwq);   //所有奖券产生总量
            sgjztj.rwxhjq1 += this.rwxhjq1;  //钻石任务消耗奖券总量（领任务时记录）
            sgjztj.rwxhjq2 += this.rwxhjq2;  //RMB任务消耗奖券总量（领任务时记录）
            sgjztj.rwxhjq3 = 0;  //备用任务1消耗奖券总量（领任务时记录）
            sgjztj.rwxhjq4 = 0;  //备用任务2消耗奖券总量（领任务时记录）
            sgjztj.rwdcze1 += this.rwdcze1;  //钻石任务兑出总额（领奖时记录）
            sgjztj.rwdcze2 += this.rwdcze2;  //RMB（分）任务兑出总额（领奖时记录）
            sgjztj.rwdcze3 = 0;  //备用任务兑出总额（领奖时记录）
            sgjztj.rwdcze4 = 0;  //备用任务兑出总额（领奖时记录）
            let cwindx = 0;
            if(sgjztj.allyzze.length != this.allyzze.length) cwindx = 1;
            if(sgjztj.allydze.length != this.allydze.length) cwindx = 2;
            if(sgjztj.gxzydze.length != this.gxzydze.length) cwindx = 3;
            if(sgjztj.gxcxzcs.length != this.gxcxzcs.length) cwindx = 4;
            if(sgjztj.tsxzydze.length != this.tsxzydze.length) cwindx = 5;
            if(sgjztj.tsxcxzcs.length != this.tsxcxzcs.length) cwindx = 6;
            if(cwindx == 0){
                let allyzze = [];
                let allydze = [];
                let gxzydze = [];
                let gxcxzcs = [];
                let tsxzydze = []; 
                let tsxcxzcs = []; 
                // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
                for (var i = 0; i < sgjztj.allyzze.length; i++) {
                    allyzze[i] = sgjztj.allyzze[i] + this.allyzze[i];
                }
                for (var i = 0; i < sgjztj.allydze.length; i++) {
                    allydze[i] = sgjztj.allydze[i] + this.allydze[i];
                }
                // 下面这两个数据是长度为16的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
                //小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
                for (var i = 0; i < sgjztj.gxzydze.length; i++) {
                    gxzydze[i] = sgjztj.gxzydze[i] + this.gxzydze[i];
                }
                for (var i = 0; i < sgjztj.gxcxzcs.length; i++) {
                    gxcxzcs[i] = sgjztj.gxcxzcs[i] + this.gxcxzcs[i];
                }
                // 下面这两个数据是长度为3的数组，分别代表[小三元,小三元,大四喜]
                for (var i = 0; i < this.tsxzydze.length; i++) {
                    tsxzydze[i] = sgjztj.tsxzydze[i] + this.tsxzydze[i];
                }
                for (var i = 0; i < this.tsxcxzcs.length; i++) {
                    tsxcxzcs[i] = sgjztj.tsxcxzcs[i] + this.tsxcxzcs[i];
                }
                sgjztj.allyzze = _.cloneDeep(allyzze);
                sgjztj.allydze = _.cloneDeep(allydze);
                sgjztj.gxzydze = _.cloneDeep(gxzydze);
                sgjztj.gxcxzcs = _.cloneDeep(gxcxzcs);
                sgjztj.tsxzydze = _.cloneDeep(tsxzydze);
                sgjztj.tsxcxzcs = _.cloneDeep(tsxcxzcs);

            }
            else{
                let nowTime = Date.now();
                let errstr = "cdbyz:"+cwindx+",sj:"+nowTime+",fh:"+this.id;
                sgjztj.errstr += errstr;

            }
            yield sgjztj.saveAsync();
            // console.warn("更改总的  ",cwindx,sgjztj);
        }
        else{
            var sgjtj = new this.app.models.SGJTongji({
                allCost: this.allCost,  //所有玩家总下注
                allwin: this.allwin,   //所有玩家总赢得
                allxh: this.allxh,    //所有玩家总消耗（总下注-总赢得）
                zqqCost: this.zqqCost,  //所有玩家游戏转圈总下注
                zqqwin: this.zqqwin,   //所有玩家游戏转圈总赢得
                zqqxh: this.zqqxh,    //所有玩家游戏转圈总消耗（总赢得 - 总下注）
                ydxCost: this.ydxCost,  //所有玩家押大小总下注
                ydxwin: this.ydxwin,   //所有玩家押大小总赢得
                ydxxh: this.ydxxh,    //所有玩家押大小总消耗（总赢得 - 总下注）
                allrwq: this.allrwq,   //所有奖券产生总量   
                rwxhjq1: this.rwxhjq1,  //钻石任务消耗奖券总量（领任务时记录）
                rwxhjq2: this.rwxhjq2,  //RMB任务消耗奖券总量（领任务时记录）
                rwxhjq3: 0,  //备用任务1消耗奖券总量（领任务时记录）
                rwxhjq4: 0,  //备用任务2消耗奖券总量（领任务时记录）
                rwdcze1: this.rwdcze1,  //钻石任务兑出总额（领奖时记录）
                rwdcze2: this.rwdcze2,  //RMB（分）任务兑出总额（领奖时记录）
                rwdcze3: 0,  //备用任务兑出总额（领奖时记录）
                rwdcze4: 0,  //备用任务兑出总额（领奖时记录）
                // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
                allyzze: _.cloneDeep(this.allyzze),                  //总押注总额列表
                allydze: _.cloneDeep(this.allydze),                  //总赢得总额列表(不包含特殊项)
                // 下面这两个数据是长度为16的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
                //小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
                gxzydze: _.cloneDeep(this.gxzydze),                  //各项总赢得总额列表(不包含特殊项)
                gxcxzcs: _.cloneDeep(this.gxcxzcs),                  //各项出现总次数列表(不包含特殊项)
                // 下面这两个数据是长度为3的数组，分别代表[小三元,小三元,大四喜]
                tsxzydze: _.cloneDeep(this.tsxzydze),                //特殊项总赢得总额列表
                tsxcxzcs: _.cloneDeep(this.tsxcxzcs),                //特殊项出现总次数列表
            });
            yield sgjtj.saveAsync();
            // console.warn("创建总的  ",sgjtj);
        }
    }
    // yield this.app.models.SGJMRTJ.removeAsync({_id : "1713715200000"});
    // yield this.app.models.SGJTongji.removeAsync({_id : "sgztj"});
    // yield this.app.models.SGJPaiHang.removeAsync({_id : "dfcb8e16-a05a-c26e-a9af-29a0a1fd0d86"});
    // let str0 = "table 记录钻石记录结束.......id:  "+ this.id + " sjbdlx  " + sjbdlx;
    // logger.warn(str0);////cssj
});

// 站起桌子之后
proto.afterStandAsync = cor(function* (user, chairId) {
    // 站起通知
    // yield this.pushMsgAsync(-1, 'csjiang_event', { type: M.STAND, data: { chairId: String(chairId) } });
    if(user.cost==0 && user.spreadId)//ts++推荐人奖励
    {
        ////20200928因为现在的spreadId存的是userId，所以上面那段用不了了
        if(!this.lconfigCommon) {
            // console.warn("邀请新人送钻石活动  this.lconfigCommon 不存在 "+this.etime);
            this.lconfigCommon = new configCommon(this.app);
        }
        let yxhdxx = this.lconfigCommon.getActiveOpenTime(1);//邀请新人送钻石活动是否开启和开始结束时间的信息
        let isKQ = false;//邀请新人送钻石活动是否开启
        if(yxhdxx && yxhdxx.open && yxhdxx.startTime && yxhdxx.endTime) isKQ = true;
        // console.warn("获取配置信息   yxhdxx "+JSON.stringify(yxhdxx));
        if(isKQ && this.etime >= yxhdxx.startTime && this.etime < yxhdxx.endTime){
            var cpopts = {};
            cpopts['userId'] = parseInt(user.spreadId);
            let spreadList = yield this.app.models.Player.findMongoAsync(cpopts, 'spreadCount spreadRebate', { sort: { stime: 1 } });//
            if(spreadList.length == 1){
                spreadList[0].spreadCount += 1;
                spreadList[0].spreadRebate += 100;
                yield spreadList[0].saveAsync();
            }
        }
    }
    yield this.lsetReabte.updateDaterebateRecord(this.agentId,this.etime);
});

// 离开桌子
proto.leaveAsync = cor(function* (user) {
    let str3 = "table 离开桌子.......id:  "+ this.id + " user.chairId: " + user.chairId + " user.name: " + user.name ;
    logger.warn(str3);////cssj
    // this.leavePlayerID = user.id;//////TL++,旁观为房主的话离开之后由于从观战者列表里面删除了，导致发消息的时候他收不到离开桌子的消息
    // console.warn("离开桌子、、、、、、、");
    yield this.beforeLeaveAsync(user);
    var chairId = user.chairId;
    // yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.LEAVE, data: { account: user.account } });/////TL++zs，原来在下面
    if (chairId != -1) {
        delete this.users[chairId];
        yield this.afterStandAsync(user, chairId);
    } else {
        let pos = _.findIndex(this.lookers, (u) => (u.id == user.id));
        if (pos != -1) this.lookers.splice(pos, 1);
    }
    return this.afterLeaveAsync(user);
});

// 离开桌子之前
proto.beforeLeaveAsync = cor(function* (user) {
    var channelId = 'xct:' + this.id;
    return this.app.controllers.push._quitAsync(channelId, user.id);
});

// 离开桌子之后
proto.afterLeaveAsync = cor(function* (user) {
   
    // 离开通知
    /////TL++zsyl 在此之前离开玩家已经从玩家列表或者旁观者列表中删除了所以把下面这句提到前面去了
    return this.pushMsgAsync(-1, 'shuiguo_event', { type: M.LEAVE, data: { account: user.account } });
});

// 玩家准备（结束本小局）
proto.readyGameAsync = cor(function* (user) {
    let str1 = "table 玩家准备.......id:  "+ this.id + " user.chairId: " + user.chairId + " this.over: " + this.over + " user.name: " + user.name ;
    logger.warn(str1);////cssj
    let endmode=ENDMODE.PLAYING;
    yield this.endResultAsync(endmode);
    let data = {
        state: this.state,
        win:this.win
    }
    let str3 = "table 玩家准备222.......id:  "+ this.id + " state: " + data.state ;
    logger.warn(str3);////cssj
    yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.STATE_CHANGE, data: data });
    this.win = 0;//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
    // yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.STATE_CHANGE, data: { chairId: String(user.chairId), state: String(user.state2), state2: String(user.state2) } });
    return { code: C.OK, data:data };
});

// 请求结束（前端点击返回大厅）
proto.overTableAsync = cor(function* (user) {
    // console.warn("ts+++++请求结束",user.chairId);
    let str3 = "cstable 请求结束.......id:  "+ this.id + " user.chairId: " + user.chairId + " user.name: " + user.name ;
    logger.warn(str3);////cssj
    user.state = User.STATE.FREE;
    user.state2 = User.STATE.FREE;
    this.state = STATE.END;
    let diamond = 0;
    if(user) diamond = user.diamond || 0;
    // this.leaveAsync(user);
    return { code: C.OK, data:{diamond:diamond}};//离开房间
});

// 得到战绩
proto.getRecordAsync = P.coroutine(function* (user) {
    // console.warn("得到战绩   "+user.id);
    var opts = { 
        ownerId:user.id//time: { $gte: startTime, $lt: endTime },
        
    };
    var list = yield this.app.models.SGJTables.findMongoAsync(opts, 'ownerId time gameCost yazhuList resultList winsList win bsIndex scoreBefore scoreEnd', { sort: { time: -1 } ,limit:25});
    // console.warn("战绩-------------------length",list.length);
    let records = [];
    let nowTime = Date.now();//当前时间戳  
    for (let i = 0; i < list.length; ++i) {
        // console.warn("战绩条目    "+i+"    "+JSON.stringify(list[i]));
        if(list[i].time + 8000 > nowTime) continue;
        let item = {
            time:list[i].time,
            gameCost:list[i].gameCost,
            yazhuList:list[i].yazhuList, 
            resultList:list[i].resultList,
            win:list[i].scoreEnd - list[i].scoreBefore,
            bsIndex:list[i].bsIndex
        }
        records[records.length] = item;
        if(records.length == 24) break;
    }
    return { code: C.OK,data: {records:records } };
});

//得到玩家截至今日零点总充值数量（分）
proto.getjzjrldzcz = cor(function* () {
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    let totalMoney = 0;//该玩家目前总充值
    let jzjrldzcz = 0;// 玩家截至今日零点总充值数量（分），用于判断任务
    let player = yield this.app.models.Player.findByIdAsync(this.ownerId, 'totalMoney');
    if (player) totalMoney = player.totalMoney;
    if(totalMoney > 0){
        let jrgwjzcz = 0;//今日该玩家总充值
        let opts3 = { 
            playerId: this.ownerId,
            paystate: 1,
            time: { $gte: jrStart, $lt: jrStart+86400000}
        };
        let jrpayList = yield this.app.models.PayRecord.findMongoAsync(opts3,"total_fee")
        if(jrpayList.length > 0){
            for (var i = 0; i < jrpayList.length; i++) {
                jrgwjzcz += jrpayList[i].total_fee;
            }
        }
        // console.warn("得到玩家截至今日零点总充值数量（分）  ",jzjrldzcz , totalMoney , jrgwjzcz);
        if(totalMoney - jrgwjzcz >= 0) jzjrldzcz = totalMoney - jrgwjzcz;
        else{
            let str3 = "得到历史充值错误  "+ jrgwjzcz + " this.ownerId: " + this.ownerId + " totalMoney: " + totalMoney ;
            logger.warn(str3);////cssj
        }
    }
    // console.warn("得到玩家截至今日零点总充值数量（分）222  ",jzjrldzcz , totalMoney );
    return jzjrldzcz;
});

// 处理前端带入函数
proto.dairuAsync = cor(function* (playerId,chairId) {
    // console.warn("带入 this.nowDiamond2  ",this.nowDiamond2);
    let str1 = "table 带入1---id:"+this.id +" 当前局 "+ (this.over+1)+"  nd2  "+this.nowDiamond2;
    logger.warn(str1);////cssj
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.CHAIR_NOT_FOUND };
    }
    let str2 = "table 带入2---id:"+this.id +" 当前局 "+ this.over+"  ud  "+user.diamond;;
    logger.warn(str2);////cssj
    //下面是统计数据赋初始值
    this.zqqCost = 0;  //所有玩家游戏转圈总下注
    this.zqqwin = 0;   //所有玩家游戏转圈总赢得
    this.zqqxh = 0;    //所有玩家游戏转圈总消耗（总下注-总赢得）
    this.ydxCost = 0;  //所有玩家押大小总下注
    this.ydxwin = 0;   //所有玩家押大小总赢得
    this.ydxxh = 0;    //所有玩家押大小总消耗（总下注-总赢得）
    this.ydxzcs = 0;   //该日押大小总次数
    this.allrwq = 0;   //所有奖券产生总量   
    this.rwxhjq1 = 0;  //钻石任务消耗奖券总量（领任务时记录）
    this.rwxhjq2 = 0;  //RMB任务消耗奖券总量（领任务时记录）
    this.rwdcze1 = 0;  //钻石任务兑出总额（领奖时记录）
    this.rwdcze2 = 0;  //RMB（分）任务兑出总额（领奖时记录）
    this.allCost = 0;  //所有玩家总下注
    this.allwin = 0;   //所有玩家总赢得
    this.allxh = 0;    //所有玩家总消耗（总下注-总赢得）
    
    // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
    this.allyzze = []; //总押注总额列表
    this.allydze = []; //总赢得总额列表(不包含特殊项)
    for (var i = 0; i < 8; i++) {
        this.allyzze[i] = 0; //总押注总额列表
        this.allydze[i] = 0; //总赢得总额列表(不包含特殊项)
    }
    // 下面这数据是长度为17的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
    //幸运运,小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
    this.gxzydze = []; //总赢得总额列表(不包含特殊项)
    this.gxcxzcs = []; //出现总次数列表(不包含特殊项)
    for (var i = 0; i < this.logic.cardKindCount; i++) {
        this.gxzydze[i] = 0; //各项总赢得总额列表(不包含特殊项)
        this.gxcxzcs[i] = 0; //各项出现总次数列表(不包含特殊项)
    }
    // 下面这两个数据是长度为3的数组，分别代表[小三元,小三元,大四喜]
    this.tsxzydze = [0,0,0];                  //特殊项总赢得总额列表
    this.tsxcxzcs = [0,0,0];                 //特殊项出现总次数列表

    let sgjconfig = yield this.app.models.SGJConfig.findByIdAsync('sgconfigs');
    if (sgjconfig) {
        this.phbyfjlrq = sgjconfig.phbyfjlrq;  //排行榜已发奖励的日期（0点时间戳）
        // console.warn("获取水果机排行榜已发奖励的日期   ",this.phbyfjlrq);
    }
    else{
        this.phbyfjlrq = this.logic.getTodaySJC() - 86400000;  //排行榜已发奖励的日期（0点时间戳）
        var newconfig = new this.app.models.SGJConfig({
            _id: 'sgconfigs',
            phbyfjlrq: this.phbyfjlrq
        });
        yield newconfig.saveAsync();
        // console.warn("创建水果机排行榜已发奖励的日期   ");
    }
    this.wjrwxylb = _.fill(Array(this.logic.cardKindCount), 0);//玩家已领未完成任务需要的任务要求列表
    let opts0 = { 
        playerId: playerId,
        state:0,//已领未完成
    };
    var ylwwcrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, 'reachs reachC state');
    if(ylwwcrwList.length > 0){
        for (var i = 0; i < ylwwcrwList.length; i++) {
            let rwyq = ylwwcrwList[i].reachs;//任务要求类型列表
            for (var j = 0; j < rwyq.length; j++) {
                let rwyqlx = rwyq[j];//任务要求类型
                let rwyqsl = ylwwcrwList[i].reachC[j];//任务要求类型
                this.wjrwxylb[rwyqlx] += rwyqsl;
            }
        }
    }
    // console.warn("玩家已领未完成任务需要的任务要求列表  ",ylwwcrwList.length,this.wjrwxylb);
    //统计数据赋初始值结束
    if(this.over > 0){
        var data = { 
            diamond: this.nowDiamond2,
            drCount: user.drCount - this.win,
        }
        this.wjcsDiamond = user.diamond;//玩家进入房间初始的钻石数，用于判断离开的时候是否需要记录钻石变更
        return { code: C.OK, data: data };
    }
    let drCount = Number(0);
    let nowTime = Date.now();//当前时间戳  
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(this.ownerId, 'jrkbcdrs drCount drTime jzjrldzcz jzjrldzczjlsj lastJoinTime');
    if (sgjUser) {
        // console.warn("带入   ",sgjUser.jzjrldzczjlsj,sgjUser.drTime);
        if(sgjUser.jzjrldzczjlsj != jrStart){
            let jzjrldzcz = yield this.getjzjrldzcz();
            sgjUser.jzjrldzcz = jzjrldzcz;
            sgjUser.jzjrldzczjlsj = jrStart;
        }
        sgjUser.drCount = sgjUser.drCount.toFixed(2)
        if(sgjUser.drTime == jrStart){
            if(this.nowDiamond2 >= sgjUser.drCount){
                drCount = sgjUser.drCount.toFixed(1);
                let ssbkdrdd = this.nowDiamond2 - drCount;//身上比可带入多的钻石
                if(ssbkdrdd > this.logic.dairuMax - sgjUser.drCount && this.logic.dairuMax - sgjUser.drCount > 0){
                    ssbkdrdd = this.logic.dairuMax - sgjUser.drCount
                }
                if(ssbkdrdd < 0){
                    //适合比如身上有14w钻石，带入10w之后，被系统扣钻了8w,那这时候数据表的drCount字段就要改了
                    drCount = Math.floor(user.diamond / this.logic.nowCell)*this.logic.nowCell;//1分=10钻石，每日上限1w分）
                    sgjUser.drCount = drCount;
                    sgjUser.lastJoinTime = nowTime;   // 玩家上次进入果游戏时间(留存人数)
                    yield sgjUser.saveAsync();
                }
                // console.warn("带入函数111===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
                // console.warn("带入  ？？？ ",sgjUser.jzjrldzcz,sgjUser.jzjrldzczjlsj);
                if(ssbkdrdd >= this.logic.nowCell && sgjUser.jrkbcdrs > 0){
                    let bckddrd = Math.floor(ssbkdrdd / this.logic.nowCell)*this.logic.nowCell;//本次可多带入的
                    console.warn("bckddrd:",bckddrd," drCount:",drCount)
                    drCount = Number(drCount)+ Number(bckddrd);
                    console.warn("bckddrd:",bckddrd," drCount:",drCount)
                    sgjUser.drCount = drCount;
                    sgjUser.jrkbcdrs -= bckddrd;
                    sgjUser.lastJoinTime = nowTime;   // 玩家上次进入果游戏时间(留存人数)
                    yield sgjUser.saveAsync();
                    // console.warn("带入函数222===  drCount "+drCount+" ssbkdrdd "+ssbkdrdd+" sgjUser.jrkbcdrs "+sgjUser.jrkbcdrs);
                }
            } 
            else{
                drCount = Math.floor(user.diamond / this.logic.nowCell)*this.logic.nowCell;//1分=10钻石，每日上限1w分）
                sgjUser.drCount = drCount;
                sgjUser.lastJoinTime = nowTime;   // 玩家上次进入果游戏时间(留存人数)
                yield sgjUser.saveAsync();
                let str3 = "带入出错了 this.nowDiamond2 "+ this.nowDiamond2 +"  ud  "+user.diamond + " sgjUser.drCount " + sgjUser.drCount;
                logger.error(str3);////cssj
                //return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
            }
        }
        else {
            if(this.nowDiamond2 >= this.logic.dairuMax){
                drCount = this.logic.dairuMax;//(钻石)
            }
            else{
                drCount = Math.floor(this.nowDiamond2 / this.logic.nowCell)*this.logic.nowCell;//1分=10钻石，每日上限1w分）
            }
            // console.warn("带入  到乐乐 ",sgjUser.jzjrldzczjlsj,sgjUser.drTime);
            let jrkbcdrs = this.logic.dairuMax - drCount;
            sgjUser.jrkbcdrs = jrkbcdrs;
            sgjUser.drCount = drCount;
            sgjUser.drTime = jrStart;
            sgjUser.lastJoinTime = nowTime;   // 玩家上次进入果游戏时间(留存人数)
            yield sgjUser.saveAsync();
        }
    }
    else{
        let jrkbcdrs = 0;
        if(this.nowDiamond2 >= this.logic.dairuMax){
            drCount = this.logic.dairuMax;//(钻石)
        }
        else{
            drCount = Math.floor(this.nowDiamond2 / this.logic.nowCell)*this.logic.nowCell;//1分=10钻石，每日上限1w分）
            jrkbcdrs = this.logic.dairuMax - drCount;
        }
        let jzjrldzcz = yield this.getjzjrldzcz();
        var newsgjUser = new this.app.models.SGJUser({
            _id: this.ownerId, // 标识
            userId: Number(user.userId), // 号码
            cost: 0, // 消费
            win: 0, // 总赢得分
            zfbAcc: "",       // 支付宝账号
            zfbName: "",      // 支付宝姓名
            zfbBindTime: 0,   // 玩家支付宝信息正确性验证成功时间(0时表示验证未通过)
            gameCount: 0,     // 总小局次数
            wingames: 0,      // 总赢的小局次数
            taskReward: 0,    // 已获得的任务奖励
            taskQuan: 0,  // 任务券（用于领任务）
            yazhuList: [], // 上局押注列表
            getList: [],  // 获得的列表(用于计算任务是否完成)
            getTime: 0,       // 获得列表更新的时间
            jrkbcdrs:jrkbcdrs,  // 今日可补充带入数量
            drCount: drCount,       // 带入数量(钻石)（1分=10钻石，每日上限1w分）
            drTime: jrStart,        // 带入时间
            jzjrldzcz: jzjrldzcz,
            jzjrldzczjlsj: jrStart,
            registerTime: nowTime,            // 玩家首次进入水果游戏时间
            lastJoinTime: nowTime,   // 玩家上次进入果游戏时间(留存人数)
            lastPlayTime: 0,    // 玩家上次玩水果游戏时间(用于统计有效人数)
            lastYDXTime: 0    // 玩家上次水果押大小时间(用于统计有效人数)
        });
        yield newsgjUser.saveAsync();
    }
    this.wjcsDiamond = this.nowDiamond2;//user.diamond;//玩家进入房间初始的钻石数，用于判断离开的时候是否需要记录钻石变更
    // console.warn("玩家进入之后记录初始钻石数   ",this.wjcsDiamond,this.nowDiamond,this.nowDiamond2);
    this.nowDiamond = Number(drCount);
    console.warn(" this.nowDiamond2:", this.nowDiamond2, " drCount:",drCount)
    this.nowDiamond2 -= Number(drCount);
    console.warn(" this.nowDiamond2:", this.nowDiamond2)
    if(this.nowDiamond2 < 0){
        let str4 = "table 带入出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  nd2  "+this.nowDiamond2;
        logger.warn(str4);////cssj
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    console.warn("this.nowDiamond2:",this.nowDiamond2)
    console.warn("drCount:",drCount)
    var data = { 
        diamond: this.nowDiamond2.toFixed(2),
        drCount: drCount,
    }
    console.warn("data:",data)
    return { code: C.OK, data: data };
});

// 开始游戏
proto.startGameAsync = cor(function* (yazhus) {
    let str4 = "table 开始游戏---id:"+this.id +" 当前局 "+ (this.over+1)+"  nowDiamond  "+this.nowDiamond+"  yazhus  "+JSON.stringify(yazhus);
    logger.warn(str4);////cssj
    // 状态设置
    //现在钻石数量   玩家初始钻石数量不得小于0
    let wh = yield this.app.models.WHstate.findByIdReadOnlyAsync('wh', 'stateWH whTip');
    // console.warn("22检查是否维护状态",whdata);
    if (wh) {
        // console.warn("--33检查是否维护状态",whdata.stateWH,whdata.whTip);
        if(wh.stateWH){
            /////维护状态中
            return { code: C.SERVER_WEIHU, tip: wh.whTip };
        }
    }
    if(this.nowDiamond2 < 0 || this.wjcsDiamond < 0){
        let str1 = "table nowDiamond2出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  nd2  "+this.nowDiamond2+"  csd  "+this.wjcsDiamond;
        logger.warn(str1);////cssj
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    //押注长度必须为8
    if(yazhus.length != 8){
        let str = "table 押注长度出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  this.ownerUid  "+this.ownerUid+"  yazhus  "+JSON.stringify(yazhus);
        logger.warn(str);////cssj
        return { code: C.FAILD, msg: "押注长度出错了   前端的问题  "+JSON.stringify(yazhus) };
    }

    //押注值必须为10的倍数
    for (var i = 0; i < yazhus.length; i++) {
        yazhus[i] = parseFloat(yazhus[i].toFixed(2));
        if(((yazhus[i]*1000)%(this.logic.nowCell*1000)) != 0){
            let str = "table 押注数值出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  this.ownerUid  "+this.ownerUid+"  yazhus  "+JSON.stringify(yazhus);
            logger.warn(str);////cssj
            return { code: C.FAILD, msg: "押注数值出错了   前端的问题  "+JSON.stringify(yazhus) };
        }
    }
    //本次总押注 身上的钱是否够
    if(this.nowDiamond < _.sum(yazhus)){ //本次总下注
        return { code: C.FAILD, msg: C.GAME_DIAMOND_LOW };//玩家钻石不足
    }
    //时间戳 ！= 每日人数统计时间
    if(this.logic.getTodaySJC() != this.mrrstjsj){
        // console.warn("昨日数据还未统计111");
        yield this.tjbjlmryxrs();
    }
    this.state = STATE.PLAYING;
    this.win = 0;//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
    this.yxjlid = uuid.v1()+'_'+this.id;//ts++游戏记录id
    //ts++设置为游戏状态
    for (let user of this.users) 
    {
        if (user) {
            user.state = User.STATE.PLAYING
            user.state2 = User.STATE.PLAYING
            user.offlinetime = 0;
        }
    }
    //ts++end
    let whdata = yield this.app.models.WHstate.findByIdReadOnlyAsync('wh', 'rebaterate yxndlbTime yxndlbTip');
    // console.warn("22检查是否维护状态",whdata);
    if (whdata) {
        if(whdata.yxndlbTime) this.yxndlbTime = whdata.yxndlbTime;
        if(whdata.yxndlbTip) this.yxndlbTip = whdata.yxndlbTip;
    }
    if(this.yxndlbTime <= 20) this.yxndlbTime = 120;
    this.PaijuHuiFang = [];////TL++,牌局回放 重置数据
    // 初始信息
    // if (this.over <= 0) {///////本房间开始的第一局游戏
    //     this.pjhffileName[this.pjhffileName.length] = this.PJHF.getjsonFileName(0,this.recordid,this.ctime);/////TL++,用于记录玩家牌局回放的json文件名
    //     // console.error("000HHHHHHHHHHHHHHHHHHHHHH",this.pjhffileName.length,this.pjhffileName);
    //     this.PJHF.writePJHFJson(this.getTableInfo(),0,this.id);////在开始第一局的时候将桌子信息写入本地的json文件
    // } 
    let nowTime = Date.now();//当前时间戳  
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    this.stime = nowTime;
    let scoreBefore = Number(this.nowDiamond) + Number(this.nowDiamond2);//下注之前玩家的钻石
    this.over++; 
    this.yazhus = this.logic.deepCloneTL(yazhus)//玩家本场押注情况
    let bczxz = _.sum(this.yazhus);//本次总下注
    console.warn("bczxz:",bczxz)
    let jcPools = yield this.app.models.SGJJC.findByIdAsync('sgjjcs');
    console.warn("jcpools:",jcPools)
    let mqdw = -1;//目前挡位
    let cjjcsjk = 1;//是否创建奖池数据库
    if (jcPools) {
        cjjcsjk = 2;
        if(jcPools.levels && jcPools.levels.length > 0){
            cjjcsjk = 3;
            mqdw = this.logic.getMQDW(bczxz,jcPools.levels);//得到目前挡位
        }
    }
    if(cjjcsjk < 3){
        // console.warn("创建数据库",cjjcsjk);
        if(cjjcsjk == 2) yield jcPools.removeAsync();
        var sgjjc = new this.app.models.SGJJC({
            _id: 'sgjjcs',
            pools: [10000000,50000000,100000000],
            cspools: [10000000,50000000,100000000],
            levels: [0,1000,5000],
            kouchus: [0,0,0],                         // 扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
            topLimits1: [13000000,65000000,130000000],   // 各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
            topLimits2: [15000000,75000000,150000000],   // 各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
            topLimits3: [19000000,95000000,190000000],   // 各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
            lowLimits1: [7000000,35000000,70000000],   // 各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
            lowLimits2: [5000000,25000000,50000000],   // 各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
            lowLimits3: [1000000, 5000000,10000000],   // 各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
            paiTopRate1: [20,20,20],  // 各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
            paiTopRate2: [50,50,50],  // 各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
            paiTopRate3: [80,80,80],  // 各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
            paiLowRate1: [20,20,20],  // 各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
            paiLowRate2: [50,50,50],  // 各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
            paiLowRate3: [80,80,80],  // 各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
            bsTopRate1: [20,20,20],   // 各个挡位对应的倍数上限1调控比例（奖池分为几个等级，数组就有几个元素）
            bsTopRate2: [30,30,30],   // 各个挡位对应的倍数上限2调控比例（奖池分为几个等级，数组就有几个元素）
            bsTopRate3: [20,20,20],   // 各个挡位对应的倍数上限3调控比例（奖池分为几个等级，数组就有几个元素）
            bsLowRate1: [20,20,20],   // 各个挡位对应的倍数下限1调控比例（奖池分为几个等级，数组就有几个元素）
            bsLowRate2: [30,30,30],   // 各个挡位对应的倍数下限2调控比例（奖池分为几个等级，数组就有几个元素）
            bsLowRate3: [20,20,20],   // 各个挡位对应的倍数下限3调控比例（奖池分为几个等级，数组就有几个元素）
            ydxpools: [10000000,50000000,100000000],   // 押大小奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
            ydxcspools: [10000000,50000000,100000000], // 押大小初始奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
            ydxlevels: [0,1000,10000],                 // 押大小挡位数组(单位：钻石)（奖池分为几个等级，数组就有几个元素）
            ydxkouchus: [0,0,0],                      // 押大小扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
            ydxtopLimits1: [13000000,65000000,130000000],   // 押大小各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
            ydxtopLimits2: [15000000,75000000,150000000],   // 押大小各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
            ydxtopLimits3: [19000000,95000000,190000000],   // 押大小各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
            ydxlowLimits1: [7000000,35000000,70000000],   // 押大小各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
            ydxlowLimits2: [5000000,25000000,50000000],   // 押大小各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
            ydxlowLimits3: [1000000, 5000000,10000000],   // 押大小各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
            ydxTopRate1: [20,20,20],  // 押大小各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
            ydxTopRate2: [50,50,50],  // 押大小各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
            ydxTopRate3: [80,80,80],  // 押大小各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
            ydxLowRate1: [20,20,20],  // 押大小各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
            ydxLowRate2: [50,50,50],  // 押大小各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
            ydxLowRate3: [80,80,80]  // 押大小各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
           
        });
        mqdw = this.logic.getMQDW(bczxz,sgjjc.levels);//得到目前挡位
        yield sgjjc.saveAsync();
        // console.warn("检查是否维护状态");
    }
    this.nowDiamond -= bczxz;
    // 发牌
    this.fpRes = this.logic.handCards(this.yazhus,this.over,mqdw,jcPools,this.ownerUid);
    var handCards = this.fpRes.cards;
    let tspx = this.fpRes.tspx;//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
    let bcfpdydyzxbs = this.fpRes.bcfpdydyzxbs;//本次发牌对应的押注下注下标
    let zjdypxbs = this.fpRes.zjdypxbs;//这局结果对应的牌值列表，用于计算获得列表判断任务
    let xxydList = this.fpRes.xxydList;//详细赢得的列表
    let winList = this.fpRes.winList;
    let win = this.fpRes.win;
    let bsIndex = this.fpRes.bsIndex;//本次发牌对应的倍数下标
    let wingames = 0;//赢的小局次数
    if(win >= bczxz) wingames = 1;
    this.win = win;//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
    this.nowDiamond += win;//玩家目前的钻石

    let str5 = "table sgj数据---id:"+this.id +" 当前局 "+ (this.over)+"  yzs  "+JSON.stringify(this.yazhus);
    str5+=("  nd  "+this.nowDiamond+"  win  "+win+" pP "+this.logic.prizePool+"  hc  "+JSON.stringify(handCards))
    logger.warn(str5);
    let uId = 0;
    let player = yield this.app.models.Player.findByIdAsync(this.ownerId, '_id userId name diamond cost');
    if (player) {
        player.diamond = this.nowDiamond + this.nowDiamond2;
        uId = player.userId;
        if(player.diamond < 0){
            player.diamond = 0;
            let stre = "table 这里出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  uId "+uId+"  nowDiamond  "+this.nowDiamond + "  nowDiamond2  " + this.nowDiamond2;
            logger.warn(stre);////cssj
        }
        // player.cost -= this.cost;
        yield player.saveAsync();
        let str7 = "sgjtable 游戏开始计算结果之后保存钻石成功id:  "+ this.id + " userId: " + player.userId + " name: " + player.name+"  nowDiamond  "+this.nowDiamond ;
        logger.warn(str7);////cssj
    }
    this.users[0].diamond = (this.nowDiamond + this.nowDiamond2).toFixed(2);;
    this.users[0].drCount = this.nowDiamond.toFixed(2);
    // 水果机战绩
    var sgjtable = new this.app.models.SGJTables({
        _id: this.yxjlid,//ts++游戏记录id,  
        tableNo: this.id,     // ts++房间号
        ownerId: this.ownerId,     // 玩家标识
        agentId: this.agentId,     // 代理ID
        over: this.over,        // 游戏局数
        time: nowTime,        // 结束时间
        gameCost: bczxz,     // 游戏消耗(本局下注总额)
        giftCost: 0,     // 礼物消耗
        agentRebate: 0,  // 代理返利
        yazhuList: this.logic.deepCloneTL(this.yazhus),    // 本局押注列表
        resultList: this.logic.deepCloneTL(handCards),     // 本局结果列表
        winsList: this.logic.deepCloneTL(winList),         // 本局结果赢的列表
        win: win,          // 本局结果赢得分数(不包含下注的即winsList元素总和)
        bsIndex:bsIndex,//本次发牌对应的倍数下标,
        huafenList:[],     // 本局划分数据列表
        scoreBefore: scoreBefore.toFixed(2),  // 本局开始前的分数(钻石)
        scoreEnd: (Number(this.nowDiamond) + (this.nowDiamond2)).toFixed(2), // 本局结束后的分数(=scoreBefore-押注总额+win)
    });
    //let addTaskQuan = bczxz*this.logic.toTaskQuanReate;
    let addTaskQuan = bczxz/this.logic.nowCell*this.logic.toTaskQuanReate;
    console.warn("bczxz:",bczxz," nowCell:",this.logic.nowCell, " toTaskQuanReate:",this.logic.toTaskQuanReate," addTaskQuan:",addTaskQuan)
    let nowTaskQuan = 0;
    yield sgjtable.saveAsync();
    let getList = [];
    let zfbAcc = "";
    let zfbName = "";
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(this.ownerId, 'userId cost win zfbAcc zfbName gameCount wingames taskQuan yazhuList getList getTime drCount drTime lastPlayTime');
    if (sgjUser) {
        var resTaskQuan = this.logic.jisuanFloat(sgjUser.taskQuan,addTaskQuan,1);
        // 钻石记录
        var taskquanrecord = new this.app.models.TaskQuanRecord({
            _id: uuid.v1(),
            playerId: player._id,
            dType: 1,//下注
            dSource: sgjUser.taskQuan,
            dSwap: addTaskQuan.toFixed(2),
            dNow: resTaskQuan
        });
        yield taskquanrecord.saveAsync()
        // sgjUser.zfbAcc = "";
        // sgjUser.zfbName = "";
        zfbAcc = sgjUser.zfbAcc;
        zfbName = sgjUser.zfbName;
        if(sgjUser.userId == 0 && uId > 0){
            sgjUser.userId = uId // 号码
        }
        sgjUser.cost+= bczxz;
        sgjUser.win+= win;
        sgjUser.gameCount += 1;
        sgjUser.wingames += wingames;
        sgjUser.taskQuan = this.logic.jisuanFloat(sgjUser.taskQuan,addTaskQuan,1);
        this.users[0].taskQuan = sgjUser.taskQuan;
        // sgjUser.taskQuan = 0;//测试时使用
        nowTaskQuan = sgjUser.taskQuan;        
        if(!this.logic.getListIsSame(sgjUser.yazhuList,this.yazhus)){
            // console.warn("下注列表和之前不一样========   ",sgjUser.yazhuList,this.yazhus);
            sgjUser.yazhuList = this.logic.deepCloneTL(this.yazhus)
        }
        getList = this.logic.updateGetList(nowTime,sgjUser.getTime,sgjUser.getList,zjdypxbs,this.wjrwxylb);//更新获得列表
        sgjUser.getList = this.logic.deepCloneTL(getList);
        // console.warn("开始游戏uid    ",uId);
        // if(uId == 100046 || uId == 100055 || uId == 100002){
        //     for (var i = 0; i < getList.length; i++) {
        //         sgjUser.getList[i] = 100;
        //     }
        //     sgjUser.zfbAcc = "18511090980";
        //     sgjUser.zfbName = "张明";
        //     sgjUser.zfbBindTime = 1698422400000;
                // sgjUser.taskQuan = 100000;
        // }
        sgjUser.getTime = nowTime;   // 获得列表更新的时间
        sgjUser.drCount = this.nowDiamond;
        sgjUser.lastPlayTime = nowTime;   // 玩家上次进入果游戏时间(留存人数)
        yield sgjUser.saveAsync();
    }
    // else{
    //     nowTaskQuan = addTaskQuan;
    //     let wingames2 = 0 + wingames
    //     getList = this.logic.updateGetList(nowTime,0,[],zjdypxbs);//更新获得列表
    //     var newsgjUser = new this.app.models.SGJUser({
    //         _id: player._id, // 标识
    //         userId: player.userId, // 号码
    //         cost: bczxz, // 消费
    //         win: win, // 总赢得分
    //         zfbAcc: "",       // 支付宝账号
    //         zfbName: "",      // 支付宝姓名
    //         gameCount: 1,     // 总小局次数
    //         wingames: wingames2,      // 总赢的小局次数
    //         taskQuan: addTaskQuan,  // 任务券（用于领任务）
    //         yazhuList: this.logic.deepCloneTL(this.yazhus), // 上局押注列表
    //         getList: this.logic.deepCloneTL(getList),  // 获得的列表(用于计算任务是否完成)
    //         getTime: nowTime,       // 获得列表更新的时间
    //         registerTime: nowTime            // 玩家首次进入水果游戏时间
    //         // taskList: [],  // 玩家已领任务的列表[任务下标，领取时间，完成次数]
    //     });
    //     yield newsgjUser.saveAsync();
    // }
    // console.warn("本次总下注    "+bczxz+"  addTaskQuan  "+addTaskQuan+"  nowTaskQuan  "+nowTaskQuan);
    // 掷骰子

    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:this.logic.getTodaySJC()})
    if (SGJUserTongjis.length == 0) {
        var SGJUserTongji = this.app.models.SGJUserTongji({
            _id: uuid.v1(),
            //userId: player.userId,
            //usdt: this.users[0].diamond,
            sgjwinlose: (Number(win)-Number(_.sum(yazhus))).toFixed(2),//下注
            taskquanget: addTaskQuan,
            nowtaskquan: sgjUser.taskQuan,
            todaytime: this.logic.getTodaySJC()
        });
        console.warn("empty win:",win)
        console.warn("_.sum(yazhus):",_.sum(yazhus))
        yield SGJUserTongji.saveAsync()
    }else {
        var SGJUserTongji = SGJUserTongjis[0]
        console.warn("SGJUserTongji:",SGJUserTongji)
        SGJUserTongji.sgjwinlose = (Number(SGJUserTongji.sgjwinlose) - Number(_.sum(yazhus))+Number(win)).toFixed(2)//下注
        SGJUserTongji.nowtaskquan = sgjUser.taskQuan
        SGJUserTongji.taskquanget = (Number(SGJUserTongji.taskquanget)+Number(addTaskQuan)).toFixed(2)
        console.warn("have data win:",win)
        console.warn("_.sum(yazhus):",_.sum(yazhus))
        console.warn("SGJUserTongji:sgjwinlose",SGJUserTongji.sgjwinlose)
        yield SGJUserTongji.saveAsync()
    }

    var sttGame = {
        over: this.over,
        state: this.state,
        yazhus:this.logic.deepCloneTL(this.yazhus),
        nowDiamond:this.nowDiamond.toFixed(2),
        win:win.toFixed(2),
        handCards:handCards,
        bsIndex:bsIndex,//本次发牌对应的倍数下标,
        tspx:tspx,//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
        prizePool: this.logic.prizePool,
        nowTaskQuan:nowTaskQuan.toFixed(2),
        yxndlbTime:this.yxndlbTime,
        yxndlbTip:this.yxndlbTip,
    };
    let jjcsl = 0//进奖池数量
    let bcsy = win - bczxz;//本次输赢
    let xkcbl = this.logic.jisuanFloat(this.logic.yzjjckcReate,this.logic.fqjjckcReate,1);//进出奖池需扣掉的比例
    let xkcsl = this.logic.jisuanFloat(bczxz,xkcbl,3);//进出奖池需扣掉的数量
    if(bcsy >= 0){//押中赢了,奖池要亏
        let jczs = this.logic.jisuanFloat(bcsy,xkcsl,1)*-1;//进出钻石
        jjcsl = this.logic.jisuanFloat(jczs,this.logic.jcdwzhwzs,3);
        console.warn("bcsy:",bcsy," xkcsl:",xkcsl, " jczs:",jczs, " jjcsl:",jjcsl)
    }
    else{//未押中输了，奖池要盈
        let bcsd = bczxz-win;//本次输的
        let jczs = this.logic.jisuanFloat(bcsd,xkcsl,2);//进出钻石
        jjcsl = this.logic.jisuanFloat(jczs,this.logic.jcdwzhwzs,3);//下的太多赢得太少情况下这里出现负数很正常
        console.warn("bcsd:",bcsd," bczxz:",bczxz," win:",win," xkcsl:",xkcsl, " jczs:",jczs, " jjcsl:",jjcsl)
    }
    if (jcPools) {
        console.warn(1433)
        if(mqdw >= 0 && mqdw < jcPools.pools.length){
            let xzpool = _.cloneDeep(jcPools.pools);
            xzpool[mqdw] += jjcsl;
            // console.warn("奖池保存结果111 ",mqdw,jcPools.pools, xzpool,jjcsl);
            let xzkouchu = _.cloneDeep(jcPools.kouchus);
            xzkouchu[mqdw] += this.logic.jisuanFloat(xkcsl,this.logic.jcdwzhwzs,3);
            // console.warn("奖池保存结果222 ",mqdw,jcPools.kouchus, xzkouchu,xkcsl);
            jcPools.pools = _.cloneDeep(xzpool);
            jcPools.kouchus = _.cloneDeep(xzkouchu);
            console.warn("xzpool:",xzpool)
            console.warn("pools:",jcPools.pools)
            yield jcPools.saveAsync();
        }
    }
    else{
        console.warn("1454")
        var sgjjc = yield this.app.models.SGJJC.findByIdAsync('sgjjcs', 'pools cspools levels kouchus');
        if(sgjjc){
            if(mqdw >= 0 && mqdw < sgjjc.pools.length){
                let xzpool = _.cloneDeep(sgjjc.pools);
                xzpool[mqdw] += jjcsl;
                // console.warn("奖池保存结果333 ",mqdw,sgjjc.pools, xzpool,jjcsl);
                let xzkouchu = _.cloneDeep(sgjjc.kouchus);
                xzkouchu[mqdw] += this.logic.jisuanFloat(xkcsl,this.logic.jcdwzhwzs,3);
                // console.warn("奖池保存结果444 ",mqdw,sgjjc.kouchus, xzkouchu,xkcsl);
                sgjjc.pools = _.cloneDeep(xzpool);
                sgjjc.kouchus = _.cloneDeep(xzkouchu);
                console.warn("xzpool:",xzpool)
                console.warn("pools:",sgjjc.pools)
                yield sgjjc.saveAsync();
            }
        }
    }
    this.ydxfpRes = {
        cs:0,//本局押大小的次数，用于实现只能在首次押大小之前点击加分
        type: -1,//本局玩家上次押大小的类型，-1表示还未押过大小,1表示押小2表示押大
        number: -1,//本局玩家上次押大小的发牌，-1表示还未押过大小
    };//本局的押大小发牌

    //下面是计算统计数据
    this.zqqCost += bczxz;  //所有玩家游戏转圈总下注
    this.zqqwin += win;   //所有玩家游戏转圈总赢得
    this.zqqxh += bcsy*-1;    //所有玩家游戏转圈总消耗（总下注-总赢得）
    this.allrwq = this.logic.jisuanFloat(this.allrwq,addTaskQuan,1);   //所有奖券产生总量  
    this.allCost += bczxz;  //所有玩家总下注
    this.allwin += win;   //所有玩家总赢得
    this.allxh += bcsy*-1;    //所有玩家总消耗（总下注-总赢得）
    for (var i = 0; i < this.yazhus.length; i++) {
        if(!this.allyzze [i]) this.allyzze [i] = 0;
        this.allyzze [i] += this.yazhus[i]
    } 
    for (var i = 0; i < winList.length; i++) {
        if(!this.allydze [i]) this.allydze [i] = 0;
        this.allydze [i] += winList[i]
    } 
    if(tspx == 0){//特殊牌型，0：没有，1：小三元，2：大三元，3：大四喜
        this.logic.getGXXXYDZEList(this.gxzydze,xxydList);//总赢得总额列表(不包含特殊项)
        if(handCards[0] == 9 || handCards[0] == 21) {
            if(!this.gxzydze[8]) this.gxzydze[8] = 0
            this.gxzydze[8]+=win;
        }
        this.logic.getAllGetList(this.gxcxzcs,zjdypxbs);//出现总次数列表(不包含特殊项)
    }
    else if(tspx >= 1 && tspx <= 3){
        for (var i = 0; i < tspx; i++) {
            if(!this.tsxzydze[i]) this.tsxzydze[i] = 0;
            if(!this.tsxcxzcs[i]) this.tsxcxzcs[i] = 0;
        }
        console.warn("记录特殊====  ",tspx,this.tsxzydze,this.tsxcxzcs);
        if(!this.tsxzydze[tspx-1]) this.tsxzydze[tspx-1] = 0;
        this.tsxzydze[tspx-1] += win;
        if(!this.tsxcxzcs[tspx-1]) this.tsxcxzcs[tspx-1] = 0;
        this.tsxcxzcs[tspx-1]++;
    }
    let phdata = {
        bczxz: bczxz,//本次总下注
        addTaskQuan: addTaskQuan,//本次增加的任务券
        jrStart: jrStart,//本次游戏时间对应的0点时间戳
        nowTime: nowTime//本次游戏的时间
    }
    yield this.setPaiHangData(phdata);
    // console.warn("游侠开始*******************this.chBanker",this.chBanker);
    this.setPaijuHuiFangData(M.START_GAME,sttGame);/////TL++ 牌局回放  push游戏开始
    // 开始通知
    console.warn("sttGame:",sttGame)
    yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.START_GAME, data: sttGame });
    // let endmode=ENDMODE.NORMALEND//局数完成--正常结束
    // let endmode=ENDMODE.PLAYING;
    // yield this.endResultAsync(endmode);
    // console.warn("游戏开始执行完毕  this.state "+this.state);
    yield this.taskReward(this.ownerId,zfbAcc,zfbName,getList);
    let str3 = "table 222开始游戏执行完毕  下面是是返回---id:"+this.id +","+ this.state;
    logger.warn(str3);////cssj
    // console.warn("游戏开始执行完毕  下面是是返回 "+this.state);
    return { code: C.OK };
});

//
proto.taskReward = cor(function* (playerId,zfbAcc,zfbName,_getList) {
    // if(!zfbAcc || !zfbName) return { code: C.OK };//该玩家没有支付宝信息
    let opts0 = { 
        playerId: playerId,
        state:0,
        wcTime:0
    };
    var ylrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, '_id des cost reachs reachC rewards state');
    if(ylrwList.length == 0) return { code: C.OK };//该玩家没有已领取的任务
    let overTaskRes = this.logic.getOverTask(_getList,ylrwList);
    let ywcrwzjlist = [];//已完成任务主键列表
    if(overTaskRes.overList.length > 0){
        for (var i = 0; i < overTaskRes.overList.length; i++) {
            let xb = overTaskRes.overList[i];
            let zj = ylrwList[i]._id;
            var ywcList = yield this.app.models.SGJTask.findByIdAsync(zj,'reachs reachC state wcTime');
            if(ywcList){
                ywcList.state = 1;  //任务状态0:未完成，1:已完成，2:发奖中，3:已发奖，
                ywcList.wcTime = Date.now();  //完成时间
                // console.warn("发奖成功之qian更新任务状态  ",zj)
                yield ywcList.saveAsync();
                ywcrwzjlist[ywcrwzjlist.length] = zj;
                if(this.wjrwxylb.length > 0){
                    for (var j = 0; j < ywcList.reachs.length; j++) {
                        let rwyqlx = ywcList.reachs[j];//任务要求类型
                        let rwyqsl = ywcList.reachC[j];//任务要求类型
                        if(this.wjrwxylb[rwyqlx] >= rwyqsl){
                            this.wjrwxylb[rwyqlx] -= rwyqsl;
                            // console.warn("任务完成  玩家已领未完成任务需要的任务要求列表  ",this.wjrwxylb,rwyqlx,rwyqsl);
                        }
                        else{
                            let str3 = "table 任务要求个数出错---id:"+this.id +" 当前局 "+ this.over+"  wjrwxylb  "+this.wjrwxylb+"  rwyqlx  "+rwyqlx+"  rwyqsl  "+rwyqsl;
                            logger.error(str3);////cssj
                        }
                    }
                }
                else{
                    let str4 = "table 任务要求出错---id:"+this.id +" 当前局 "+ this.over+"  cd  "+this.wjrwxylb.length+"  playerId  "+playerId;
                    logger.error(str4);////cssj
                }
                
            }
            else{
                logger.error("任务主键出错了没有找到记录： "+zj);
            }
        }
        var sgjUser = yield this.app.models.SGJUser.findByIdAsync(this.ownerId, 'getList');
        if (sgjUser) {
            // console.warn("发奖成功之后保存getlist  ",sgjUser.getList,overTaskRes.getList)
            sgjUser.getList = _.cloneDeep(overTaskRes.getList);
            yield sgjUser.saveAsync();
        }
        //至此已经有任务完成了
        // let fjres = yield this.sendTaskRecord(2,ywcrwzjlist);
        // ////// return { code: C.OK, data: result};{"message":"操作成功","errorCode":0,"success":true,"data":null}
        // console.warn("发奖成功信息  ",JSON.stringify(fjres));
        // if(fjres.code == C.OK && fjres.data.success == true){
        //     //发奖成功
            
        //     for (var i = 0; i < overTaskRes.overList.length; i++) {
        //         let xb = overTaskRes.overList[i];
        //         let zj = ylrwList[i]._id;
        //         var ywcList = yield this.app.models.SGJTask.findByIdAsync(zj,'state fjTime');
        //         if(ywcList){
        //             ywcList.state = 3;  //任务状态0:未完成，1:已完成，2:发奖中，3:已发奖，
        //             ywcList.fjTime = Date.now();  //发奖时间
        //             console.warn("发奖成功之后更新任务状态  ",zj);
        //             yield ywcList.saveAsync();
        //         }
        //     }
        // }
    }
    return { code: C.OK };
});

// 划分
proto.huafenAsync = cor(function* (type,value) {
    if(this.win <= 0){//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
        console.warn("remove 1616")
        return { code: C.FAILD, msg: C.TABLE_MASK_ERROR };
    }
    value = parseFloat(value.toFixed(2));
    if(this.nowDiamond < value){
        return { code: C.FAILD, msg: "不能超出身上已有钻石" };
    }
    if((value*1000)%((this.logic.nowCell*1000)) != 0){
        let str = "table 押大小数值出错了---id:"+this.id +" 当前局 "+ (this.over+1)+"  this.ownerUid  "+this.ownerUid+"  value  "+value;
        logger.warn(str);////cssj
        return { code: C.FAILD, msg: "押大小数值出错了   前端的问题  "+value };
    }
    // let fjres = yield this.sendTaskRecord();
    // console.warn("划分2222    ",JSON.stringify(fjres));
    if(this.logic.getTodaySJC() != this.mrrstjsj){
        // console.warn("昨日数据还未统计222");
        yield this.tjbjlmryxrs();
    }
    this.win = value;
    // let cz = this.win - value;//前端加减分之后修改的差值
    let scoreBefore = this.nowDiamond;//划分之前玩家的钻石
    let mqdw = -1;//目前挡位
    let jcPools = yield this.app.models.SGJJC.findByIdAsync('sgjjcs');
    if (jcPools) {
        if(jcPools.ydxpools && jcPools.ydxpools.length > 0){
            mqdw = this.logic.getMQDW(value,jcPools.ydxlevels);//得到目前挡位
        }
    }
    let res = this.logic.getHuafenRes(type,value,mqdw,jcPools);
    this.ydxfpRes.cs++;// 本局押大小次数
    let ydxcs = this.ydxfpRes.cs;// 本局押大小次数
    // console.warn("本局押大小次数  ",ydxcs, this.ydxfpRes.cs);
    this.ydxfpRes = {
        cs:ydxcs,//本局押大小的次数，用于实现只能在首次押大小之前点击加分
        type: type,//本局玩家上次押大小的类型，-1表示还未押过大小,1表示押小2表示押大
        number: res.number,//本局玩家上次押大小的发牌，-1表示还未押过大小
    };//本局的押大小发牌
    this.win += res.win;//本局结果赢得分数(不包含下注的即winsList元素总和)用于判断用户是否可以押分
    this.nowDiamond = this.nowDiamond - value + this.win;//玩家目前的钻石
    let addTaskQuan = 0//res.addTaskQuan.toFixed(2);;
    let str5 = "table sgj划分  数据---id:"+this.id +" 当前局 "+ this.over+"  type  "+type+"  value  "+value;
    str5+=("  nd  "+this.nowDiamond+"  win  "+this.win+" pP "+this.logic.prizePool+"  hc  "+JSON.stringify(res))
    logger.warn(str5);

    let player = yield this.app.models.Player.findByIdAsync(this.ownerId, '_id diamond cost name userId');
    if (player) {
        player.diamond = this.nowDiamond + this.nowDiamond2;
        // player.cost -= this.cost;
        if(player.diamond < 0){
            player.diamond = 0;
            let stre = "table 这里出错了---222id:"+this.id +" 当前局 "+ (this.over+1)+"  ownerUid "+this.ownerUid+"  nowDiamond  "+this.nowDiamond + "  nowDiamond2  " + this.nowDiamond2;
            logger.warn(stre);////cssj
        }
        yield player.saveAsync();
        let str7 = "sgjtable 划分计算结果之后保存钻石成功id:  "+ this.id + " userId: " + player.userId + " name: " + player.name+"  nowDiamond  "+this.nowDiamond ;
        logger.warn(str7);////cssj
    }
    let nowTime = Date.now();
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    this.users[0].diamond = this.nowDiamond + this.nowDiamond2;
    this.users[0].drCount = this.nowDiamond;
    // 水果机战绩里面划分列表增加数据
    let sgjtable = yield this.app.models.SGJTables.findByIdAsync(this.yxjlid, '_id huafenList');
    if (sgjtable) {
        let huafenItem = {
            yddx: type,             // 本次划分玩家押的大小
            hfxz: value,            // 本次划分的下注
            hfjg: res.number,       // 本次划分的发牌结果
            bcyd: res.win,          // 本次划分赢的
            ksfs: scoreBefore,      // 本次划分开始时的钻石(下注之前的)
            jsfs: this.nowDiamond + this.nowDiamond2,  // 本次划分结束时的钻石(jsfs = ksfs-hfxz+bcyd)
            time: nowTime        // 本条划分记录时间
        }
        let newlb = _.cloneDeep(sgjtable.huafenList);
        newlb[newlb.length] = huafenItem;
        sgjtable.huafenList = _.cloneDeep(newlb);
        yield sgjtable.saveAsync();    
    }

    let nowTaskQuan = 0;
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(this.ownerId, 'userId cost win taskQuan drCount drTime lastYDXTime');
    if (sgjUser) {
        sgjUser.cost+= value;
        sgjUser.win+= this.win;
        //sgjUser.taskQuan = this.logic.jisuanFloat(sgjUser.taskQuan,addTaskQuan,1);
        nowTaskQuan = sgjUser.taskQuan;
        sgjUser.drCount = this.nowDiamond;
        sgjUser.lastYDXTime = nowTime;
        this.users[0].taskQuan = sgjUser.taskQuan;
        yield sgjUser.saveAsync();
    }
    if (jcPools) {

        if(mqdw >= 0 && mqdw <jcPools.ydxpools.length){
            let jjcsl = 0//进奖池数量
            let xkcsl = this.logic.jisuanFloat(value,this.logic.fqjjckcReate,3);//进出奖池需扣掉的数量
            if(res.win >= 0){//押中赢了，奖池要亏
                let jczs = this.logic.jisuanFloat(res.win,xkcsl,1)*-1;//进出钻石
                jjcsl = this.logic.jisuanFloat(jczs,this.logic.jcdwzhwzs,3);
            }
            else{//未押中输了，奖池要盈
                let jczs = this.logic.jisuanFloat(res.win*-1,xkcsl,2);//进出钻石
                jjcsl = this.logic.jisuanFloat(jczs,this.logic.jcdwzhwzs,3);
            }
            let xzpool = _.cloneDeep(jcPools.ydxpools);
            xzpool[mqdw] += jjcsl;
            // console.warn("ydx奖池保存结果111 ",mqdw,jcPools.ydxpools, xzpool,jjcsl);
            let xzkouchu = _.cloneDeep(jcPools.ydxkouchus);
            xzkouchu[mqdw] += this.logic.jisuanFloat(xkcsl,this.logic.jcdwzhwzs,3);
            // console.warn("ydx奖池保存结果222 ",mqdw,jcPools.ydxkouchus, xzkouchu,xkcsl);
            jcPools.ydxkouchus = _.cloneDeep(xzkouchu);
            jcPools.ydxpools = _.cloneDeep(xzpool);
            yield jcPools.saveAsync();
        }
    }
    //下面是计算统计数据
    this.ydxCost += value;  //所有玩家押大小总下注
    if(res.win >= 0) this.ydxwin += res.win*2;   //所有玩家押大小总赢得
    this.ydxxh += res.win*-1;    //所有玩家押大小总消耗（总下注-总赢得）
    this.ydxzcs += 1;   //该日押大小总次数
    this.allrwq = this.logic.jisuanFloat(this.allrwq,addTaskQuan,1).toFixed(2);   //所有奖券产生总量
    this.allCost += value;  //所有玩家总下注
    if(res.win >= 0) this.allwin += res.win*2;   //所有玩家总赢得
    this.allxh += res.win*-1;    //所有玩家总消耗（总下注-总赢得） 

    let phdata = {
        bczxz: value.toFixed(2),//本次总下注
        addTaskQuan: addTaskQuan,//本次增加的任务券
        jrStart: jrStart,//本次游戏时间对应的0点时间戳
        nowTime: nowTime//本次游戏的时间
    }
    yield this.setPaiHangData(phdata);
    // console.warn("划分返回111");
    let data = this.logic.deepCloneTL(res);
    data.ydxcs = ydxcs;           // 本局押大小次数
    data.nowDiamond = this.nowDiamond;
    data.value = value;
    data.nowTaskQuan = nowTaskQuan.toFixed(2);
    yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.COMPARE_RESULT, data: data });
    //console.warn("data:",data)
    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:this.logic.getTodaySJC()})
    var SGJUserTongji = null
    if (SGJUserTongjis.length == 0) {
        SGJUserTongji = this.app.models.SGJUserTongji({
            _id: uuid.v1(),
            userId: user.userId,
            usdt: user.diamond,
            taskquanlose: cost,//下注
            todaytime: this.logic.getTodaySJC()
        });
        yield SGJUserTongji.saveAsync()
    }else {
        SGJUserTongji = SGJUserTongjis[0]
        SGJUserTongji.usdt = data.nowDiamond
        SGJUserTongji.sgjwinlose = (Number(SGJUserTongji.sgjwinlose) +Number(data.win)).toFixed(2)//下注

        yield SGJUserTongji.saveAsync()
    }
    // console.warn("划分返回222  "+JSON.stringify(data));
    return { code: C.OK, data: data };
});

// 统计并记录每日游戏人数数据(今天首局记录昨天的数据)
proto.tjbjlmryxrs = cor(function* () {
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    let zrStart = jrStart - 86400000;////昨日0时的时间戳
    // console.warn("统计并记录每日游戏人数数据   jrStart  "+jrStart+" zrStart   "+zrStart);
    var sgjmrsj = yield this.app.models.SGJMRRS.findByIdAsync(""+zrStart);
    if (sgjmrsj) {
        this.mrrstjsj = jrStart;//每日人数统计时间，用于判断在游戏和押大小时是否需要统计记录昨天的人数信息实现减少数据库访问
        // return { code: C.OK, msg: "昨日已经统计过了" };
    }
    else{
        //创建昨日人数数据
        let opts1 = { registerTime: { $gte: zrStart, $lt: jrStart}};
        let grzcrs = yield this.app.models.SGJUser.countMongoAsync(opts1);
        let opts2 = { registerTime: { $gte: zrStart, $lt: jrStart},
                    lastPlayTime: { $gte: zrStart, $lt: jrStart}};
        let xzyxrs = yield this.app.models.SGJUser.countMongoAsync(opts2);
        let opts3 = { lastPlayTime: { $gte: zrStart, $lt: jrStart}};
        let grzqrs = yield this.app.models.SGJUser.countMongoAsync(opts3);
        let opts4 = { lastYDXTime: { $gte: zrStart, $lt: jrStart}};
        let ydxzrs = yield this.app.models.SGJUser.countMongoAsync(opts4);
        let opts5 = { time: { $gte: zrStart, $lt: jrStart}};
        let grzqcs = yield this.app.models.SGJTables.countMongoAsync(opts5);
        let ydxzcs =  0;
        var sgjmrtj = yield this.app.models.SGJMRTJ.findByIdAsync(""+zrStart, 'ydxzcs');
        if (sgjmrtj) {
            ydxzcs = sgjmrtj.ydxzcs;
        }
        var newsgjmrsj = new this.app.models.SGJMRRS({
            _id: ""+zrStart,    // 标识(日期)
            grzcrs: grzcrs,  //该日注册人数(按照进入时间算)
            xzyxrs: xzyxrs,  //该日新增有效人数（玩过游戏的算为有效）
            grzqrs: grzqrs,  //该日转圈人数
            ydxzrs: ydxzrs,  //该日押大小总人数
            grzqcs: grzqcs,  //该日转圈次数
            ydxzcs: ydxzcs,  //该日押大小次数
            lcrs1: 0,   //该日的次日留存人数(按照进入算)
            lcrs7: 0,   //该日的7日留存人数
            time: Date.now(),        // 精确时间
            registerTime: zrStart// 记录时间（该日0点时间戳）
        });
        yield newsgjmrsj.saveAsync();
        // console.warn("保存每日人数111   ",newsgjmrsj);
        //更新前日的次日留存人数
        let kssj1 = zrStart - 86400000;////2日前0时的时间戳，用于更新2日前那条记录的次日留存人数
        var sgjmrsj1 = yield this.app.models.SGJMRRS.findByIdAsync(""+kssj1, 'lcrs1');
        if (sgjmrsj1) {
            let opts7 = { lastJoinTime: { $gte: zrStart-86400000, $lt: zrStart}};
            let lcrs1 = yield this.app.models.SGJUser.countMongoAsync(opts7);
            sgjmrsj1.lcrs1 = lcrs1;
            yield sgjmrsj1.saveAsync();
            // console.warn("保存每日人数222   ",lcrs1);
        }
        //更新7日前的次日留存人数
        let kssj7 = zrStart - 7*86400000;////2日前0时的时间戳，用于更新2日前那条记录的次日留存人数
        var sgjmrsj7 = yield this.app.models.SGJMRRS.findByIdAsync(""+kssj7, 'lcrs7');
        if (sgjmrsj7) {
            let opts8 = { lastJoinTime: { $gte: zrStart-86400000, $lt: zrStart}};
            let lcrs7 = yield this.app.models.SGJUser.countMongoAsync(opts8);
            sgjmrsj7.lcrs7 = lcrs7;
            yield sgjmrsj7.saveAsync();
            // console.warn("保存每日人数333   ",lcrs7);
        }
        this.mrrstjsj = jrStart;//每日人数统计时间，用于判断在游戏和押大小时是否需要统计记录昨天的人数信息实现减少数据库访问
    }
    // return { code: C.OK, msg: "昨日统计完成" };
});

////任务发奖
proto.sendTaskRecord = cor(function* (type,ywcrwzjlist) {
    // console.warn("任务发奖 ywcrwzjlist   "+ywcrwzjlist);
    // 判断的是否是JSON字符串
    let getIsAJsonStr22 = 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;
    }
    // var player = yield this.app.models.sgjUser.findByIdAsync(this.ownerId, 'zfbAcc zfbName');
    // if (player) {
        let p = this.ownerId; //用户id
        // let idsList = _.cloneDeep(ywcrwzjlist);//任务主键列表数组
        let idsStr = "";//JSON.stringify(ywcrwzjlist);//任务主键列表字符串
        for (var i = 0; i < ywcrwzjlist.length; i++) {
            let sss = ""+ywcrwzjlist[i];
            if(i < ywcrwzjlist.length - 1) sss+=",";
            idsStr+=sss;
        }
        let t = type; // 类型 1:绑定支付宝，2:水果游戏任务奖励 
        let r=""; // 说明
        let tsT = Date.now();

        let key = "xxxxxxx"
        let str1 = ""+p+idsStr+key+t+r+tsT;
        let md51 = md5(str1).toUpperCase();
        let str2 = ""+md51+tsT;
        let md52 = md5(str2).toUpperCase();
        let sign = md52;
        let post_data={
            p: p,
            idsStr:idsStr,
            t: t,
            r: r,
            tsT: tsT,
            s: sign
        };//请求数据
        // console.warn("任务发奖 post_data   "+post_data);
        let reqdata = JSON.stringify(post_data);
        let options = {
            hostname: 'aa.bb.cc.com',
            port: '',
            path: '/sfM/giveOut',
            method: 'POST',
            rejectUnauthorized: false,
            requestCert: true,
            headers: {
                'Content-Type': 'Application/json',
                "Content-Length":reqdata.length
            }
        };
        var req = https.request(options, function (res) {
        });
        req.write(reqdata);
        req.on('response', function (response2) {
            // console.warn("请求到这里了？？？222 response2.headers   "+JSON.stringify(response2.headers) );
            req.end();
            let body2 = "";
            response2.on('data', function (chunk) {
                body2 = chunk.toString();
                // console.warn("请求到这里了？？？555 chunk   "+body2);
                if(!getIsAJsonStr22(body2)){
                    console.error("接口返回值非json字符串   "+body2);
                    return {code: C.ERROR, msg: 114 };//"验证码发送失败"
                }
                let result = JSON.parse(body2);
                // console.warn("请求到这里了？？？56 chunk   "+result.success);
                if(result.success){
                    // console.warn("任务发奖成功  "+this.ownerId+"  "+JSON.stringify(result) );
                    
                    return { code: C.OK, data: result};
                }
                else{
                    console.error("任务发奖出错了   "+body2);
                    return {code: C.ERROR, msg: 115 };//"验证码发送失败"
                }
                // console.warn("这里都到返回值了222  ")
                
            });
            // console.warn("请求到这里了？？？666 body2 "+body2)
        });
        req.on('error', function (e) {
            req.end();
            console.error(new Error('request FJ error: ' + e.message));
            return { code: C.ERROR, msg: 116 };//"请求验证码失败"
        });
    // }
    // console.warn("请求支付宝完成了  ")
    var data = { 
        // renwuPool: allRenWuInfo,
    }
    return { code: C.OK, data: data };
});

// //ts++写分   endtype = { 正常: 0，局数完成: 1, 房主解散: 2, 申请解散: 3 ,超时解散: 4 };
// proto.writeResultAsync = cor(function* (endmode) {
//     if(this.yjxrzj){
//         logger.warn("出错了已经写入过战绩了-------------- " + this.yjxrzj );
//         return;
//     }
//     this.yjxrzj = true;
//     yield this.writeResultAsync2(endmode);
// });

// //ts++写分   endtype = { 正常: 0，局数完成: 1, 房主解散: 2, 申请解散: 3 ,超时解散: 4 };
// proto.writeResultAsync2 = cor(function* (endmode) {
//     logger.warn("牌局写入-------------- " + this.id );
//     // console.warn("ts++---------牌局写入writeResultAsync",this.id);   
//     let gameCost=0;//游戏消耗
//     let giftCost = 0;////道具消耗
//     this.etime = Date.now();
//     let users = [];
//     let localUsers = [];
//     // var scorers = this.score.getUsers();
//     var scorers = this.users[0];
//     if (scorers.length > 0)
//     {
//         var scorersSort = _.sortBy(scorers, (i) => i.chairId);
//         for (let scorer of scorersSort) {
//             gameCost+=this.cost;
//             giftCost+=scorer.giftCost;
//             let userscore=scorer.score;
//             // if(this.gameKindTL == 2) userscore -= 200;
//             users.push({_id: scorer.playerId,chairId:scorer.chairId,userId: scorer.userId, name: scorer.name, sex: scorer.sex, headurl: scorer.headurl,over: scorer.over, score: userscore}); 
//             //, gameCost: scorer.gameCost,giftCost: scorer.giftCost,diamond: scorer.diamond
//             localUsers.push({_id: scorer.playerId,userId: scorer.userId, name: scorer.name, gameCost: scorer.gameCost,giftCost: scorer.giftCost,}); 
//         }
//     }
//     // if(this.isGameOk)////以前是解散的不算返利
//     if(this.over > 0)////改成只要玩家扣钻了就有返利
//     {
//         // this.agentRebate=gameCost;//parseInt(gameCost*0.5);
//         this.agentRebate=gameCost+giftCost;////礼物也算消耗进行返利
//         // console.warn("代理返利+++++",this.agentRebate);
//     }
//     else
//     {
//         this.agentRebate=0;
//     }

//     //下面是记录返利相关的
//     if(this.agentId && this.agentRebate>0){
//         yield this.lsetReabte.writeReabteInfo(this.agentId,this.etime,this.agentRebate,gameCost,giftCost,this.recordid,localUsers,this.gameId);
//         // yield this.lsetReabte.writePlayerCountInfo(this.agentId,this.etime,users,this.cost,this.isGameOk,this.gameId);
//     }
//     //下面是记录邀请新人按比例送钻这个活动的数据
//     if(!this.lconfigCommon) {
//         // console.warn("邀请新人送钻石活动  this.lconfigCommon 不存在 "+this.etime);
//         this.lconfigCommon = new configCommon(this.app);
//     }
//     yield this.lconfigCommon.yxActivityAsync(scorers,this.etime);
    
//     logger.warn("战绩写入结束--",this.id);
//     // return { code: C.OK };

// });

// // 结束信息 var endtype = { 局数完成: 1, 主动解散: 2, 断线解散: 3 ,超时解散: 4 };
proto.endResultAsync = cor(function* (endmode) {

    // console.warn("ts++---------记录信息",this.id);
    let str6 = "table 结束信息--id: "+this.id +" ,结算模式 "+endmode;
    logger.warn(str6);////cssj

    if(endmode>ENDMODE.PLAYING)//ts++关闭
    {
        let nowTime = Date.now();
        if(this.state<STATE.END)//ts++防止重复写入
        {
            this.state = STATE.END;
            if (this.endTimer) {
                clearTimeout(this.endTimer);
                this.endTimer = null;
            }
            for (let user of this.users) {
                if (user) {
                    if (user.isOffline())
                    {
                        user.state = User.STATE.FREE;
                        user.state2 = User.STATE.FREE;
                        this.leaveUsers.push(user.id);
                    }
                    else
                    {
                        user.state = User.STATE.FREE;
                        user.state2 = User.STATE.FREE;
                    }
                }
            }
        }
        if(endmode==ENDMODE.SYSTEMEND)
        {
            yield this.pushMsgAsync(-1, 'shuiguo_event', { type: M.TABLE_JIESAN });
        }
        
        if(this.leaveUsers.length>0)
        {
             this.app.timer.setTimeout(() => this.leaveUserTimeAsync(), 100);
        }
        var gametable = yield this.app.models.GameTable.findByIdAsync(this.recordid, '_id tableNo agentId endMode');
        if(gametable){
            gametable.endMode = 1;
            yield gametable.saveAsync();
        }
        this.game.deleteTable(this.id);//ts++删除房间    
        // let str5 = "table 结束信息22  关闭-id:"+this.id +"结算模式"+endmode;
        // logger.info(str5);////cssj    
    }
    else//普通结束
    {
        this.fpRes = {};//本局的发牌
        this.ydxfpRes = {
            cs:0,//本局押大小的次数，用于实现只能在首次押大小之前点击加分
            type: -1,//本局玩家上次押大小的类型，-1表示还未押过大小,1表示押小2表示押大
            number: -1,//本局玩家上次押大小的发牌，-1表示还未押过大小
        };//本局的押大小发牌
        this.state = STATE.FREE2;
        for (let user of this.users) {
            if (user) {
                // user.state = User.STATE.FREE;//这个本来是游戏未开始或着游戏已达成才会设置这个的
                // user.state2 = User.STATE.FREE;
                //下面这两句本来是点击准备按钮之后才会设置这个的
                // user.state = User.STATE.READY;
                user.state2 = User.STATE.READY;
            }
        }
    }
    
    let str7 = "table end 结束信息---id:%s  "+this.id +" 结算模式 "+endmode;
    logger.warn(str7);////cssj
    
});

//ts++离开用户退出定时器
proto.leaveUserTimeAsync = cor(function* () {
    // console.warn("离开用户退出定时器,离开用户数==%d",this.leaveUsers.length);////cssj
    if(this.leaveUsers.length>0)
    {
        let userid = this.leaveUsers[0];
        this.leaveUsers.splice(0, 1);
        let str7 = "table end 离开用户退出定时器---id:%s  "+this.id +" userid "+userid;
        logger.warn(str7);////cssj
        yield this.game.leaveTableAsync(userid);
    }

    if(this.leaveUsers.length>0)
    {
         this.app.timer.setTimeout(() => this.leaveUserTimeAsync(), 100);
    }

});

// 玩家信息,里面包含任务信息
proto.roleInfoAsync = cor(function* (playerId,chairId) {
     // console.log("玩家信息玩家信息玩家信息");
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    var data = { 
        cost:0,
        win:0,
        zfbAcc:"",
        zfbName:"",
        gameCount:0,
        wingames:0,
        taskReward:0,
        taskQuan:0,
        getList:[]
    }
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(user.id, 'cost win zfbAcc zfbName gameCount wingames taskReward taskQuan getList');
    if (sgjUser) {
        data.cost= sgjUser.cost;
        data.win= sgjUser.win;
        data.zfbAcc= sgjUser.zfbAcc;
        data.zfbName= sgjUser.zfbName;
        data.gameCount= sgjUser.gameCount;
        data.wingames= sgjUser.wingames;
        data.taskReward= sgjUser.taskReward;
        data.taskQuan= sgjUser.taskQuan;
        data.getList= sgjUser.getList;
    }
    return { code: C.OK, data: data };
});

////设置排行榜数据
proto.setPaiHangData = cor(function* (data) {
    // data.jrStart -= 86400000*1;
    // data.nowTime -= 86400000*1;
    // bczxz: bczxz,//本次总下注
    //     addTaskQuan: addTaskQuan,//本次增加的任务券
    //     jrStart: jrStart,//本次游戏时间对应的0点时间戳
    //     nowTime: nowTime//本次游戏的时间
    let isNeedFaJiang = false;//是否需要给排行榜玩家发奖
    let gwjd = {};//该玩家的，因为会修改，所以先记录下
    let fields = '_id userId cost1 quan1 time1 cost2 quan2 time2 registerTime';
    var paihang = yield this.app.models.SGJPaiHang.findByIdAsync(this.ownerId, fields);
    if (paihang) {
        if(data.jrStart == paihang.time1){
            let newcost1 = Number(paihang.cost1) +  Number(data.bczxz);
            let newQuan = this.logic.jisuanFloat(paihang.quan1,data.addTaskQuan,1); 
            paihang.cost1 = newcost1;
            paihang.quan1 = newQuan;
        }
        else{
            //下面这个if是为了处理有多个玩家玩到第二天了，防止这几个玩家游戏的时候造成每个玩家都发一遍奖励
            if(this.phbyfjlrq != data.jrStart - 86400000){
                let sgjconfig = yield this.app.models.SGJConfig.findByIdAsync('sgconfigs');
                if (sgjconfig) {
                    this.phbyfjlrq = sgjconfig.phbyfjlrq;  //排行榜已发奖励的日期（0点时间戳）
                }
            }
            let szqphbjlsfyf = true;//上周期排行榜奖励是否已发
            if(this.phbyfjlrq != data.jrStart - 86400000) szqphbjlsfyf = false;
            // console.warn("上周期排行榜奖励是否已发   ",szqphbjlsfyf,this.phbyfjlrq,data.jrStart);
            if(!szqphbjlsfyf) {
                isNeedFaJiang = true;
                gwjd = {
                    _id: paihang._id,
                    userId: paihang.userId,
                    cost1: paihang.cost1,
                    quan1: paihang.quan1,
                    time1: paihang.time1
                }
            }
            paihang.cost2 = paihang.cost1;
            paihang.quan2 = paihang.quan1;
            paihang.time2 = paihang.time1;
            paihang.cost1 = data.bczxz;
            paihang.quan1 = data.addTaskQuan;
            paihang.time1 = data.jrStart;
        }
        paihang.registerTime = data.nowTime;
        // console.warn("设置排行榜数据   ",isNeedFaJiang,paihang);
        // yield paihang.saveAsync();
    }
    if(isNeedFaJiang){
        this.phbyfjlrq = data.jrStart - 86400000;  //排行榜已发奖励的日期（0点时间戳）
        //下面是给昨天排行榜在榜玩家发放奖励
        let sgjconfig = yield this.app.models.SGJConfig.findByIdAsync('sgconfigs');
        if (sgjconfig) {
            sgjconfig.phbyfjlrq = this.phbyfjlrq;
            yield sgjconfig.saveAsync();
        }
        let limit = 10;//前10名上榜
        let zrStart = data.jrStart - 86400000;////更新今日0时的时间戳
        var opts = { 
            time1: zrStart,
            quan1: { $gt: 0}
        };
        let fields = '_id userId cost1 quan1 time1';
        //上面刚刚修改下面就查询，查询到的结果是上面修改之前的
        var list = yield this.app.models.SGJPaiHang.findMongoAsync(opts, fields, { sort: { quan1: -1 } ,limit:limit});
        // console.warn("得到排行榜昨日在榜   ",list.length,list);
        if(list.length > 0){
            if (this.phbfjTimer) {
                clearTimeout(this.phbfjTimer);
                this.phbfjTimer = null;
            }
            let zphblb = [];//在排行榜列表
            for (var i = 0; i < list.length; i++) {
                // if(gwjd.quan1 >= list[i].quan1) zphblb[zphblb.length] = gwjd;
                // else zphblb[zphblb.length] = list[i];
                // if(zphblb.length == limit) break;

                zphblb[zphblb.length] = list[i];
            }
            //this.phbfjTimer = this.app.timer.setTimeout(() => this.sendPHBJL(zphblb,0),100);
        }
    }
    if(paihang){
        yield paihang.saveAsync();
        // console.warn("设置排行榜数据结束   ");
    }
});

//发放排行榜奖励
proto.sendPHBJL = cor(function* (list,_index) {
    return
    /*let index = _index;
    if(index >= list.length) return;
    if (this.phbfjTimer) {
        clearTimeout(this.phbfjTimer);
        this.phbfjTimer = null;
    }
    let playerId = list[index]._id;
    let userid = list[index].userId;
    let diamond = this.logic.getpmjl(index);
    // console.warn("发放排行榜奖励  ",index,userid,diamond,list[index]);
    yield this.lconfigCommon.senMailToPlayer(playerId,userid,16,16,1,1,diamond,"sgjSys");
    index++;
    if(index < list.length){
        //间隔0.1秒给玩家发送排行榜奖励
        this.phbfjTimer = this.app.timer.setTimeout(() => this.sendPHBJL(list,index),100);
    }*/
});

////得到排行榜
proto.getPaiHangAsync = cor(function* (playerId) {
    let limit = 10;//前10名上榜
    let jrStart = this.logic.getTodaySJC();////更新今日0时的时间戳
    var opts = { 
        time1: jrStart,
        quan1: { $gt: 0}
    };
    let fields = 'name headurl userId cost1 quan1 time1';
    var list = yield this.app.models.SGJPaiHang.findMongoAsync(opts, fields, { sort: { quan1: -1 } ,limit:limit});
    let pmInfos = [];
    for (let i = 0; i < list.length; ++i) {
        // console.warn("排序之后  ",i,list[i]);
        let item = {
            name: list[i].name,
            headurl: list[i].headurl,
            userId: list[i].userId,
            cost1: list[i].cost1,
            quan1: list[i].quan1,
            pmjl: this.logic.getpmjl(i)
        }
        pmInfos[i] = item;
    }
    let player = yield this.app.models.Player.findByIdAsync(playerId);
    opts.userId = player.userId

    var zjph = yield this.app.models.SGJPaiHang.findMongoAsync(opts);
    var d = null
    if (zjph.length > 0) {
        d = zjph[0]
        console.warn("getpaihang self:",d)
    }
    let data = {
        pmInfos: pmInfos,
        zjph: d
    }

    return { code: C.OK, data: data };
});

// 上传真实姓名支付宝账号
proto.upZFBInfoAsync = cor(function* (playerId,realName,zfbAcc) {
     // console.log("上传真实姓名支付宝账号");
    let opts = { zfbAcc: zfbAcc,zfbName: realName};
    let fields = 'zfbAcc zfbName';
    var sgjUserList = yield this.app.models.SGJUser.findMongoAsync(opts, fields, { limit: 1 });
    if(sgjUserList.length > 0) return { code: C.FAILD, msg: "该支付宝已经被绑定过，不可重复绑定" };
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'zfbAcc zfbName zfbBindTime');
    if (sgjUser) {
        if(Date.now() - sgjUser.zfbBindTime < 86400000 ) return { code: C.FAILD, msg: "一天只能绑定一次" };
        sgjUser.zfbAcc = zfbAcc;
        sgjUser.zfbName = realName;
        yield sgjUser.saveAsync();
    }
    yield this.sendTaskRecord(1,[]);
    var data = { 
        zfbAcc:zfbAcc,
        zfbName:realName
    }
    return { code: C.OK, data: data };
});

// 得到任务列表
proto.getTaskInfoAsync = cor(function* (playerId,chairId) {
      console.log("玩家信息玩家信息玩家信息");
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    
    // var xxxrw = yield this.app.models.SGJTask.findByIdAsync("7abfd0a0-fe1a-11ee-996a-93780804e29f", 'fjTime state');
    // if(xxxrw){
    //     xxxrw.state = 1;
    //     xxxrw.fjTime = 0;
    //     yield xxxrw.saveAsync();
    //     console.warn("dakmaijfnaisfnainijn");
        
    //     // yield this.app.models.SGJTask.removeAsync({_id : "abce01f0-31f8-11ef-abd5-954f4bbeb2b1"});
    // }
    let opts0 = { 
        playerId: playerId,
        // state:0,//已领未完成
        // wcTime:0,
        state:{ $lte: 2}//已领未发奖完成
    };
    var ylwwcrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, 'des cost reachs reachC rewardt rewards state');
    // console.warn("该wanjia已领取未完成或未发奖的列表   length   "+ylwwcrwList.length+"   ylrwList  "+JSON.stringify(ylwwcrwList))
    let jrStart = this.logic.getTodaySJC();////更新今日0时的时间戳
    let opts1 = { 
        playerId: playerId,
        state:3,
        wcTime:{ $gte: jrStart, $lt: jrStart+86400000}
    };
    var jrywcrwList = yield this.app.models.SGJTask.findMongoAsync(opts1, 'des cost reachs reachC rewardt rewards state');
    // console.warn("该wanjia今日已完成的列表   length   "+jrywcrwList.length+"   jrywcrwList  "+JSON.stringify(jrywcrwList))
    var ylrwList = ylwwcrwList.concat(jrywcrwList);
    // console.warn("该wanjia已经领取的列表   length   "+ylrwList.length+"   ylrwList  "+JSON.stringify(ylrwList))
    let klqhbjl = 0;//该玩家还可以领取的红包奖励
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'taskReward jxzReward jzjrldzcz');
    if (sgjUser) {
        klqhbjl = sgjUser.jzjrldzcz - sgjUser.taskReward - sgjUser.jxzReward;
        if(klqhbjl < 0){
            let str7 = " 该玩家还可以领取的红包奖励    出错了 "+klqhbjl +" playerId "+playerId;
            logger.warn(str7);////cssj
            klqhbjl = 0;
        }
    }
    let rwcList = [];
    var sgjwjjrrwc = yield this.app.models.SGJWJJRRWC.findByIdAsync(playerId, '_id time rwcList');
    if (sgjwjjrrwc) {
        if(sgjwjjrrwc.time == jrStart) {
            rwcList = this.logic.deepCloneTL2(sgjwjjrrwc.rwcList);
        }
        else{
            rwcList = this.logic.getWJJRRWC(ylrwList,klqhbjl);
            sgjwjjrrwc.rwcList = [];
            sgjwjjrrwc.rwcList = this.logic.deepCloneTL2(rwcList);
            sgjwjjrrwc.time = jrStart;
            yield sgjwjjrrwc.saveAsync();
        }
        
    }
    else{
        rwcList = this.logic.getWJJRRWC(ylrwList,klqhbjl);
        var newsgjwjjrrwc = new this.app.models.SGJWJJRRWC({
            _id: this.ownerId,  // 标识，玩家的_id
            time: jrStart,  // 任务池对应的时间
            rwcList: this.logic.deepCloneTL2(rwcList)    // 该玩家对应时间的任务池列表
        });
        yield newsgjwjjrrwc.saveAsync();
    }
    let allRenWuInfo = this.logic.getTasksInfo(ylrwList,rwcList)//该任务最多领取次数
    var data = { 
        renwuPool: allRenWuInfo,
    }
    return { code: C.OK, data: data };
});

// 处理任务领取
proto.dealRenWuAsync = cor(function* (playerId,chairId,item) {
    // console.warn("table 处理任务  ",playerId,chairId);
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    let alltasks = null;
    if(item.index == -1){
        //是之前的任务，现在已经不在任务池中了
        var sgjwjjrrwc = yield this.app.models.SGJWJJRRWC.findByIdAsync(playerId, '_id time rwcList');
        if (sgjwjjrrwc) {
            if(sgjwjjrrwc.rwcList.length > 0) {
                alltasks = this.logic.deepCloneTL2(sgjwjjrrwc.rwcList);
            }
           
        }
    }
    let allCountInfo = this.logic.getATaskAllCount(item,alltasks)//该任务最多领取次数
    let allCount = allCountInfo.count;//该任务最多领取次数
    if(allCount <= 0) return { code: C.FAILD, msg: allCountInfo.msg };
    let cost = allCountInfo.cost;
    let zfbAcc = "";
    let zfbName = "";
    let zfbBindTime = 0;
    let taskQuan = 0;
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'zfbAcc zfbName zfbBindTime taskQuan jxzReward');
    if (sgjUser) {
        zfbAcc = sgjUser.zfbAcc;
        zfbName = sgjUser.zfbName;
        zfbBindTime = sgjUser.zfbBindTime;
        taskQuan = sgjUser.taskQuan;
    }
    if(taskQuan < cost)return { code: C.FAILD, msg: "任务券不足。" };
    // if(!zfbAcc || !zfbName || !zfbBindTime){
    //     return { code: C.FAILD, msg: "未绑定支付宝信息" };//领任务的时候绑定支付宝信息
    // }
    let opts0 = { 
        playerId: playerId,
        cost: item.cost,
        // reachs: item.reachs,
        reachs: { $all: item.reachs},
        reachC: { $all: item.reachC},
        rewardt: item.rewardt,
        rewards: item.rewards,
        state:0,
        wcTime:0
    };
    var ylwwcrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, 'playerId cost reachs reachC rewards state ');
    if(ylwwcrwList.length > 0) return { code: C.FAILD, msg: "请完成该任务之后再领取" };
    let jrStart = this.logic.getTodaySJC();////今日0时的时间戳
    let opts1 = { 
        playerId: playerId,
        cost: item.cost,
        // reachs: item.reachs,
        reachs: { $all: item.reachs},
        reachC: { $all: item.reachC},
        rewardt: item.rewardt,
        rewards: item.rewards,
        state:{ $gte: 1},
        wcTime:{ $gte: jrStart, $lt: jrStart+86400000}
    };
    var jrywcrwList = yield this.app.models.SGJTask.findMongoAsync(opts1, 'playerId cost reachs reachC rewards state ');
    var ylrwList = ylwwcrwList.concat(jrywcrwList);
    // console.warn("该任务已经领取的列表   length   "+ylrwList.length+"   ylrwList  "+JSON.stringify(ylrwList))
    let ylcs = ylrwList.length;//该任务已领取的次数
    // console.warn("该条任务领取次数已达上限???????   ",ylcs , allCount);
    if (ylcs >= allCount) {
        return { code: C.FAILD, msg: "该条任务领取次数已达上限" };
    }
    var newsgjTask = new this.app.models.SGJTask({
        _id: uuid.v1(),  // 标识
        playerId: playerId,  // 玩家标识
        userId: user.userId,    // 号码
        des: allCountInfo.des,   // 玩家标识
        cost: item.cost, // 消费
        reachs: this.logic.deepCloneTL(item.reachs),//达成该条任务所需的条件列表[1(1号牌),2(2号牌)]
        reachC: this.logic.deepCloneTL(item.reachC),//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
        rewardt: item.rewardt,//该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
        rewards: item.rewards,//该条任务达成之后的奖品数量
        state: 0,  //任务状态0:未完成，1:已完成，2:已发奖，
        lqTime: Date.now(),  //领取时间
        wcTime: 0,  //完成时间
        fjTime: 0,  //发奖时间
    });
    // console.warn("领取之后存储任务  ",JSON.stringify(newsgjTask),JSON.stringify(item));
    yield newsgjTask.saveAsync();

    let jxzrmbjl = 0;//进行中的rmb奖励
    if(item.rewardt == 1) {
        this.rwxhjq1 = this.logic.jisuanFloat(this.rwxhjq1,cost,1);  //钻石任务消耗奖券总量（领任务时记录）
    }
    else if(item.rewardt == 2){
        this.rwxhjq2 =  this.logic.jisuanFloat(this.rwxhjq2,cost,1); //RMB任务消耗奖券总量（领任务时记录）
        jxzrmbjl = item.rewards;
    }
    let nowTaskQuan = 0;
    // var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'taskQuan');
    if (sgjUser) {
        nowTaskQuan = this.logic.jisuanFloat(sgjUser.taskQuan,cost,2);
        var resTaskQuan = new this.app.models.TaskQuanRecord({
            _id: uuid.v1(),
            playerId: playerId,
            dType: 2,//领任务
            dSource: sgjUser.taskQuan,
            dSwap: 0-cost.toFixed(2),
            dNow: nowTaskQuan
        });
        yield resTaskQuan.saveAsync()
        // console.warn("领取之后修改任务券数  ",sgjUser.taskQuan,cost,nowTaskQuan);
        sgjUser.taskQuan = nowTaskQuan;
        sgjUser.jxzReward += jxzrmbjl;
        this.users[0].taskQuan = sgjUser.taskQuan;
        yield sgjUser.saveAsync();
    }
    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:this.getTodaySJC()})
    var SGJUserTongji = null
    if (SGJUserTongjis.length == 0) {
        SGJUserTongji = this.app.models.SGJUserTongji({
            _id: uuid.v1(),
            //userId: user.userId,
            usdt: user.diamond,
            taskquanlose: cost,//下注
            todaytime: this.logic.getTodaySJC()
        });
        yield SGJUserTongji.saveAsync()
    }else {
        SGJUserTongji = SGJUserTongjis[0]
        console.warn("SGJUserTongji:",SGJUserTongji)
        //SGJUserTongji.usdt = user.diamond,
            SGJUserTongji.taskquanlose = (Number(SGJUserTongji.taskquanlose) +Number(cost)).toFixed(2)//下注
        SGJUserTongji.nowtaskquan = nowTaskQuan
        yield SGJUserTongji.saveAsync()
    }
    if(this.wjrwxylb.length != this.logic.cardKindCount){
        this.wjrwxylb = _.fill(Array(this.logic.cardKindCount), 0);
    }
    for (var j = 0; j < newsgjTask.reachs.length; j++) {
        let rwyqlx = newsgjTask.reachs[j];//任务要求类型
        let rwyqsl = newsgjTask.reachC[j];//任务要求类型
        this.wjrwxylb[rwyqlx] += rwyqsl;
    }
    // console.warn("领取任务  玩家已领未完成任务需要的任务要求列表  ",this.wjrwxylb);
    ylcs++;
    var data = { 
        nowTaskQuan:nowTaskQuan.toFixed(2),
        ylcs : ylcs,//该任务已领取的次数
        renwuInfo: item
    }
    return { code: C.OK, data: data };
});

// 任务领奖
proto.renWuLingjiangAsync = cor(function* (playerId,chairId,item) {
    // console.warn("table 任务领奖  ",playerId,chairId);
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    let userid = 0;
    let zfbAcc = "";
    let zfbName = "";
    let zfbBindTime = 0;
    var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'playerId userId zfbAcc zfbName zfbBindTime taskQuan ylzsReward');
    if (sgjUser) {
        userid = sgjUser.userId;
        zfbAcc = sgjUser.zfbAcc;
        zfbName = sgjUser.zfbName;
        zfbBindTime = sgjUser.zfbBindTime;
    }
    let opts0 = { 
        playerId: playerId,
        cost: item.cost,
        reachs: { $all: item.reachs},
        reachC: { $all: item.reachC},
        rewardt: item.rewardt,
        rewards: item.rewards,
        state:{$gte: 1, $lte: 2},
        lqTime:{$gt: 0},
        wcTime:{$gt: 0},
        fjTime:0
    };
    var ywcrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, '_id playerId rewardt rewards state fjTime');
    if(ywcrwList.length < 1) return { code: C.FAILD, msg: "领奖任务未找到" };
    let rewardt = ywcrwList[0].rewardt;
    if(rewardt == 2){
        if(!zfbAcc || !zfbName || !zfbBindTime){
            return { code: C.FAILD, msg: "未绑定支付宝信息" };//领任务的时候绑定支付宝信息
        }
    }
    if(rewardt == 1){
        //钻石
        let diamond = ywcrwList[0].rewards;
        ywcrwList[0].state = 3;
        ywcrwList[0].fjTime = Date.now();
        yield ywcrwList[0].saveAsync();
        yield this.lconfigCommon.senMailToPlayer(playerId,userid,15,15,1,1,diamond,"sgjSys");
        if (sgjUser) {
            sgjUser.ylzsReward += diamond;
            yield sgjUser.saveAsync();
        }
        this.rwdcze1 += diamond;  //钻石任务兑出总额（领奖时记录）
    }
    else if(rewardt == 2){
        //RMB
        if(ywcrwList[0].state == 1){
            ywcrwList[0].state = 2;
            yield ywcrwList[0].saveAsync();
            this.rwdcze2 += ywcrwList[0].rewards;  //RMB（分）任务兑出总额（领奖时记录）
        }
        let fjres = yield this.sendTaskRecord(2,[ywcrwList[0]._id]);
    }
   
    var data = { 
        rewardt:rewardt,
        renwuInfo: item
    }
    return { code: C.OK, data: data };
});

// 得到玩家已完成的任务列表
proto.getOverTasksAsync = cor(function* (playerId,chairId) {
     // console.log("玩家信息玩家信息玩家信息");
    var user = this.users[chairId];
    if (!user) {
        return { code: C.FAILD, msg: C.GAME_PARAM_ERROR };
    }
    // if(1 == 1){
    //     var sgjUser = yield this.app.models.SGJUser.findByIdAsync(playerId, 'playerId userId jzjrldzcz jzjrldzczjlsj');
    //     //这里面全是测试代码
    //     if(sgjUser){
    //         sgjUser.jzjrldzcz = 10000;
    //         sgjUser.jzjrldzczjlsj = 0;
    //         yield sgjUser.saveAsync();
    //     }
    //     var sgjwjjrrwc = yield this.app.models.SGJWJJRRWC.findByIdAsync(playerId, '_id time rwcList');
    //     if (sgjwjjrrwc) {
    //         sgjwjjrrwc.rwcList = [];
    //         sgjwjjrrwc.time = 0;
    //         yield sgjwjjrrwc.saveAsync();
    //     }
    // }
    let opts0 = { 
        playerId: playerId,
        state: { $gt: 2 },
        wcTime:{ $gt: 2 }
    };
    var ywcrwList = yield this.app.models.SGJTask.findMongoAsync(opts0, 'cost reachs reachC rewardt rewards state lqTime wcTime fjTime',{sort: { lqTime: -1 },limit:30});
    // console.warn("该wanjia已经完成的列表   length   "+ywcrwList.length+"   ywcrwList  "+JSON.stringify(ywcrwList))
    var data = { 
        ywcrwList: ywcrwList,
    }
    return { code: C.OK, data: data };
});

//////TL++,设置记录游戏过程中的记录数据
proto.setPaijuHuiFangData = function (_operateKind,_data){
    let data = this.logic.deepCloneTL(_data);
    data.operateKind = _operateKind;
    this.PaijuHuiFang[this.PaijuHuiFang.length] = data;
};