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,
    },

    //读取数据
    readData: {
      default: null,
      visible: false,
    },

    /**
     * 接口
     * todo cnt和snb 由钱包读取
     */
    CNT: {
      default: 0,
      visible: false,
    },
    SNB: {
      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,

    /**
     * 处理请求
     */
    //现在多次触发
    isOnAddFruit: false,
    isOnSaleFruit: false,
    isOnGrantFruit: false,

    //自动存储数据
    AutoSaveData: null,
  },
  onLoad() {
    //初始化GameData全局变量
    GlobalD.GameData = this
    this.GameConfig()
  },
  GameConfig() {
    this.AddBuildingCost = 5
    this.RemoveBuildingCost = 5

    //
    this.Dapp = {
      UserInfo: null,
    }
  },
  start() {
    cc.loader.loadRes(
      'prefab/gameToast',
      function (err, texture) {
        this.toast = cc.instantiate(texture)
        this.toast.parent = cc.find('Canvas/UICamera')
        this.toast.zIndex = 999
        this.toast.active = false
        this.scheduleObj = this.schedule(() => {
          this.updateToast()
        }, 1)
      }.bind(this)
    )

    this._tiledMap = GlobalD.TiledMap._tiledMap
    //调用初始化dapp
    this.isDebugMode(GlobalD.dapp)
  },
  /**
   * 根据 不存在dapp 的话，使用本地测试
   * @param {*} bInit
   */
  isDebugMode: function (bInit) {
    if (bInit) {
      //读取网络数据
      try {
        GlobalD.dapp.cntBalance().then((cntBalance) => {
          //会延迟返回
          // console.log("获取cnt:" + cntBalance) // string, 精度18，需要自行处理省略几位小数
          GlobalD.GameData.SetCNT(cntBalance)
        })
      } catch (err) {
        console.error(err) // 初始化失败，运行环境不是钱包环境
      }
      //登录时候已经初始化好snb了
      this.SNB = GlobalD.UserInfo.snb

      this.readData = userData.readData
      // cc.log('playerPullInfo 读取到数据？：', this.readData)
      this.InitNextworkData()
      this.InitSceneInfo()

      // 自动存储数据
      /**
       * todo 如果退出游戏，触发一次存储。
       */
      this.AutoSaveData = function () {
        this.pushData(true)
      }
      this.schedule(this.AutoSaveData, 15)
    } else {
      // 清除
      cc.log('本地数据重新开始，并且不初始化')
      // this.onClearAllData();
      this.Init()
      this.InitSceneInfo()
      this.AutoSaveData = function () {
        this.pushData(false)
      }
      this.schedule(this.AutoSaveData, 10)
    }
  },

  getData: function () {
    //如果开局没有读取到网络数据，就这里初始化
    if (userData.readData == null) {
      cc.log('本地数据：', cc.sys.localStorage.getItem('userdata'))
      let userdata = cc.sys.localStorage.getItem('userdata')
      if (userdata) {
        this.readData = JSON.parse(userdata)
      }
      this.Init()
      this.InitSceneInfo()
    } else {
      this.readData = userData.readData
      cc.log('读取到数据？：', this.readData)
      this.Init()
      this.InitSceneInfo()
    }
  },

  InitSceneInfo() {
    //根据顺序生成
    //初始化时间ui
    cc.find('GameNode/ManageTimer').getComponent('ManageTimer').Init()
    //初始化金钱ui,gold,diamond, cnt,snb,
    cc.find('GameNode/ManageGolden')
      .getComponent('ManageGolden')
      .InitManageGlodenUI()
    // //初始化地图物件
    // cc.find("GameNode/ManageMap").getComponent('ManageMap').InitManageMap();
    GlobalD.TiledMap.onInitSolid()

    //初始化生成房屋
    /**
     * dapp设定： 如果固定土地冲突，删除冲突的建筑和回收仓库
     */
    this.ManageUI.getComponent('ManageBuildings').InitBuildings()

    //初始化道路
    /**
     * 原本游戏设定是先生产道路，现在为了方便处理等房屋生产后，再处理公路
     * dapp设定： 如果固定土地冲突，删除对应的公路
     */
    this.onSpawnHighway()

    //初始化生成人物
    /**
     * dapp设定： 如果固定土地位置冲突，把人物生成位置放置到主路
     * onSpawnWorkerAIFromStoredData 此函数处理
     */
    cc.find('GameNode/ManageWorker').getComponent('ManageWorker').InitWorkerAI()

    let _BFirstLoadGame = this.readData ? this.readData.BFirstLoadGame : 0
    //初始化新手教学
    GlobalD.ManageTask.InitTask(_BFirstLoadGame)

    this.ManageUI.getComponent('ManageUI').Init()
  },
  InitNextworkData() {
    // console.log("this.readData", this.readData);
    this.Golden = this.readData.Golden
    this.Diamond = this.readData.Diamond
    this.shareGive = this.readData.shareGive
    //签到分享给钻石金币
    this.signInGive = this.readData.signInGive
    //每个月 给的 低保
    this.EveryGive = this.readData.EveryGive
    //公共分享
    this.publicGive = this.readData.publicGive

    // cc.log('初始化网络数据');
    //读取日期数据
    this.GameYear = this.readData.GameYear
    this.GameMonth = this.readData.GameMonth
    this.GameDay = this.readData.GameDay

    //读取金币
    this.Golden = this.readData.Golden
    //读取钻石
    this.Diamond = this.readData.Diamond
    // cc.log('this.readData.Diamond', this.readData.Diamond);
    //读取工人等级
    this.WorkerLV = this.readData.WorkerLV
    //工人数量
    this.WorkerNum = this.readData.WorkerNum
    //工人容量
    this.WorkerCapacity = this.readData.WorkerCapacity
    this.GameDate = this.readData.GameDate
    this.LastTimeEveryDayRewardsDate = this.readData.LastTimeEveryDayRewardsDate
    this.LastTimeLuckDate = this.readData.LastTimeLuckDate
    this.EveryDayRewardsArray = this.readData.EveryDayRewardsArray //.split('_');
    this.TerritoryStateArray = this.readData.TerritoryStateArray //.split('_');
    //面板状态
    this.BuildingStateArray = this.readData.BuildingStateArray //.split('_');

    //解锁设置为 不用解锁
    // this.BuildingLockStateArray.forEach((value, index, array) => {
    //     array[index] = 1;
    // })
    this.BuildingLockStateArray = this.readData.BuildingLockStateArray //.split('_');
    this.BuildingNumArray = this.readData.BuildingNumArray //.split('_');
    this.DiamondNumArray = this.readData.DiamondNumArray //.split('_');
    this.FoodTradeState = this.readData.FoodTradeState
    this.WoodTradeState = this.readData.WoodTradeState
    this.MineralTradeState = this.readData.MineralTradeState
    //工人工作信息
    if (this.readData.characterInfoArray) {
      this.CharacterInfoArray = this.readData.characterInfoArray
    } else {
      this.CharacterInfoArray = []
    }
    //道路数据
    if (this.readData.highwayIndex)
      this.GameData_highwayIndex = this.readData.highwayIndex

    //建筑物数据
    if (this.readData.buildingsInfo)
      this.GameData_buildings = this.readData.buildingsInfo

    this.LotteryTimes = this.readData.LotteryTimes
    //任务
    if (this.readData.TaskIconCountClick)
      task.TaskIconCountClick = this.readData.TaskIconCountClick
  },
  /**
   * 初始化
   */
  Init: function () {
    let _BFirstLoadGame = false //  this.readData ? this.readData.BFirstLoadGame : 0;
    //date
    this.GameYear = 0
    this.GameMonth = 0
    this.GameDay = 0
    this.GameDate = '0000/00/01'
    /**
     * 新增 CNT 和 SNB
     */
    this.CNT = 0
    this.SNB = 0
    this.Golden = 2000
    this.Diamond = 100
    this.WorkerLV = 0
    this.WorkerNum = 0
    this.CharacterInfoArray = []
    this.WorkerCapacity = 5
    this.TerritoryStateArray = [1, 1, 1, 1, 1, 1, 1, 1] //测试，全开地图
    /**
     * 添加建筑往后添加，到时候ManageBuildings 脚本 会初始化根据顺序
     * BuildingStateArray---相关 GetBuildingStateArray 获取建筑状态
     * BuildingNumArray  ---相关 GetBuildingNumArray 获取建筑数量
     * BuildingFrameArray ---相关 ManageUI  添加面板是否解锁之类的相关预制
     */
    this.BuildingStateArray = [
      1, //公路
      1, //路铲
      1, //拆迁
      1, //农舍
      1, //单元楼
      1, //别墅
      1, //农田
      1, //伐木场
      1, //矿坑
      1, //加工厂
      1, //冷饮摊
      1, //贩卖机
      1, //面包房
      1, //早餐车
      1, //饮茶店
      1, //点心店
      1, //美食店
      1, //西餐厅
      1, //花店
      1, //美发店
      1, //洋装店
      1, //珠宝店
      1, //电影院
      1, //路灯
      1, //绿化带
      1, //花坛
      1, //喷泉
      1, //警察局
      1, //游乐场
      1, //蓝色城堡
      1, //粉色城堡
      1, //Holy Farmland
      1, //Holy Farmland seed
    ]
    this.BuildingLockStateArray = [
      1, //公路
      1, //路铲
      1, //拆迁
      1, //农舍
      0, //单元楼
      0, //别墅
      1, //农田
      0, //伐木场
      0, //矿坑
      1, //加工厂
      0, //冷饮摊
      0, //贩卖机
      0, //面包房
      0, //早餐车
      0, //饮茶店
      0, //点心店
      0, //美食店
      0, //西餐厅
      0, //花店
      0, //美发店
      0, //洋装店
      0, //珠宝店
      0, //电影院
      1, //路灯
      1, //绿化带
      1, //花坛
      0, //喷泉
      0, //警察局
      0, //游乐场
      0, //蓝色城堡
      0, //粉色城堡
      1, //Holy Farmland
      1, //Holy Farmland seed
    ]
    //建筑物数量
    this.BuildingNumArray = [
      0, //公路
      0, //路铲
      0, //拆迁
      4, //农舍
      1, //单元楼
      1, //别墅
      4, //农田
      1, //伐木场
      1, //矿坑
      2, //加工厂
      2, //冷饮摊
      1, //贩卖机
      1, //面包房
      1, //早餐车
      1, //饮茶店
      1, //点心店
      1, //美食店
      1, //西餐厅
      1, //花店
      1, //美发店
      1, //洋装店
      1, //珠宝店
      1, //电影院
      1, //路灯
      1, //绿化带
      1, //花坛
      1, //喷泉
      1, //警察局
      1, //游乐场
      1, //蓝色城堡
      1, //粉色城堡
      1, //Holy Farmland
      1, //Holy Farmland seed
    ]

    this.DiamondNumArray = AConfig.DiamondArray
    //todo 钻石消耗默认值
    this.DiamondNumArray.forEach((value, index, array) => {
      array[index] = 0
    })
    cc.log('钻石消耗默认值', this.DiamondNumArray)
    this.EveryDayRewardsArray = [0, 0, 0, 0, 0, 0, 0]

    this.LastTimeEveryDayRewardsDate = '0000/00/00'
    this.LastTimeLuckDate = '0000/00/00'

    this.FoodTradeState = 1
    this.WoodTradeState = 1
    this.MineralTradeState = 1
    //转盘分享给钻石金币
    this.shareGive = [200, 5]
    //签到分享给钻石金币
    this.signInGive = [200, 5]
    //每个月 给的 低保
    this.EveryGive = [500, 10]
    //公共分享
    this.publicGive = [200, 50]
    //每天抽奖次数
    this.LotteryTimes = 10

    // 1 === _BFirstLoadGame
    if (_BFirstLoadGame) {
      console.log('this.readData', this.readData)
      // cc.log('初始化网络数据');
      //读取日期数据
      this.GameYear = this.readData.GameYear
      this.GameMonth = this.readData.GameMonth
      this.GameDay = this.readData.GameDay

      /**
       * 接口
       * todo cnt和snb 由钱包读取
       */
      this.CNT = 0
      this.SNB = 0

      //读取金币
      this.Golden = this.readData.Golden
      //读取钻石
      this.Diamond = this.readData.Diamond
      // cc.log('this.readData.Diamond', this.readData.Diamond);
      //读取工人等级
      this.WorkerLV = this.readData.WorkerLV
      //工人数量
      this.WorkerNum = this.readData.WorkerNum
      //工人容量
      this.WorkerCapacity = this.readData.WorkerCapacity
      this.GameDate = this.readData.GameDate
      this.LastTimeEveryDayRewardsDate =
        this.readData.LastTimeEveryDayRewardsDate
      this.LastTimeLuckDate = this.readData.LastTimeLuckDate
      this.EveryDayRewardsArray = this.readData.EveryDayRewardsArray //.split('_');
      this.TerritoryStateArray = this.readData.TerritoryStateArray //.split('_');
      //面板状态
      this.BuildingStateArray = this.readData.BuildingStateArray //.split('_');

      //解锁设置为 不用解锁
      this.BuildingLockStateArray.forEach((value, index, array) => {
        array[index] = 1
      })
      // this.BuildingLockStateArray = this.readData.BuildingLockStateArray.split('_');
      this.BuildingNumArray = this.readData.BuildingNumArray //.split('_');
      this.DiamondNumArray = this.readData.DiamondNumArray //.split('_');
      this.FoodTradeState = this.readData.FoodTradeState
      this.WoodTradeState = this.readData.WoodTradeState
      this.MineralTradeState = this.readData.MineralTradeState

      //工人工作信息
      if (this.readData.characterInfoArray)
        this.CharacterInfoArray = this.readData.characterInfoArray
      //道路数据
      if (this.readData.highwayIndex)
        this.GameData_highwayIndex = this.readData.highwayIndex

      //建筑物数据
      if (this.readData.buildingsInfo)
        this.GameData_buildings = this.readData.buildingsInfo

      this.LotteryTimes = this.readData.LotteryTimes
      //任务
      if (this.readData.TaskIconCountClick)
        task.TaskIconCountClick = this.readData.TaskIconCountClick
      //测试5W
      // this.PlusDiamond(50000);

      //如果用户未租赁过土地且未用钻石兑换过种子，则显示
      GlobalD.GameData.getPlayerExchangeState((res, vaule) => {
        //warn 这里需要增加对结果的判断
        this.ManageUI.getComponent('ManageUI').DiamondGapViewShow()
      })
    }
  },

  //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').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)
  },

  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
  },

  //初始化道路
  onSpawnHighway() {
    // 获取InitPoint层
    let InitPos = this._tiledMap.getLayer('InitPoint')
    InitPos.enabled = false

    //创建公路数据
    if (this.readData && this.readData.allHighwayStylesAndIndex) {
      //保存到内存中
      this.GameData_highwayIndex = this.readData.highwayIndex
      //先赋值道路的对象数组
      let _AllHighwayAIndex = Object.assign(
        [],
        this.readData.allHighwayStylesAndIndex
      )
      //获取最后建造公路的层级
      this.HighwayLayer = this._tiledMap.getLayer('Highway')
      for (let i = 0; i < _AllHighwayAIndex.length; i++) {
        let _tiledPos = GlobalD.TiledMap.analyticalIndexData(
          _AllHighwayAIndex[i].highwayInfoIndex
        )
        /**
         * 解决固定土地时候，道路 和房子 冲突
         *
         */
        if (
          GlobalD.game.getManageGameIndexArrayAt(
            cc.v2(_tiledPos.x, _tiledPos.y)
          )
        ) {
          continue
        }
        let highwayTemp = cc.instantiate(this.HighWayPrefabs)
        highwayTemp.parent = this.HighwayLayer.node
        let tiledTile = highwayTemp.addComponent('TiledTile')
        tiledTile.x = _tiledPos.x
        tiledTile.y = _tiledPos.y
        //地图设置可行走区域公路设置
        AStar.setMapSolid(_tiledPos.x, _tiledPos.y, 0)
        // _buildId ==0 是公路
        let _buildId = 0
        let occupyTemp = cc.v2(_buildId, _AllHighwayAIndex[i].highwayInfoIndex)
        GlobalD.game.OccupyArray.push(occupyTemp)
        highwayTemp
          .getComponent('HighwayInfo')
          .onChangeHighwayStyles(_AllHighwayAIndex[i].highwayInfoType)

        GlobalD.game.AllHighwayStylesAndIndex.push(_AllHighwayAIndex[i])
      }
      // console.log("end");
    } else {
      //如果用户没有存储数据
      //根据InitPoint 的数据，创建初始化的地图数据 的初始化数据

      this.HighwayLayer = this._tiledMap.getLayer('Highway')
      for (var i = 0; i < 32; i++) {
        //去除中间两条路
        if (i == 16 || i == 17) continue
        for (var j = 0; j < 32; j++) {
          let tilesPos = cc.v2(i, j)

          if (InitPos.getTileGIDAt(tilesPos)) {
            let index = GlobalD.TiledMap.getIndex(tilesPos)
            this.GameData_highwayIndex.push(index)

            let highwayTemp = cc.instantiate(this.HighWayPrefabs)
            highwayTemp.parent = this.HighwayLayer.node
            let tiledTile = highwayTemp.addComponent('TiledTile')
            tiledTile.x = tilesPos.x
            tiledTile.y = tilesPos.y
            // cc.log('onSpawnHighway2');
            //地图设置可行走区域公路设置
            AStar.setMapSolid(tilesPos.x, tilesPos.y, 0)
            // _buildId ==0 是公路
            let _buildId = 0
            let occupyTemp = cc.v2(_buildId, index)
            GlobalD.game.OccupyArray.push(occupyTemp)

            let tile = InitPos.getTiledTileAt(tilesPos.x, tilesPos.y, true)

            let _MoveType = reGameStates.HighwayType.moveX
            // if (tile.gid == 15) {
            //     _MoveType = reGameStates.HighwayType.moveX;
            // } else
            if (tile.gid == 16) {
              _MoveType = reGameStates.HighwayType.moveY
            } else if (tile.gid == 11) {
              _MoveType = reGameStates.HighwayType.ZebraCrossingX
            } else if (tile.gid == 12) {
              _MoveType = reGameStates.HighwayType.ZebraCrossingY
            }
            // return;
            //更换公路样式
            GlobalD.game.onCreateDifferentRoadStyles({
              _buildId: _buildId,
              _highwayType: _MoveType,
              _roadIndex: index,
              _hightwayNode: highwayTemp,
            })
          }
        }
      }
    }
    //外面的两条路
    let initRoad = this._tiledMap.getLayer('Road')
    initRoad.enabled = false
    for (var i = 16; i < 18; i++) {
      for (var j = 0; j < 32; j++) {
        let tilesPos = cc.v2(i, j)
        // cc.log('road tilesPos',tilesPos)
        if (initRoad.getTileGIDAt(tilesPos)) {
          let index = GlobalD.TiledMap.getIndex(tilesPos)
          this.GameData_highwayIndex.push(index)
          let highwayTemp = cc.instantiate(this.HighWayPrefabs)
          highwayTemp.parent = this.HighwayLayer.node
          let tiledTile = highwayTemp.addComponent('TiledTile')
          tiledTile.x = tilesPos.x
          tiledTile.y = tilesPos.y
          // cc.log('initRoad');
          //地图设置可行走区域公路设置
          AStar.setMapSolid(tilesPos.x, tilesPos.y, 0)
          let _buildId = 0
          let occupyTemp = cc.v2(_buildId, index)
          GlobalD.game.OccupyArray.push(occupyTemp)
          //更换公路样式
          // if (j >= 25 && j <= 27 || j >= 19 && j <= 21 || j >= 9 && j <= 11)
          //     highwayTemp.getComponent('HighwayInfo').onChangeHighwayStyles(reGameStates.HighwayType.none);
          // else
          //     highwayTemp.getComponent('HighwayInfo').onChangeHighwayStyles(reGameStates.HighwayType.moveY);
        }
      }
    }
  },

  //清除所有的数据
  onClearAllData() {
    this.unschedule(this.AutoSaveData)
    //任务索引
    cc.sys.localStorage.removeItem('userdata')
    //跳回登录场景
    // cc.director.loadScene('Login');
  },
  //保存数据请求
  /**
   *
   * 现在转服务器存储，原本所有相关操作通过服务器计算。
   * 一、目前涉及到的是 SNT 和 SNB 两个货币相关，和买田地操作 (可以理解为租聘,三种类型)
   *
   * isNetwork：true，上传到网络
   *
   */
  pushData: function (isNetwork) {
    // cc.log(this.EveryDayRewardsArray);
    // console.log(this.readData.BFirstLoadGame);
    var datas = {
      version: this.GameVersion,
      // 转后台处理
      BFirstLoadGame: 1, //只要push数据，就证明已经开始第一次游戏了

      /**游戏不修改，默认值 start */
      shareGive: this.shareGive,
      //签到分享给钻石金币
      signInGive: this.signInGive,
      //每个月 给的 低保
      EveryGive: this.EveryGive,
      //公共分享
      publicGive: this.publicGive,
      /**游戏不修改，默认值 end */

      //时间
      GameYear: this.GameYear,
      GameMonth: this.GameMonth,
      GameDay: this.GameDay,

      //这里只是单纯的存储起来
      CNT: this.CNT,
      SNB: this.SNB,

      Golden: this.Golden,
      Diamond: this.Diamond,
      WorkerLV: this.WorkerLV,
      WorkerNum: this.WorkerNum,
      WorkerCapacity: this.WorkerCapacity,
      GameDate: this.GameDate,
      LastTimeEveryDayRewardsDate: this.LastTimeEveryDayRewardsDate,
      LastTimeLuckDate: this.LastTimeLuckDate,
      EveryDayRewardsArray: this.EveryDayRewardsArray, //.join('_'),
      TerritoryStateArray: this.TerritoryStateArray, //.join('_'),
      //面板状态
      BuildingStateArray: this.BuildingStateArray, //.join('_'),
      BuildingLockStateArray: this.BuildingLockStateArray, //.join('_'),

      /**
       * SNB和CNT相关，需要后台筛选 田地 和 种子。单独处理
       */
      BuildingNumArray: this.BuildingNumArray, //.join('_'),
      DiamondNumArray: this.DiamondNumArray, //.join('_'),
      FoodTradeState: this.FoodTradeState,
      WoodTradeState: this.WoodTradeState,
      MineralTradeState: this.MineralTradeState,

      LotteryTimes: this.LotteryTimes,

      /**
       * 这些数据不用服务器初始化
       */
      //工人工作信息
      characterInfoArray: this.CharacterInfoArray,
      //道路数据
      highwayIndex: this.GameData_highwayIndex,
      allHighwayStylesAndIndex: GlobalD.game.AllHighwayStylesAndIndex,
      //建筑物数据
      buildingsInfo: this.GameData_buildings,
      //任务
      TaskIconCountClick: task.TaskIconCountClick,
    }

    if (isNetwork) {
      var data = []
      // data["openid"] = userData.openId;
      // data["userdata"] = JSON.stringify(datas);
      data['playerData'] = JSON.stringify(datas)

      /** 推送信息 */
      utils.post(utils.api.playerPushInfo, data, (res, playerPushInfoTemp) => {
        // console.log('playerPushInfoTemp', playerPushInfoTemp);
      })
    } else {
      console.log('存储本地：' + isNetwork)
      //保存用户数据到本地
      cc.sys.localStorage.setItem('userdata', JSON.stringify(datas))
    }
  },

  /**
   * 兑换种子时候，特殊处理数据
   * 扣除相应的钻石
   */
  exchangeSeed(callback) {
    //先暂停存储
    this.unschedule(this.AutoSaveData)

    utils.post(
      utils.api.exchangeSeeds,
      { diamondAmount: 30000, seedId: 8 },
      (res, value) => {
        console.log('兑换种子', value)
        callback(res, value)
        //兑换成功后
        if (0 === value.code) {
          //更新一次数据
          let _playerData = JSON.parse(value.data.playerData)
          //更新本地钻石数据
          this.SetDiamond(_playerData.Diamond)
          callback(res, vaule)
        } else {
          //兑换失败
          GlobalD.GameData.showToast(cc.find('Canvas/UICamera'), '兑换失败', 2)
        }

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

  /**
   * 暂时不需要从这里读取
   */
  getLandConfig() {
    utils.get(utils.api.landConfig, {}, (res, value) => {
      if (0 === value.code) {
        this.ConfigLand = value.data
      } else {
        console.warn('未能读取到config土地？')
      }
    })
  },
  //获取用户全部租赁土地
  getUserLandList() {
    utils.get(utils.api.userLandList, {}, (res, vaule) => {})
  },
  //获取用户已租赁土地的状态
  getLandState(context) {
    let { landId, callback } = context
    utils.get(utils.api.landState, { landId: landId }, (res, vaule) => {
      callback(res, vaule)
    })
  },
  //获取商城种子
  getMallSeed(callback) {
    utils.get(utils.api.mallSeed, {}, (res, vaule) => {
      callback(res, vaule)
    })
  },

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

  //种植种子
  // data:{landId:1,seedId:1}
  onPlant(data, callback) {
    utils.get(utils.api.plant, data, (res, vaule) => {
      callback(res, vaule)
    })
  },

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

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

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

  //神农呗购买种子
  onBuySeedsWithSNB(snbAmount, seedId, callback) {
    utils.post(
      utils.api.snbBuySeeds,
      { payAmount: snbAmount, seedId: seedId },
      (res, vaule) => {
        callback(res, vaule)
      }
    )
  },

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

  /**
   * 支付cnt操作
   * @param {*} amount // 需支付金额
   * @param {*} payType 支付类型，1购买土地租凭， 2自然灾害防护，3野兽防护
   * @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
      )
      GlobalD.GameData.showToast(
        cc.find('Canvas/UICamera'),
        'CNT不足！',
        2,
        () => {
          console.log('finish toast! CNT不足！')
        }
      )
      return
    }
    this.isPlayingCnt = true
    GlobalD.GameData.showToast(
      cc.find('Canvas/UICamera'),
      '支付处理中...',
      5,
      () => {
        console.log('finish toast!支付处理中...')
      }
    )

    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)
        })
        GlobalD.GameData.showToast(
          cc.find('Canvas/UICamera'),
          '支付成功!',
          5,
          () => {
            GlobalD.GameData.showToast(
              cc.find('Canvas/UICamera'),
              '区块确认中，请耐心等待！',
              120
            )
          }
        )
      } else {
        console.log(err)
        GlobalD.GameData.showToast(cc.find('Canvas/UICamera'), err, 2, () => {
          console.log('finish toast!')
        })
      }

      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
      )
      GlobalD.GameData.showToast(
        cc.find('Canvas/UICamera'),
        '神农呗数量不足！',
        2,
        () => {
          console.log('finish toast!')
        }
      )
      return
    }

    GlobalD.GameData.showToast(
      cc.find('Canvas/UICamera'),
      '已发起兑换！',
      5,
      () => {
        console.log('finish toast!')
      }
    )
    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)
        })

        GlobalD.GameData.showToast(
          cc.find('Canvas/UICamera'),
          '区块确认中，请耐心等待！',
          5,
          () => {
            console.log('finish toast!')
          }
        )
      } else {
        console.log(err)
        GlobalD.GameData.showToast(cc.find('Canvas/UICamera'), err, 2, () => {
          console.log('finish toast!')
        })
      }

      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
    }
    GlobalD.GameData.showToast(
      cc.find('Canvas/UICamera'),
      '收益正在提现中',
      10,
      () => {
        console.log('finish toast!')
      }
    )
    GlobalD.dapp.cntWithdraw(amount).then((data) => {
      const [err, tx] = data
      console.log('onCntWithdraw:', data)
      if (err === null) {
        console.log(tx) //String|null 交易唯一哈市
        GlobalD.GameData.showToast(
          cc.find('Canvas/UICamera'),
          '提现成功！',
          1,
          () => {
            console.log('finish toast!')
          }
        )
      } else {
        GlobalD.GameData.showToast(cc.find('Canvas/UICamera'), err, 1, () => {
          console.log('finish toast!')
        })
      }
      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 }, (res, value) => {
      // console.log("snb操作日志", value);
      if (0 === value.code) {
        if (callback) callback(value.data)
      } else {
        let mySnbList = []
        if (callback) callback(mySnbList)
      }
    })
  },

  updateToast() {
    if (this.toastEndTime <= 0) {
      this.toast.active = false
      if (this.isStart) {
        if (this.toastCallback != null && this.toastCallback != undefined) {
          this.toastCallback()
          // console.log(this.toastCallback);
        }
        this.isStart = false
      }
      // console.log("this.toast.active:" + this.toast.active);
    }
    this.toastEndTime--
  },

  showToast(parent, content, time, callback) {
    if (callback) {
      this.toastCallback = callback
    } else {
      this.toastCallback = null
    }

    this.isStart = true
    if (this.toast) {
      // console.log(this.toast.active);
      this.toast.active = true
      this.toast.parent = parent
      this.toast.zIndex = 999
      let DetailLabel = this.toast.getChildByName('DetailLabel')
      DetailLabel.getComponent(cc.Label).string = content
      this.toastEndTime = time
    }
  },

  onTestToken() {
    utils.onTestToken()
  },
})