slambb_fragranttown_theholyfarmer_2.4.3/assets/Script/public/GameData.js

var reGameStates = require('GameStates');
var AConfig = require('../Config');

import utils from "../Network/netUtils";
// import GameNet from "../Network/GameNet"
// import gameToast from "../Network/gameToast"

//全局数据类
cc.Class({
    extends: cc.Component,
    properties: {
        //记录全部道路的index
        GameData_highwayIndex: {
            default: [],
            type: [cc.Integer],
            visible: false,
            serializable: false,
        },

        //记录建筑物存储的信息
        GameData_buildings: {
            default: [],
            visible: false,
            serializable: false,
        },
        HighWayPrefabs: cc.Prefab,
        //MyMapNode
        //建筑物的节点
        BuildingsParent: {
            default: null,
            type: cc.Node,
        },
        ManageUI: {
            default: null,
            type: cc.Node,
        },

        GameVersion: {
            default: -1,
            type: cc.Integer,
        },


        Golden: {
            default: 0,
            visible: false,
        },
        Diamond: {
            default: 0,
            visible: false,
        },

        /**
         * 接口
         * todo cnt和snb 由钱包读取
         */
        CNT: {
            default: 0,
            visible: false,
        },
        SNB: {
            default: 0,
            visible: false,
        },

        /**
         * 土地租赁机会，替换 Golden 显示
         */
        animalTimes: {
            default: 0,
            visible: false,
        },


        /**
         * 用户属性
         */
        //体力
        strength: {
            default: 0,
            visible: false,
        },
        //幸运值
        lucky: {
            default: 0,
            visible: false,
        },
        //站内收益
        CNTDrawBalance: {
            default: 0,
            visible: false,
        },

        //读取的土地文件
        ConfigLand: {
            default: null,
            visible: false
        },


        /**
         * 制作计时器
         */
        toast: null,
        scheduleObj: null,
        toastCallback: null,
        isStart: true,
        isInit: false,

        /**
         * 限制重复触发支付， 正在支付中转态，
         */
        isPlayingCnt: false,
        isPlayingSnb: false,
        isPlayingLucky: false,


        /**
         * 处理请求
         */
        //现在多次触发
        isOnAddFruit: false,
        isOnSaleFruit: false,
        isOnGrantFruit: false,
        isExchangeSeed: false,
        //是否申请
        isApplying: false,
        //自动存储数据
        AutoSaveData: null,

        gameToastPrefab: cc.Prefab

    },
    onLoad() {
        //初始化GameData全局变量
        GlobalD.GameData = this;

        this.AddBuildingCost = 5;
        this.RemoveBuildingCost = 5;

        this.toast = cc.instantiate(this.gameToastPrefab);
        this.toast.parent = cc.find("Canvas/UICamera");
        this.toast.zIndex = 999;
        this.toast.active = false;
    },

    start() {
        this._tiledMap = GlobalD.TiledMap._tiledMap;

        //读取可领取的snb
        this.onGetCntToSnb((value) => {
            // console.log("当前用户转换的snb", value);
            if (value.data != null) {
                this.ManageUI.getComponent("ManageUI").onSetVillageReceivesSNBViewInfo(value.data);
            }

        })

        try {
            GlobalD.dapp.cntBalance().then((cntBalance) => {
                //会延迟返回
                // console.log("获取cnt:" + cntBalance) // string, 精度18，需要自行处理省略几位小数
                GlobalD.GameData.SetCNT(cntBalance);
            });
        } catch (err) {
            console.error(err) // 初始化失败，运行环境不是钱包环境
        }

        //登录时候已经初始化好snb了
        this.SetSNB(GlobalD.UserInfo.snb + GlobalD.UserInfo.snbPart);

        this.SetDiamond(userData.readData.diamond);
        //初始化一个租赁币
        this.SetAnimalTimes(GlobalD.animalTimes);

        //领取ui
        this.ManageUI.getComponent("ManageUI").DiamondNowlabel.string = this.GetDiamond() + '/30000'
        //设置体力值
        this.SetStrength(GlobalD.PlayerAttribute.currentStrength);
        //设置幸运值
        this.SetLucky(GlobalD.PlayerAttribute.lucky);

        //初始化生成房屋 
        /**
         * dapp设定： 如果固定土地冲突，删除冲突的建筑和回收仓库
         * 新增：
         * 当进入其他用户农场时候，只处理土地显示信息。其他的都隐藏起来，不进行操作
         * 更新的数据：1.土地
         * 隐藏的数据：1.隐藏游客
         *            2.隐藏用户当前建筑
         *            3.隐藏当前用户菜单，显示对应农场按钮
         */
        this.ManageUI.getComponent('ManageBuildings').InitBuildings();


        this.ManageUI.getComponent('ManageUI').Init();
    },

    //GET / SET /Plus
    GetGameDate: function () {
        return this.GameDate;
    },
    SetGameDate: function (num) {
        this.GameDate = num;
    },
    PlusGameDate: function (num) {
        this.GameDate += num;
    },
    GetGolden: function () {
        return parseInt(this.Golden);
    },
    GetGoldenCallBack(_CallBack) {
        if (_CallBack)
            _CallBack({ resGolden: parseInt(this.Golden) });
    },
    SetGolden: function (Num) {
        let LastMoney = this.Golden;
        this.Golden = Num;
        let CurrentMoney = Num;
        this.ManageUI.getComponent('ManageUI').GoldenChangeCallBack(this.GetGolden(), LastMoney, CurrentMoney);
    },
    PlusGolden: function (Num) {
        if (this.Golden + Num < 0) {
            this.SetGolden(0);
        }
        else {
            this.SetGolden(this.Golden + Num);
        }
        // task.task50W();
    },
    GetDiamond: function () {
        return parseInt(this.Diamond);
    },
    SetDiamond: function (num) {
        let LastMoney = this.Diamond;
        this.Diamond = num;
        let CurrentMoney = num;
        this.ManageUI.getComponent("ManageUI").DiamondNowlabel.string = this.Diamond + '/30000'
        this.ManageUI.getComponent('ManageUI').DiamondChangeCallBack(this.GetDiamond(), LastMoney, CurrentMoney);
    },
    PlusDiamond: function (num) {
        if (this.Diamond + num < 0) {
            this.SetDiamond(0);
        }
        else {
            this.SetDiamond(this.Diamond + num);
        }
    },

    /**
     * 游戏里面的cnt 和神农呗
     */
    GetCNT: function () {
        return parseFloat(this.CNT);
    },
    SetCNT: function (Num) {
        this.CNT = Num;
        this.ManageUI.getComponent('ManageUI').CNTChangeCallBack(this.CNT);
    },
    GetSNB: function () {
        return parseFloat(this.SNB);
    },
    SetSNB: function (Num) {
        this.SNB = Num;
        this.ManageUI.getComponent('ManageUI').SNBChangeCallBack(this.SNB);
    },

    //租赁次数
    GetAnimalTimes: function () {
        return parseFloat(this.animalTimes);
    },
    SetAnimalTimes: function (Num) {
        this.animalTimes = Num;
        this.ManageUI.getComponent('ManageUI').AnimalTimesChangeCallBack(this.animalTimes);
    },


    GetStrength: function () {
        return parseFloat(this.strength);
    },
    SetStrength: function (Num) {
        this.strength = Num;
        this.ManageUI.getComponent('ManageUI').StrengthChangeCallBack(this.strength);
    },

    GetLucky: function () {
        return parseFloat(this.lucky);
    },
    SetLucky: function (Num) {
        this.lucky = Num;
        this.ManageUI.getComponent('ManageUI').LuckyChangeCallBack(this.lucky);
    },


    GetWorkerLV: function () {
        return parseInt(this.WorkerLV);
    },
    SetWorkerLV: function (num) {
        this.WorkerLV = num;
    },
    PlusWorkerLV: function (num) {
        this.WorkerLV += num;
    },
    GetWorkerNum: function () {
        return parseInt(this.WorkerNum);
    },
    SetWorkerNum: function (num) {
        this.WorkerNum = num;
    },
    PlusWorkerNum: function (num) {
        this.WorkerNum += num;
    },
    GetLastTimeEveryDayRewardsDate: function () {
        return this.LastTimeEveryDayRewardsDate;
    },
    //获取转盘 时间
    GetLastTimeLuckDate: function () {
        return this.LastTimeLuckDate;
    },
    //设置转盘时间
    SetLastTimeLuckDate: function (DateString) {
        this.LastTimeLuckDate = DateString;
    },
    SetLastTimeEveryDayRewardsDate: function (DateString) {
        this.LastTimeEveryDayRewardsDate = DateString;
    },

    //工人信息数组
    GetWorkerCharacterInfoArray: function () {
        return this.CharacterInfoArray;
    },
    SetWorkerCharacterInfoArray: function (item) {
        this.CharacterInfoArray = item;
    },

    /*** */
    GetWorkerCapacity: function () {
        return parseInt((this.WorkerCapacity));
    },
    SetWorkerCapacity: function (num) {
        this.WorkerCapacity = num;
    },
    PlusWorkerCapacity: function (num) {
        this.WorkerCapacity += num;
    },
    GetTerritoryStateArray: function () {
        return this.TerritoryStateArray;
    },
    SetTerritoryStateArray: function (aTerritoryStateArray) {
        this.TerritoryStateArray = aTerritoryStateArray;
    },
    PlusTerritoryStateArray: function (Item) {
        this.TerritoryStateArray.push(Item);
    },
    GetBuildingStateArray: function () {
        return this.BuildingStateArray;
    },
    SetBuildingStateArray: function (aBuildingStateArray) {
        this.BuildingStateArray = aBuildingStateArray;
    },
    PlusBuildingStateArray: function (Item) {
        this.BuildingStateArray.push(Item);
    },
    GetBuildingLockStateArray: function () {
        return this.BuildingLockStateArray;
    },
    SetBuildingLockStateArray: function (aArray) {
        this.BuildingLockStateArray = aArray;
    },
    PlusBuildingLockStateArray: function (Item) {
        this.BuildingLockStateArray.push(Item);
    },

    GetBuildingNumArray: function () {
        return this.BuildingNumArray;
    },
    SetBuildingNumArray: function (aBuildingNumArray) {
        this.BuildingNumArray = aBuildingNumArray;
    },
    PlusBuildingNumArray: function (Item) {
        this.BuildingNumArray.push(Item);
    },
    //操作钻石数据
    GetDiamondNumArray: function () {
        return this.DiamondNumArray;
    },
    SetDiamondNumArray: function (aDiamondNumArray) {
        this.DiamondNumArray = aDiamondNumArray;
    },
    GetEveryDayRewardsArray: function () {
        return this.EveryDayRewardsArray;
    },
    SetEveryDayRewardsArray: function (aArray) {
        this.EveryDayRewardsArray = aArray;
    },
    PlusEveryDayRewardsArray: function (Item) {
        this.EveryDayRewardsArray.push(Item);
    },
    GetFoodTradeState: function () {
        return parseInt((this.FoodTradeState));
    },
    SetFoodTradeState: function (num) {
        this.FoodTradeState = num;
    },
    PlusFoodTradeState: function (num) {
        this.FoodTradeState += num;
    },
    GetWoodTradeState: function () {
        return parseInt((this.WoodTradeState));
    },
    SetWoodTradeState: function (num) {
        this.WoodTradeState = num;
    },
    PlusWoodTradeState: function (num) {
        this.WoodTradeState += num;
    },
    GetMineralTradeState: function () {
        return parseInt((this.MineralTradeState));
    },
    SetMineralTradeState: function (num) {
        this.MineralTradeState = num;
    },
    PlusMineralTradeState: function (num) {
        this.MineralTradeState += num;
    },
    GetLotteryTimes: function () {
        return parseInt((this.LotteryTimes));
    },
    SetLotteryTimes: function (num) {
        this.LotteryTimes = num;
    },
    PlusLotteryTimes: function (num) {
        this.LotteryTimes += num;
    },

    /**
     * 兑换种子时候，特殊处理数据
     * 扣除相应的钻石
     */
    exchangeSeed(diamondAmount, callback) {
        if (this.isExchangeSeed) {
            console.warn("正在兑换中...");
            return;
        }
        this.isExchangeSeed = true;
        //先暂停存储
        // this.unschedule(this.AutoSaveData);

        utils.post(utils.api.exchangeSeeds, { diamondAmount: diamondAmount, seedId: 8 }, (flag, value) => {
            console.log("兑换flag", flag);
            if (flag) {
                console.log("兑换种子", value.code, value.msg);
                //兑换成功后
                if (0 === value.code) {
                    //更新一次数据
                    let _playerData = JSON.parse(value.data.playerData);
                    console.log("兑换后的钻石：", _playerData.Diamond);
                    //更新本地钻石数据
                    this.SetDiamond(_playerData.Diamond);

                }
                callback(value);
            }

            this.isExchangeSeed = false;
            //重新开启存储
            // this.schedule(this.AutoSaveData, 15);
        })
    },
    /**
     * 获取是否租赁过的状态
     */
    getPlayerExchangeState(callback) {
        utils.get(utils.api.playerExchangeState, {}, (flag, value) => {
            // console.log("租赁状态：", value);
            if (flag)
                callback(flag, value);
        })
    },

    /**
     * 暂时不需要从这里读取
     */
    getLandConfig() {
        utils.get(utils.api.landConfig, {}, (flag, value) => {
            if (flag && 0 === value.code) {
                this.ConfigLand = value.data;
            } else {
                console.warn("未能读取到config土地？");
            }
        })
    },
    //获取自己全部租赁土地
    getSelfUserLandList(callback) {
        utils.get(utils.api.userLandList, {}, (flag, value) => {
            if (flag && 0 === value.code) {
                GlobalD.UserLeaseLand = value.data;
                if (callback)
                    callback();
            } else {
                console.warn("读取到用户的土地错误？");
            }
        })
    },
    //获取用户全部租赁土地
    getOtherUserLandList(otherUserId, callback) {
        this.showToast(cc.find("Canvas/UICamera"), "载入玩家数据中..", 5);
        utils.get(utils.api.userLandAndCanStealList, { otherUserId: otherUserId }, (flag, value) => {
            // console.log(otherUserId + ",获取其他用户土地数据:", value);
            this.hideToast();
            if (flag && 0 === value.code) {
                GlobalD.OtherLeaseland = value.data;
                //todo 获取数据成功，进入切换流程,设置 false，处理其他用户对应的土地
                this.ManageUI.getComponent('ManageBuildings').spawnConfigLand(GlobalD.OtherLeaseland, false);

                //收起菜单
                GlobalD.game._ManageUIScript.onHideMenu();
                //收起底部菜单栏
                GlobalD.game._ManageUIScript.onBottomMenuView(false);
                //显示进入其他用户场景后菜单操作
                GlobalD.game._ManageUIScript.onOtherFarmerView(true);

                //关闭当前列表
                GlobalD.game._ManageUIScript.onListUserInfo_Close();

                this.hideToast();
                // this.showToast(cc.find("Canvas/UICamera"), "载入成功..", 1);
                this.hideToast();
                if (callback)
                    callback();
            } else {
                this.showToast(cc.find("Canvas/UICamera"), "获取数据失败..", 1);
                console.warn("获取其他用户土地数据错误？");

            }

        })
    },
    //获取用户可以偷取的列表
    onGetCanStealUserList(page, limit, callback) {
        this.showToast(cc.find("Canvas/UICamera"), "刷新列表中..", 10);
        utils.get(utils.api.canStealUserList, { page: page, limit: limit }, (flag, value) => {
            this.hideToast();
            if (flag && 0 === value.code) {
                if (callback)
                    callback(value.data);
            } else {
                let myList = [];
                if (callback)
                    callback(myList);
            }

        })
    },

    // onGetSnbInfoList(page, limit, callback) {

    //     utils.get(utils.api.snbList, { page: page, limit: limit }, (flag, value) => {
    //         // console.log("snb操作日志", value);
    //         if (flag && 0 === value.code) {
    //             if (callback)
    //                 callback(value.data);
    //         } else {
    //             let mySnbList = [];
    //             if (callback)
    //                 callback(mySnbList);
    //         }

    //     })
    // },
    //狗的相关处理
    //获取状态
    onGetDogState(data, callback) {
        utils.get(utils.api.getEquipmentByType, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    onGetEquipmentListState(data, callback) {
        utils.get(utils.api.getListEquipment, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    onGetAddDogFood(data, callback) {
        utils.post(utils.api.addFood, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    onSetDogShowState(data, callback) {
        utils.post(utils.api.setDogShowState, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //获取狗粮商城列表
    onGetMallFoodList(callback) {
        utils.get(utils.api.getMallFoodList, {}, (flag, value) => {
            if (flag)
                callback(value);
        })

    },
    //商城装备列表
    onGetMallEquipmentList(callback) {
        utils.get(utils.api.getMallEquipmentList, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    onGetAddEquipment(data, callback) {
        utils.post(utils.api.addEquipment, data, (flag, value) => {
            console.log(value);
            callback(flag, value);
        })
    },
    //获取用户已租赁土地的状态
    getLandState(context) {
        let { landId, callback } = context;
        utils.get(utils.api.landState, { landId: landId }, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //获取商城种子
    getMallSeed(callback) {
        utils.get(utils.api.mallSeed, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },

    getWarehouseSeedAndFruit(callback) {
        utils.get(utils.api.getSeedAndFruit, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //获取种子状态
    onGetSeedState(data, callback) {
        utils.get(utils.api.getSeedState, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },

    //种植种子
    // data:{landId:1,seedId:1}
    onPlant(data, callback) {
        utils.get(utils.api.plant, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },

    //收取果实
    onAddFruit(data, callback) {
        if (this.isOnAddFruit) {
            console.log("收取果实过快！");
            return;
        }
        this.isOnAddFruit = true;
        utils.post(utils.api.addFruit, data, (flag, value) => {
            this.isOnAddFruit = false;
            if (flag)
                callback(value);
        })
    },

    //一键收取果实，偷取
    onStealAllFruit(data, callback) {
        if (this.isOnAddFruit) {
            console.log("一键收取果实过快！");
            return;
        }
        this.isOnAddFruit = true;
        this.showToast(cc.find("Canvas/UICamera"), "收取果实中..", 5);
        utils.post(utils.api.stealAllFruit, data, (flag, value) => {
            this.isOnAddFruit = false;
            this.hideToast();
            if (0 === value.code) {
                //如果返回一个体力信息，更新对应的新的用户信息。
                if (value.data.playerAttribute) {
                    GlobalD.PlayerAttribute = value.data.playerAttribute;
                    //这里需要更新体力值
                    this.SetStrength(GlobalD.PlayerAttribute.currentStrength);
                }
            }

            if (flag)
                callback(value);
        })
    },

    //单个收取
    onStealFruit(data, callback) {
        if (this.isOnAddFruit) {
            console.log("偷取果实过快！");
            return;
        }
        this.isOnAddFruit = true;
        this.showToast(cc.find("Canvas/UICamera"), "偷取收成中..", 5);
        utils.post(utils.api.stealFruit, data, (flag, value) => {
            this.isOnAddFruit = false;
            this.hideToast();
            if (0 === value.code) {
                //如果返回一个体力信息，更新对应的新的用户信息。
                if (value.data.playerAttribute) {
                    GlobalD.PlayerAttribute = value.data.playerAttribute;
                    //这里需要更新体力值
                    this.SetStrength(GlobalD.PlayerAttribute.currentStrength);
                }
            }

            if (flag)
                callback(value);
        })
    },

    //出售果实
    onSaleFruit(data, callback) {
        if (this.isOnSaleFruit) {
            console.log("出售果实过快！");
            return;
        }
        this.isOnSaleFruit = true;
        utils.post(utils.api.saleFruit, data, (flag, value) => {
            this.isOnSaleFruit = false;
            if (flag)
                callback(value);
        })
    },

    //赠送果实
    onGrantFruit(data, callback) {
        if (this.isOnGrantFruit) {
            console.log("赠送果实过快！");
            return;
        }
        this.isOnGrantFruit = true;
        utils.post(utils.api.grantFruit, data, (flag, value) => {
            this.isOnGrantFruit = false;
            if (flag)
                callback(value);
        })
    },

    //神农呗购买种子
    onBuySeedsWithSNB(snbAmount, seedId, callback) {
        utils.post(utils.api.snbBuySeeds, { payAmount: snbAmount, seedId: seedId }, (flag, value) => {
            //callback里面处理flag判断
            callback(flag, value);
        })
    },

    //获取用户的snb
    onGetUserSnb(callback) {
        utils.get(utils.api.userSnbInfo, {}, (flag, value) => {
            if (flag) {
                GlobalD.GameData.SetSNB(value.data.SNB + value.data.snbPart);
            }
            if (flag && callback)
                callback(value);
        })
    },

    /**
     * 支付cnt操作
     * @param {*} amount // 需支付金额
     * @param {*} payType 支付类型，1购买土地租凭， 2自然灾害防护，3野兽防护, 4种子
     * @param {*} itemType 操作物品的id 字符串
     */
    payCNT(cntAmount, payType, itemType, callback) {
        console.log("购买金额：" + cntAmount + "购买类型PlayType：" + payType + "购买物品的id:" + itemType);
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能payCNT!");
            return;
        }
        //
        if (this.isPlayingCnt) {
            console.warn("同时触发支付CNT过快！");
            return;
        }
        if (GlobalD.GameData.GetCNT() < cntAmount) {
            console.log("cnt 不足，GetCNT：" + GlobalD.GameData.GetCNT() + "消费的cntAmount" + cntAmount);
            this.showToast(cc.find("Canvas/UICamera"), "CNT不足！", 2);
            return;
        }
        this.isPlayingCnt = true;
        this.showToast(cc.find("Canvas/UICamera"), "支付处理中...", 60);

        GlobalD.dapp.payCnt(cntAmount, payType, itemType).then((data) => {
            const [err, tx] = data;
            this.isPlayingCnt = false;
            if (err === null) {
                // TODO 成功, 支付为链上操作，需要提供回调接口给这边服务端确认交易成功后修改购买订单结果
                console.log(tx) // 交易hash，唯一标识符

                GlobalD.dapp.cntBalance().then((cntBalance) => {
                    //会延迟返回
                    // console.log("更新cnt:" + cntBalance) // string, 精度18，需要自行处理省略几位小数
                    GlobalD.GameData.SetCNT(cntBalance);
                });
                this.showToast(cc.find("Canvas/UICamera"), "支付成功!", 10);
                setTimeout(() => {
                    this.showToast(cc.find("Canvas/UICamera"), "区块确认中，请耐心等待！", 120)
                }, 3100)


            } else {
                console.log(err)
                this.showToast(cc.find("Canvas/UICamera"), err, 2);
            }

            if (callback) {
                callback(data);
            }
        });
    },

    /**
     * 神农呗转换CNT ,比例是5:1
     * @param {*} snbAmount 
     * @param {*} callback 
     * @returns 
     */
    onSnbToCnt(snbAmount, callback) {
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能onSnbToCnt!");
            return;
        }
        // GlobalD.GameData.showToast(cc.find("Canvas/UICamera"), "暂不支持兑换CNT！", 2, () => {
        //     console.log("finish toast!");
        // });
        // return;
        if (this.isPlayingSnb) {
            console.warn("同时触发支付SNB过快！");
            return;
        }
        if (GlobalD.GameData.GetSNB() <= 0) {
            console.log("神农呗数量GetSNB:", GlobalD.GameData.GetSNB(), "替换snbAmount:", snbAmount);
            this.showToast(cc.find("Canvas/UICamera"), "神农呗数量不足！", 2);
            return;
        }
        this.showToast(cc.find("Canvas/UICamera"), "区块确认中，请耐心等待！", 10);

        this.isPlayingSnb = true;
        GlobalD.dapp.snbToCnt(snbAmount).then((data) => {
            //更新日志数据
            cc.find("GameNode/ManageDapp").getComponent("ManageDapp").onUpdateSnbList();
            const [err, tx] = data;
            this.isPlayingSnb = false;
            if (err === null) {
                // TODO 成功, 兑换为链上操作，需要提供回调接口给这边服务端确认交易成功后修改扣除SNB数量
                console.log(tx) // 交易hash，唯一标识符
                //扣除对应的神农呗，本地修改显示
                GlobalD.GameData.SetSNB(GlobalD.GameData.GetSNB() - snbAmount);

                GlobalD.dapp.cntBalance().then((cntBalance) => {
                    //会延迟返回
                    // console.log("更新cnt:" + cntBalance) // string, 精度18，需要自行处理省略几位小数
                    GlobalD.GameData.SetCNT(cntBalance);
                });
                this.showToast(cc.find("Canvas/UICamera"), "区块确认中，请耐心等待！", 2);
            } else {
                console.log(err)
                this.showToast(cc.find("Canvas/UICamera"), err, 2);
            }

            if (callback) {
                callback(data);
            }
        });
    },
    //站内收益
    onCntCanWithdrawBalance(callback) {
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能onGetCNTRevenue!");
            return;
        }
        GlobalD.dapp.cntCanWithdrawBalance().then((data) => {
            const { err, res } = data;
            if (err === null) {
                // console.log(res) //Number 返回数字
                GlobalD.GameData.CNTDrawBalance = res;
            }
            //todo ，记录一个信息
            if (callback) {
                callback(data);
            }
        });
    },
    //站内收益提现
    onCntWithdraw(amount, callback) {
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能onCntWithdraw!");
            return;
        }
        this.showToast(cc.find("Canvas/UICamera"), "收益正在提现中", 10);
        GlobalD.dapp.cntWithdraw(amount).then((data) => {
            const [err, tx] = data;
            console.log("onCntWithdraw:", data);
            if (err === null) {
                console.log(tx) //String|null 交易唯一哈市
                this.showToast(cc.find("Canvas/UICamera"), "提现成功！", 1);
            } else {
                this.showToast(cc.find("Canvas/UICamera"), err, 1);
            }
            if (callback) {
                callback(data);
            }
        });
    },

    //获取账户站内CNT明细（村长和镇长才有）
    onCntLog(page, limit, callback) {
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能onGetSnbToCntInfo!");
            return;
        }
        GlobalD.dapp.cntLog(page, limit).then((data) => {
            const { err, res } = data;
            // if (err === null) {
            //     console.log(res) //
            // }
            if (callback) {
                callback(data);
            }
        });
    },

    //获取 神农呗转 CNT 日志
    onGetSnbToCntInfo(page, limit, callback) {
        if (!GlobalD.dapp) {
            console.warn("GlobalD.dapp未初始化，不能onGetSnbToCntInfo!");
            return;
        }
        GlobalD.dapp.swapLog(page, limit).then((data) => {
            const { err, res } = data;
            if (err === null) {
                console.log(res) //
            }
            if (callback) {
                callback(data);
            }
        });
    },

    //获取 snb 流水日志
    onGetSnbInfoList(page, limit, callback) {

        utils.get(utils.api.snbList, { page: page, limit: limit }, (flag, value) => {
            // console.log("snb操作日志", value);
            if (flag && 0 === value.code) {
                if (callback)
                    callback(value.data);
            } else {
                let mySnbList = [];
                if (callback)
                    callback(mySnbList);
            }

        })
    },

    //获取snb申请列表
    onGetSnbApplyPage(isState, page, limit, callback) {
        utils.get(utils.api.getSnbApplyPage, { isState: isState, page: page, limit: limit }, (flag, value) => {
            if (flag && 0 === value.code) {
                if (callback)
                    callback(value.data);
            } else {
                let getSnbApplyPage = [];
                if (callback)
                    callback(getSnbApplyPage);
            }

        })
    },
    //提交申请
    onPostApplySnbToCnt(applyAmount, callback) {
        if (this.isApplying) {
            this.showToast(cc.find("Canvas/UICamera"), "正在申请中..", 1);
            return;
        }
        this.isApplying = true;

        utils.post(utils.api.applySnbToCnt, { applyAmount: applyAmount }, (flag, value) => {
            this.isApplying = false;
            if (flag)
                callback(value);
        })
    },

    //获取转换的snb
    onGetCntToSnb(callback) {
        utils.get(utils.api.getCntToSnb, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //领取SNB接口
    onReceiveCntToSnb(callback) {
        utils.get(utils.api.receiveCntToSnb, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //校验snb凭证
    onCheckApplySnbToCnt(certificateId, callback) {
        utils.post(utils.api.checkApplySnbToCnt, { certificateId: certificateId }, (flag, value) => {
            if (flag)
                callback(value);
        })
    },


    //切换不同身份的场景，这里处理
    onSwitchAddressBg(_level) {
        //设置背景
        GlobalD.TiledMap.setMapInfo(_level);
    },

    /**
     * 获取灾难
     */
    onGetDisasterHistory(callback) {
        utils.get(utils.api.disasterHistory, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    /**
     * 获取灾难防护
     * @param {*} callback 
     */
    onGetDisasterProtected(callback) {
        utils.get(utils.api.getDisasterProtectedMap, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },



    /**
     * 操作工具
     */
    //获取工具
    onGetTools(callback) {
        utils.get(utils.api.getTools, {}, (flag, value) => {
            // console.log("工具：", flag, value);
            if (flag)
                callback(value);
        })
    },
    //使用工具
    onPostToolToLand(data, callback) {
        utils.post(utils.api.postUseLuckyTools, data, (flag, value) => {
            // console.log(data, "=使用工具：", flag, value);
            if (flag && 0 === value.code && value.flag) {
                GlobalD.PlayerAttribute = value.data.playerAttribute;
                this.SetLucky(GlobalD.PlayerAttribute.lucky);
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 1);
                callback(value);
            } else {
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 1);
            }
        })
    },
    //获取土地等级
    onGetLevel(callback) {
        utils.get(utils.api.getLevel, {}, (flag, value) => {
            console.log("获取土地", flag, value);
            if (flag)
                callback(value);
        })
    },
    //升级土地
    onPostLandLevelUp(data, callback) {
        utils.post(utils.api.postLandLevelUp, data, (flag, value) => {
            // console.log(data, "=升级土地", flag, value);
            if (flag && 0 === value.code && value.flag) {
                GlobalD.PlayerAttribute = value.data.playerAttribute;
                this.SetLucky(GlobalD.PlayerAttribute.lucky);
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 1);
                callback(value);
            } else {
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 1);
            }
        })
    },
    /**
     * 注意限制检查snb
     * @param {*} data 
     * @param {*} callback 
     */
    onPostLuckToSnb(data, callback) {
        if (this.isPlayingLucky) return;
        this.isPlayingLucky = true;
        this.showToast(cc.find("Canvas/UICamera"), "兑换SNB中", 2);
        utils.post(utils.api.luckToSnb, data, (flag, value) => {
            this.isPlayingLucky = false;
            // console.log(data, "=兑换snb", flag, value);
            if (flag && 0 === value.code && value.flag) {
                //如果返回一个体力信息，更新对应的新的用户信息。
                //更新日志数据
                cc.find("GameNode/ManageDapp").getComponent("ManageDapp").onUpdateSnbList();
                GlobalD.PlayerAttribute = value.data.playerAttribute;
                this.SetLucky(GlobalD.PlayerAttribute.lucky);

                GlobalD.UserInfo = value.data.userInfo;
                this.SetSNB(GlobalD.UserInfo.snb + GlobalD.UserInfo.snbPart);
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 2);
                callback(value);
            }
            else {
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 2);
            }

        })
    },

    /**
     * 获取可租赁牧场的次数
     */
    onGetAnimalTimes() {
        utils.get(utils.api.getAnimalTimes, {}, (flag, value) => {
            // console.log("getAnimalTimes", flag, value);
            if (flag && 0 === value.code && value.flag) {
                this.SetAnimalTimes(value.data);
            }

            this.showToast(cc.find("Canvas/UICamera"), value.msg, 2);
        })
    },

    onPlayAnimalLand(data, callback) {
        utils.post(utils.api.payAnimalLand, data, (flag, value) => {
            // console.log("payAnimalLand", flag, value);
            if (flag && 0 === value.code && value.flag) {
                this.SetAnimalTimes(value.data.times);
                if (callback)
                    callback(value);
            } else {
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 2);
            }
        })
    },
    onMultipleAnimalLand(data, callback) {
        console.log(data);
        utils.post(utils.api.multipleAnimalLand, data, (flag, value) => {
            // console.log("multipleAnimalLand", flag, value);
            if (flag && 0 === value.code && value.flag) {
                callback(value);
            } else {
                this.showToast(cc.find("Canvas/UICamera"), value.msg, 2);
            }
        })
    },


    //喂养动物
    onBuyAnimalFood(data, callback) {
        utils.post(utils.api.buyAnimalFood, data, (flag, value) => {
            // console.log("buyAnimalFood", flag, value);
            if (flag)
                callback(value);

        })
    },
    //积分兑换种子
    onGetPlayerScore(data, callback) {
        utils.post(utils.api.playerScoreExchange, data, (flag, value) => {
            if (flag)
                callback(value);
        })
    },
    //返回十天期的当前种子
    onGetPlayerSeeds(callback) {
        utils.get(utils.api.playerScoreSeeds, {}, (flag, value) => {
            if (flag)
                callback(value);
        })
    },

    //获取一个toast
    getToast() {
        return this.toast;
    },
    hideToast() {
        this.toast.active = false;
        if (this.scheduleObj) {
            this.unschedule(this.scheduleObj);
            this.scheduleObj = null;
        }
    },
    showToast(parent, content, time) {
        if (this.toast) {
            if (this.scheduleObj) {
                this.unschedule(this.scheduleObj);
                this.scheduleObj = null;
            }
            this.scheduleObj = () => {
                this.toast.active = false
            };
            this.scheduleOnce(this.scheduleObj, time);
            this.toast.active = true;
            this.toast.parent = parent;
            this.toast.zIndex = 999;
            let DetailLabel = this.toast.getChildByName('DetailLabel');
            DetailLabel.getComponent(cc.Label).string = content;

            // console.log(content, time)
        } else {
            console.error("Toast 尚未初始化！");
        }
    },

    onTestToken() {
        utils.onTestToken();
    },
    onDestroy() {
        if (this.AutoSaveData) {
            this.unschedule(this.AutoSaveData);
            this.AutoSaveData = null;
        }
    }

});