var Config = require('config');
var Global = require('global');
var Res = require('res');
var Util = require('util');
let cakeUtil = require('cakeUtil');

const newerLines = [
  [{pos: 0, length: 2}, {pos: 2, length: 2}, {pos: 4, length: 2}, {pos: 6, length: 1}],
  [{pos: 0, length: 1}, {pos: 1, length: 1}, {pos: 2, length: 2}, {pos: 4, length: 2}, {pos: 6, length: 1}],
  [{pos: 0, length: 1}, {pos: 3, length: 2}, {pos: 6, length: 1}],
];
cc.Class({
  extends: cc.Component,

  properties: {
    cookiePrefab:
      {
        default: null,
        type: cc.Prefab
      },
    linePrefab:
      {
        type: cc.Prefab,
        default: null
      },
    nodeLine:
      {
        type: cc.Node,
        default: null
      },
    pnlCombo:
      {
        type: require('comboPanel'),
        default: null
      },
    nodeScene:
      {
        type: cc.Node,
        default: null
      },
    nodeLevelup:
      {
        type: cc.Node,
        default: null
      },
    lblLevel:
      {
        type: cc.Label,
        default: null
      },
    nodeShader:
      {
        type: cc.Node,
        default: null
      },
    content:
      {
        type: cc.Node,
        default: null
      },

    length_probability:
      {
        type: Array,
        default: []
      },
    empty_probability:
      {
        type: Array,
        default: []
      },
    newLine: 99,
    sliderHelpNd: cc.Node,
    cakeHouseBtn: cc.Node,
  },

  onLoad() {
    this.empty_probability = [];
    this.length_probability = [];
    this.bomb_probability = 0;
    this.next_grids = [];
    this.container = [];//每行 每块方块的js句柄
    this.next_line_container = [];
    this.combo = 0;//连击数
    this.level = 1;
    this.score = 0;
    this.step_eliminate = false;//本次操作是否有消除
    this.isCanTouch = false;//是否可以操作
    this.useItemIndex = -1;
    this.non_eliminate_times = 0;
    this.eliminate_times = 0;

    // this.nodeCombo.opacity = 0;

    this.gameScene = this.nodeScene.getComponent('gameScene');

    this.nodeLevelup.active = false;
    this.nodeShader.active = false;

    let total = 0;
    for (let i = 0; i < Config.empty_weigh.length; ++i) {
      total += Config.empty_weigh[i];
    }
    let total2 = 0;
    for (let i = 0; i < Config.empty_weigh.length; ++i) {
      total2 += Config.empty_weigh[i];
      this.empty_probability[i] = total2 / total;
    }
    if (CC_DEBUG) {
      this.content.on(cc.Node.EventType.MOUSE_DOWN, this.onMouseDown, this);
    }
    // cc.EffectMgr.showScoreCollectEffect(cc.v2(0,0), cc.v2(0,0), 0);
  },

  onDestroy() {
    this.unschedule(this.set_face_twitchmouth);
    this.unschedule(this.set_face_wait)
  },


  start() {
    this.showLineCube = cc.jc.maincfg.info['line_cube'];
  },

  startGame() {

    Global.isGaming = true;
    this.gameOver = false;
    this.lvlTarget = this.gameScene.lvlTarget;

    this.targetArr = [];
    this.cookieMap = new Map();
    for (let key in this.lvlTarget) {
      if (this.lvlTarget.hasOwnProperty(key)) {
        this.targetArr.push({id: key, val: this.lvlTarget[key]});
        this.cookieMap.set(parseInt(key), this.lvlTarget[key]);
      }
    }
    for (let i = 0; i < Config.cookies.length; i++) {
      let cookie = Config.cookies[i];
      if ((!this.cookieMap.has(cookie.id)) && this.cookieMap.size < 3) {
        let count = Global.getItemCount(this.level);
        this.cookieMap.set(cookie.id, count);
      }
    }
    this.levelRedpack = false;
    let self = this;
    this.step_eliminate = false;
    this.isCanEvent = true;
    this.crazyMode = false;
    this.unschedule(this.set_face_twitchmouth);
    this.schedule(this.set_face_twitchmouth, Config.twitchmouth_time);
    this.unschedule(this.set_face_wait)
    this.scheduleOnce(this.set_face_wait, Config.blank_wait_time);
    this.set_probability(this.level);
    // if (Global.saveData.grids.length > 0) {
    //   this.loadGame();
    // } else {
      if (!Global.getHelpStatus(6) && !this.gameScene.slideHelp) {
        this.newLine = 0;
      }
      this.next_grids = this.generate_grids();
      this.generate_row();
    // }
    this.step(function () {
      if (self) {
        self.combo = 0;
        self.isCanTouch = true;
        self.operationCallback();
      }

    })
  },

  // 得到随机从小到大排列的数字
  get_sorted_random_integers(min, range, amount) {
    amount = range < amount ? range : amount;
    let ret = [];
    while (--amount >= 0) {
      let r = Util.getRandom(range, min);
      let i = 0;
      for (; i < ret.length; ++i) {
        if (r < ret[i]) {
          break;
        } else {
          ++r;
        }
      }
      ret.splice(i, 0, r);
      --range;
    }
    return ret;
  },

  //获取随机砖块
  get_random_wafers(num) {
    let all = [];
    for (let i = 0; i < this.container.length; ++i) {
      let units = this.container[i];
      for (let j = 0; j < units.length; ++j) {
        all.push(units[j]);
      }
    }
    let indexes = this.get_sorted_random_integers(0, all.length, num);
    let wafers = [];
    for (let i = 0; i < indexes.length; ++i) {
      wafers.push(all[indexes[i]]);
    }
    return wafers;
  },

  //撇嘴表情
  set_face_twitchmouth() {
    let wafers = this.get_random_wafers(Config.random_twitchmouth_num);
    for (let i = 0; i < wafers.length; ++i) {
      wafers[i].playAct('twitchmouth');
    }
  },

  //10秒不操作播放等待表情
  set_face_wait() {
    let wafers = this.get_random_wafers(Config.random_face_num);
    for (let i = 0; i < wafers.length; ++i) {
      wafers[i].playAct('asquint');
    }
  },
  // 播放哭泣表情
  set_face_weep() {
    let wafers = this.get_random_wafers(Config.random_face_num);
    for (let i = 0; i < wafers.length; ++i) {
      wafers[i].playAct('weep');
    }
  },

  //设置掉落属性
  set_probability(level) {
    let weigh = Config.length_weigh[level - 1] || Config.length_weigh[Config.length_weigh.length - 1];
    let total = 0;
    for (let i = 0; i < weigh.length; ++i) {
      total += weigh[i];
    }
    let total2 = 0;
    for (let i = 0; i < weigh.length; ++i) {
      total2 += weigh[i];
      this.length_probability[i] = total2 / total;
    }

    this.bomb_probability = Config.bomb_probability[level - 1] || Config.bomb_probability[Config.bomb_probability.length - 1];
    this.flash_probability = Config.flash_probability[level - 1] || Config.flash_probability[Config.flash_probability.length - 1];
    this.cookie_probability = Config.cookie_probability[level - 1] || Config.cookie_probability[Config.cookie_probability.length - 1];
    this.redpack_probability = Global.redpackProbability();
  },

  //生成一行
  generate_grids() {
    if (this.newLine < 3) {
      this.isGuide = true;
      return newerLines[this.newLine++];
    } else {
      this.isGuide = false;
    }

    // 随出新行的最大空格数
    let r = 0;
    r = Util.rand01();
    if (isNaN(r)) {
      r = 0;
      if (CC_DEBUG) console.log(`isNaN netIndex${this.netIndex} netTimeSeed=${Util.netTimeSeed.length}`);
    }
    let empty_num;
    for (let i = 0; i < this.empty_probability.length; ++i) {
      if (r < this.empty_probability[i]) {
        empty_num = i + 1;
        break;
      }
    }

    // 算出方块长度组合
    let lengths = [];
    let total = 0;
    while (total < Config.hCount - empty_num) {
      let r = 0;
      r = Util.rand01();
      if (isNaN(r)) {
        r = 0;
        if (CC_DEBUG) console.log(`isNaN netIndex${this.netIndex}`);

      }
      for (let i = 0; i < this.length_probability.length; ++i) {
        if (r < this.length_probability[i]) {
          let length = i + 1;
          if (length >= Config.hCount - total) {
            length = Config.hCount - total - 1;
          }
          total += length;
          lengths.push(length);
          break;
        }
      }
    }
    // 插入空格
    empty_num = Config.hCount - total;
    while (--empty_num >= 0) {
      let r = 0;
      r = Util.getRandom(lengths.length + 1);
      if (isNaN(r)) {
        r = 0;
        if (CC_DEBUG) console.log(`isNaN netIndex${this.netIndex}  netTimeSeed=${Util.netTimeSeed.length}`);
      }
      lengths.splice(r, 0, 0);
    }
    // 算出方块的位置和长度信息
    let grids = [];
    let pos = 0;
    for (let i = 0; i < lengths.length; ++i) {
      if (!lengths[i]) {
        ++pos;
      } else {
        grids.push({pos: pos, length: lengths[i]});
        pos += lengths[i];
      }
    }
    return grids;
  },

  //生成一个威化饼
  newBrick({gridNum, typeNum, column, eventData, hasRedPack, hasCube}) {
    eventData = eventData || {};
    let brick = cc.instantiate(this.cookiePrefab);
    this.content.addChild(brick);
    let code = brick.getComponent('gameCookie');
    if (!this.hummerBrick) {
      code.hasHelpTag = true;
      this.hummerBrick = brick;
    }
    if (this.newLine === 1) {
      code.hasHelpTag = true;
      if (this.hummerBrick && !this.breadBrick && this.hummerBrick !== brick) {
        this.breadBrick = brick;
      }
    }
    code.initUI();
    code.initData({gridNum, typeNum, column, eventData, hasRedPack, hasCube});
    return brick;
  },

  //生成当前行+下一行
  generate_row() {
    let units = [];
    let lineHasCookie = false;
    for (let i = 0; i < this.next_grids.length; ++i) {
      let showCube = false;
      let grid = this.next_grids[i];
      let typeNum = 0;
      let hasRedpack = false;

      if (this.isGuide || !Global.getHelpStatus(6)) { // 如果当前是新手引导状态, 则根据预先设置好的样式显示材料方块
        if (grid.typeNum) {
          typeNum = grid.typeNum;
        } else {
          typeNum = 0;
        }
      }
      else if (Util.rand01() < this.bomb_probability) {
        typeNum = 1;
      }
      // else if (Util.rand01() < this.cookie_probability && !lineHasCookie) {
      //   lineHasCookie = true;
      //   let cookieArr = [];
      //   for (let key of this.cookieMap.keys()) {
      //     if (this.cookieMap.get(key) > 0) {
      //       cookieArr.push(key);
      //     }
      //   }
      //   if (cookieArr.length > 0 ) {
      //     let randomNum = Util.getRandom(cookieArr.length, 0);
      //     let key = cookieArr[randomNum];
      //     this.cookieMap.set(key, this.cookieMap.get(key) - 1);
      //     typeNum = key;
      //   } else {
      //     typeNum = 0;
      //   }
      // }

      if (Util.rand01() < this.redpack_probability && !this.levelRedpack && Config.redpack_open) {
        hasRedpack = true;
        this.levelRedpack = true;
      }

      let randomVal = Util.getRandom(10);
      if (Global.levelData.lines >= Config.cube_line && typeNum === 0 && randomVal >= 5 && this.showLineCube) {
        Global.levelData.lines = 0;
        showCube = true;
      }
      let brick = this.newBrick({gridNum: grid.length,
        typeNum: typeNum,
        column: grid.pos,
        hasRedPack: hasRedpack,
        hasCube: showCube});
      units.push(brick.getComponent('gameCookie'));
    }
    this.container.push(units);
    this.next_grids = this.generate_grids();
    this.generate_nextline();
  },

  //生成预览
  new_line(length, pos, typeNum) {
    let line = cc.instantiate(this.linePrefab);
    line.x = pos * Config.singleSize;
    line.width = length * Config.singleSize;
    line.typeNum = typeNum;
    this.nodeLine.addChild(line);
    return line;
  },

  //预览下一行
  generate_nextline() {
    for (let i = 0; i < this.next_line_container.length; ++i) {
      this.next_line_container[i].destroy();
    }
    this.next_line_container.length = 0;
    for (let i = 0; i < this.next_grids.length; ++i) {
      let grid = this.next_grids[i];
      let line = this.new_line(grid.length, grid.pos, grid.typeNum);
      this.next_line_container.push(line);
    }
  },

  // 一步操作完成(检查下落/播放下落动画/计算分数/生成新行/整体提升/检查下落)
  step(cb, initial_row_index) {
    let self = this;
    if (!cb) {
      cb = function () {
        self.combo = 0;
        self.isCanTouch = true;
      }
    }
    this.check_descend(function () {
      if (Global.isGaming === false) {
        return;
      }
      self.generate_row();
      self.rise_upper_units(function () {
        if (Global.isGaming === false) {
          return;
        }
        self.check_emotion();
        self.settle(cb);
      });
    }, initial_row_index);
  },

  check_emotion() {
    if (this.container.length >= Config.idle_row_limit) {
      if (this.isMyPanel) {
        cc.SoundMgr.playSound(cc.SoundMgr['nervous']);
      }
      this.set_face_weep();
    }

    this.gameScene.switchShakeItem(this.container.length >= Config.vCount - 1);
  },

  get_min_row() {
    return Config.min_rows[this.level - 1] || Config.min_rows[Config.min_rows.length - 1];
  },

  // 检测是否有方块下降以及保证最小行数
  settle(cb) {
    let self = this;

    if (!cb) {
      cb = function () {
        self.combo = 0;
        self.isCanTouch = true;
      }
    }

    this.check_descend(function () {
      if (Global.isGaming === false) {
        return;
      }
      if (self.container.length < self.get_min_row()) {
        self.next_grids = self.generate_grids();
        self.generate_row();
        self.rise_upper_units(function () {
          if (Global.isGaming === false) {
            return;
          }
          self.settle(cb);
        });

      } else {
        self.check_emotion();
        cb();
      }
    });
  },

  //整体方块上移
  rise_upper_units(cb) {
    let bricks = [];
    for (let i = this.container.length - 2; i >= 0; --i) {
      let units = this.container[i];
      for (let j = 0; j < units.length; ++j) {
        bricks.push(units[j]);
      }
    }
    let length = bricks.length;
    if (length === 0) {
      this.remove_empty_row(this.container.length - 1);
      if (cb) {
        cb();
      }
      return;
    }
    for (let i = 0; i < length; i++) {
      bricks[i].upper();
    }
    this.scheduleOnce(cb, Config.rise_time);
  },

  descend_pos(unit, bottom_row) {
    let unit_right = unit.column + unit.gridNum;
    let pos = 0;
    while (pos < bottom_row.length) {
      let bottom_unit = bottom_row[pos];
      let bottom_right = bottom_unit.column + bottom_unit.gridNum;
      if (unit_right <= bottom_unit.column) {
        return pos;
      } else if (unit.column >= bottom_right) {
        ++pos;
      } else {
        return -1;
      }
    }
    return pos;
  },

  //获取下落参数
  get_descend_length_pos(unit, row_index) {
    let length = 0;
    let pos;
    for (let i = row_index; i < this.container.length; ++i) {
      let p = this.descend_pos(unit, this.container[i]);
      if (p >= 0) {
        pos = p;
        ++length;
      } else {
        break;
      }
    }
    return {length: length, pos: pos};
  },

  //删除空行
  remove_empty_row(initial_row_index) {
    for (let i = initial_row_index; i >= 0; --i) {
      if (!this.container[i].length) {
        this.container.splice(i, 1);
      }
    }
  },

  //下落动作
  //TODO: 这里可能有问题
  descend_units(units, cb) {
    for (let i = 0; i < units.length; i++) {
      units[i].descend();
    }
    this.scheduleOnce(cb, Config.descend_time);
  },

  //检查下落
  check_descend(cb, initial_row_index) {
    let self = this;

    initial_row_index = initial_row_index || this.container.length - 2;
    if (initial_row_index > this.container.length - 2) {
      initial_row_index = this.container.length - 2;
    }
    /*
    if(initial_row_index&&initial_row_index < this.container.length - 2){
        initial_row_index = initial_row_index;
    }else{
        initial_row_index = this.container.length - 2;
    }*/

    let objs = [];
    for (let i = initial_row_index; i >= 0; --i) {
      let top_row = this.container[i];
      let bottom_row = this.container[i + 1];
      let top_pos = 0;
      let bottom_pos = 0;
      while (top_pos < top_row.length && bottom_pos < bottom_row.length) {
        let top_unit = top_row[top_pos];
        let bottom_unit = bottom_row[bottom_pos];
        let top_right = top_unit.column + top_unit.gridNum;
        let bottom_right = bottom_unit.column + bottom_unit.gridNum;
        if (top_right <= bottom_unit.column) {
          let t = this.get_descend_length_pos(top_unit, i + 2);
          if (t.length > 0) {
            this.container[i + t.length + 1].splice(t.pos, 0, top_unit);
          } else {
            bottom_row.splice(bottom_pos, 0, top_unit);
            ++bottom_pos;
          }
          objs.push(top_unit);
          top_row.splice(top_pos, 1);
        } else if (top_right < bottom_right) {
          ++top_pos;
        } else if (top_unit.column < bottom_right) {
          ++top_pos;
          ++bottom_pos;
        } else {
          ++bottom_pos;
        }
      }
      let remaining_units = top_row.splice(top_pos, top_row.length - top_pos);
      for (let j = 0; j < remaining_units.length; ++j) {
        let top_unit = remaining_units[j];
        let t = this.get_descend_length_pos(top_unit, i + 2);
        if (t.length > 0) {
          this.container[i + t.length + 1].splice(t.pos, 0, top_unit);
        } else {
          bottom_row.splice(bottom_pos, 0, top_unit);
          ++bottom_pos;
        }
        objs.push(top_unit);
      }
    }
    this.remove_empty_row(initial_row_index);
    if (!objs.length) {
      if (cb) {
        cb();
      }
      return;
    }
    this.descend_units(objs, function () {
      self.check_score(cb);
    });
  },

  get_score_rate(combo) {
    // if (combo > 30) {
    //   return 1 << 30;
    // }
    // return 1 << combo - 1;
    return combo;
  },
  /**
   * @param {object} row_dict 从上到下第几行上有爆炸方块
   * @param {number} row_index 爆炸方块在第几行(从上到下)
   * @param {object} exploded 爆炸方块
   * @param {[object]} exploded_objs 待爆炸的方块数组
   * @param {} is_exploded
   * @param {object} exploded_stack
   * */
  count_row_exploded(row_dict, row_index, exploded, exploded_objs, is_exploded, exploded_stack) {
    let square_num = 0;
    let units = this.container[row_index];
    let exploded_right = exploded.column + exploded.gridNum;
    for (let i = units.length - 1; i >= 0; --i) {
      let unit = units[i];
      if (exploded_right > unit.column) {
        if (unit.column + unit.gridNum > exploded.column) {
          if (!is_exploded[row_index][unit.column]) {
            is_exploded[row_index][unit.column] = true;
            if (unit.typeNum === 1) {
              exploded_stack.push([row_index, unit]);
            }
            exploded_objs.push(unit);
            if (!row_dict[row_index]) {
              square_num += unit.gridNum;
              units.splice(i, 1);
            }
          }
        } else {
          break;
        }
      }
    }
    return square_num;
  },

  //获取爆炸分数, 并将爆炸方块旁边的方块放入 exploded_objs
  count_exploded(rows, exploded_objs, is_exploded, extra_unit, extra_unit_row) {
    let self = this;
    let square_num = 0;
    let row_dict = {};
    for (let i = 0; i < rows.length; ++i) {
      row_dict[rows[i]] = true;
    }
    let exploded_stack = [];
    let score_rate = this.get_score_rate(this.combo + rows.length);
    if (extra_unit) {
      is_exploded[extra_unit_row][extra_unit.column] = true;
      exploded_stack.push([extra_unit_row, extra_unit]);
      exploded_objs.push(extra_unit);
    } else {
      for (let k = 0; k < rows.length; k++) {
        let units = this.container[rows[k]];
        for (let i = units.length - 1; i >= 0; --i) {
          if (units[i].typeNum === 1) {
            let unit = units[i];
            is_exploded[k][unit.column] = true;
            exploded_stack.push([rows[k], unit]);
            exploded_objs.push(unit);
          }
        }
      }
    }
    while (exploded_stack.length > 0) {
      let e = exploded_stack.pop();
      let row_index = e[0];
      let exploded = e[1];
      if (row_index > 0) {
        square_num += this.count_row_exploded(row_dict, row_index - 1, exploded, exploded_objs, is_exploded, exploded_stack);
      }

      if (row_index < this.container.length - 1) {
        square_num += this.count_row_exploded(row_dict, row_index + 1, exploded, exploded_objs, is_exploded, exploded_stack);
      }

      let units = this.container[row_index];
      let exploded_right = exploded.column + exploded.gridNum;
      for (let i = units.length - 1; i >= 0; --i) {
        let unit = units[i];
        if (exploded_right === unit.column) {
          if (!is_exploded[row_index][unit.column]) {
            is_exploded[row_index][unit.column] = true;
            if (unit.typeNum === 1) {
              exploded_stack.push([row_index, unit]);
            }
            exploded_objs.push(unit);
            if (!row_dict[row_index]) {
              square_num += unit.gridNum;
              units.splice(i, 1);
            }
          }
        } else if (exploded_right > unit.column) {
          if (unit.column + unit.gridNum === exploded.column) {
            if (!is_exploded[row_index][unit.column]) {
              is_exploded[row_index][unit.column] = true;
              if (unit.typeNum === 1) {
                exploded_stack.push([row_index, unit]);
              }
              exploded_objs.push(unit);
              if (!row_dict[row_index]) {
                square_num += unit.gridNum;
                units.splice(i, 1);
              }
            }
          } else if (unit.column + unit.gridNum < exploded.column) {
            break;
          }
        }
      }
    }
    return square_num * this.level * score_rate;
  },

  //连击提示
  combo_box(combo) {
    // 测试
    // let cnt = combo;
    // let sec = 1;
    // for(let i = 0; i < 3; i++){
    //   this.scheduleOnce(()=>{
    //     this.pnlCombo.combo(cnt);
    //     cnt++;
    //   }, sec);
    //   sec++;
    // }
    this.pnlCombo.combo(combo);
    // if (combo > 1) {
    //   cc.EffectMgr.showFireworkEffect(this.pnlCombo.node);
    // }
  },

  //加分
  score_process(objs, score, cb) {
    if (this.isMyPanel) {
      cc.SoundMgr.playSound(cc.SoundMgr['score']);
    }
    let hasRedpack = false;
    let hasCube = false;
    for (let i = 0; i < objs.length; i++) {
      objs[i].addScore(score);
      if (objs[i].hasRedPack) {
        hasRedpack = true;
      }
      if (objs[i].hasCube) {
        hasCube = true;
      }
    }
    if (hasRedpack) {
      this.gameScene.showRedpackPanel();
    }
    if (hasCube) {
      this.gameScene.showCubeReward();
    }
    if (cb) {
      this.scheduleOnce(cb, Config.remove_time);
    }
  },

  //消除动画
  ani_eliminate(objs, rows, score, cb) {
    if (this.isMyPanel) {
      cc.SoundMgr.playSound(cc.SoundMgr['eliminate']);
    }
    let start_tween = () => {
      if (Global.isGaming === false) return;
      this.score_process(objs, score, cb);
    }
    let waiting = rows.length;
    if (!waiting) {
      start_tween();
      return;
    }
    let scale = Config.eliminate_scale;
    let combo = this.combo - rows.length;
    for (let i = 0; i < rows.length; ++i) {
      let ani_name = '';
      if (++combo > 1) {
        ani_name = 'comboeliminate';
      } else {
        ani_name = 'normaleliminate';
      }
      let node = new cc.Node();
      node.anchorX = 0;
      node.anchorY = 0;
      node.width = this.node.width;
      node.height = Config.singleSize;
      this.content.addChild(node);
      let spr = node.addComponent(cc.Sprite);
      let ani = node.addComponent(cc.Animation);
      let clip = cc.AnimationClip.createWithSpriteFrames(Res.extra[ani_name], Config.ani_default_fps);
      ani.addClip(clip, ani_name);
      ani.play(ani_name);
      node.scaleY = scale;
      node.scaleX = 1.2;
      node.x = 0;
      node.y = (this.container.length - 1 - rows[i]) * Config.singleSize;
      cc.EffectMgr.showLineEffect(node);
      ani.on('stop', function () {
        node.destroy();
        if (--waiting === 0) {
          start_tween();
        }
      });
    }
  },

  //消除动画
  exploded_ani_eliminate(objs, cb) {
    let splst = [];
    let exploded_length = objs.length;
    for (let i = 0; i < exploded_length; ++i) {
      let obj = objs[i];
      let aniName = '';
      if (obj.typeNum === 1) {
        splst.push(obj);
        continue;
        //aniName = "specialBubble";
      } else {
        aniName = 'bubble';
      }
      obj.playBubble(aniName);
    }

    splst.forEach(element => {
      element.playBubble('specialBubble');
    });

    this.scheduleOnce(cb, 1.25 + 0.24);
  },

  /**
   * 非爆炸方块消除
   * @param {[Object]} normal_objs 待消除方块数组
   * @param {} rows ?
   * @param {number} score 消除后的得分
   * @param {} cb
   * */
  normal_eliminate(normal_objs, rows, score, cb) {
    let self = this;
    //this.gameScene.checkShowCakeLight();
    let normal_length = normal_objs.length;
    if (!normal_length) {
      if (cb) {
        cb();
      }
      return;
    }
    let bricks = {1: 0, 2: 0, 3: 0, 4: 0};

    for (let i = 0; i < normal_length; ++i) {
      normal_objs[i].playAct('blank');
      if (normal_objs[i].typeNum === 0) {
        bricks[normal_objs[i].colorType] += 1;
      } else {
        if (normal_objs[i].typeNum >= 100) {
          if (bricks[normal_objs[i].typeNum]) {
            bricks[normal_objs[i].typeNum] += 1;
          } else {
            bricks[normal_objs[i].typeNum] = 1;
          }
          let itemId = normal_objs[i].typeNum;
          if (this.gameScene.topLevelComp.lvlTarget[itemId]) {
            cc.EffectMgr.showCookieCollectEffect(normal_objs[i].node,
              this.gameScene.topLevelNode.getChildByName('targetContainer'), itemId);
          }
        }
      }
    }
    Global.updateLevelData(bricks, rows.length);
    this.scheduleOnce(function () {
      self.ani_eliminate(normal_objs, rows, score, cb);
    }, Config.weep_time)
  },

  // 爆炸方块消除
  exploded_eliminate(exploded_objs, cb) {
    let self = this;

    let exploded_length = exploded_objs.length;
    if (!exploded_length) {
      if (cb) {
        cb();
      }
      return;
    }
    let bricks = {1: 0, 2: 0, 3: 0, 4: 0};
    for (let i = 0; i < exploded_length; ++i) {
      exploded_objs[i].chocolate = true;
      exploded_objs[i].playAct('blank');
      if (exploded_objs[i].typeNum === 0) {
        bricks[exploded_objs[i].colorType] += 1;
      } else {
        if (exploded_objs[i].typeNum >= 100) {
          if (bricks[exploded_objs[i].typeNum]) {
            bricks[exploded_objs[i].typeNum] += 1;
          } else {
            bricks[exploded_objs[i].typeNum] = 1;
          }
          let itemId = exploded_objs[i].typeNum;
          if (this.gameScene.topLevelComp.lvlTarget[itemId]) {
            cc.EffectMgr.showCookieCollectEffect(exploded_objs[i].node,
              this.gameScene.topLevelNode.getChildByName('targetContainer'), itemId);
          }
        }
      }
    }
    Global.updateLevelData(bricks);
    this.gameScene.updateLevelInfo();
    this.scheduleOnce(function () {
      self.exploded_ani_eliminate(exploded_objs, cb);
    }, Config.weep_time)
  },

  // 得分以及移除得分方块
  removeUnit(rows, has_bomb, checkCombo, cb) {
    if (checkCombo) {
      this.combo = this.gameScene.updateComboProgress(rows.length);
    } else {
      this.combo = 1;
    }
    if (this.crazyMode) {
      this.gameScene.shakeSelf();
      cc.jc.gameVibrateLong();
    } else {
      cc.jc.gameVibrate();
    }
    Global.updateCombo(this.combo);
    this.gameScene.updateSkillProgress(Config.one_line_score * this.combo);

    let normal_objs = [];
    let exploded_objs = [];
    let is_exploded = [];
    for (let i = 0; i < this.container.length; ++i) {
      is_exploded.push({});
    }
    let score = 0;
    let exploded_score = 0;
    let remaining_count = 1;
    if (has_bomb) {
      ++remaining_count;
      exploded_score += this.count_exploded(rows, exploded_objs, is_exploded);
    }
    for (let i = 0; i < rows.length; ++i) {
      let units = this.container[rows[i]];
      if (units.length === 0) {
        continue;
      }
      let rate = 1;
      if (checkCombo) {
        rate = this.get_score_rate(this.combo);
      }
      let sameColor = true;
      let preColor = units[0].colorType;
      for (let j = 0; j < units.length; ++j) {
        if (preColor !== units[j].colorType) {
          sameColor = false;
          break;
        }
      }
      if (sameColor) {
        rate *= Config.same_color_rate;
      }
      rate = rate * (this.baseRate || 1)
      let pos = units[Util.getRandom(units.length, 0)].node.position;
      let sourcePos = units[0].node.parent.convertToWorldSpaceAR(pos);
      let rowScore = 0;
      for (let j = 0; j < units.length; ++j) {
        let unit = units[j];
        if (!is_exploded[rows[i]][unit.column]) {
          normal_objs.push(unit);
          unit.score = unit.gridNum * rate;
          score += unit.score;
        } else {
          unit.score = unit.gridNum * rate;
          exploded_score += unit.score;
        }
        rowScore += unit.score;
      }
      units.length = 0;
      // let targetNode = this.gameScene.topLevelNode.getChildByName('targetContainer');
      // let targetPos = targetNode.parent.convertToWorldSpaceAR(targetNode.position);
      // cc.EffectMgr.showScoreCollectEffect(sourcePos, targetPos, rowScore);
    }
    let check_finish = function () {
      if (--remaining_count === 0) {
        if (cb) {
          cb();
        }
      }
    }
    if (checkCombo) {
      this.combo_box(this.combo);
      if (this.combo >= Config.happy_combo) {
        if (this.isMyPanel) {
          cc.SoundMgr.playSound(cc.SoundMgr['happy']);
        }
        this.gameScene.playExtra('combo');
      }
      if (this.combo >= 2 && this.isMyPanel) {
        cc.SoundMgr.playSound(cc.SoundMgr['combo']);
      }
    }

    this.step_eliminate = true;
    this.normal_eliminate(normal_objs, rows, score, check_finish);
    if (has_bomb) {
      this.exploded_eliminate(exploded_objs, () => {
        this.score_process(exploded_objs, exploded_score, () => {
          check_finish();
        });
      });
    }
    ;
  },

  check_score(cb) {
    let self = this;

    let rows = [];
    let has_bomb;
    for (let i = this.container.length - 1; i >= 0; --i) {
      let units = this.container[i];
      if (units.length > 0 && units[0].column === 0) {
        let length = units[0].gridNum;
        has_bomb = units[0].typeNum === 1;
        for (let j = 1; j < units.length; ++j) {
          if (length !== units[j].column) {
            break;
          }
          length += units[j].gridNum;
          has_bomb = has_bomb || units[j].typeNum === 1;
        }
        if (length === Config.hCount) {
          rows.push(i);
          if (has_bomb) {
            break;
          }
        }
      }
    }
    if (!rows.length) {
      if (cb) {
        cb();
      }
      return;
    }
    this.removeUnit(rows, has_bomb, true, function () {
      self.check_descend(cb);
    });
  },

  addScore(score) {
    this.score += score;
    // if (Config.levels[this.level - 1] != undefined && this.score >= Config.levels[this.level - 1]) {
    //   this.level++;
    //   this.set_probability(this.level);
    // }
  },
  // 点击道具使用弹窗的使用按钮后执行的方法
  onTouchUseItem() {
    this.useItemIndex = this.gameScene.selectItemIndex;
    cc.jc.gamelog.logButtonClick('useitembtn', {}, this.useItemIndex);
  },

  //吃砖块效果
  game_over_process(cb) {
    if (this.isMyPanel) {
      cc.SoundMgr.playSound(cc.SoundMgr['eat']);
    }
    let self = this;

    let row_length = this.container.length;
    let middle = Config.hCount / 2;
    for (let i = 0; i < row_length; i++) {
      let units = this.container[i];
      for (let j = 0; j < units.length; j++) {
        let unit = units[j];
        let x = unit.node.x;
        let y = this.node.height + Config.singleSize;
        let delay = (i + 1) * (Config.game_over_time / (row_length * 2));
        if (unit.column + 1 === middle) {
          //nothing
        } else if (unit.column + 1 < middle) {
          x += Config.singleSize;
        } else if (unit.column + 1 > middle) {
          x -= Config.singleSize;
        }
        unit.node.runAction(cc.sequence(cc.delayTime(delay), cc.moveTo(delay, cc.v2(x, y))));
      }
    }
    this.scheduleOnce(function () {
      if (cb) {
        cb();
      }
    }, Config.game_over_time);
  },

  getRandomRow() {
    // 随出新行的最大空格数
    let r = Util.rand01();
    let empty_num;
    for (let i = 0; i < this.empty_probability.length; ++i) {
      if (r < this.empty_probability[i]) {
        empty_num = i + 1;
        break;
      }
    }

    // 算出方块长度组合
    let lengths = [];
    let total = 0;
    while (total < Config.hCount - empty_num) {
      let r = Util.rand01();
      for (let i = 0; i < this.length_probability.length; ++i) {
        if (r < this.length_probability[i]) {
          let length = i + 1;
          if (length >= Config.hCount - total) {
            length = Config.hCount - total - 1;
          }
          total += length;
          lengths.push(length);
          break;
        }
      }
    }

    // 插入空格
    empty_num = Config.hCount - total;
    while (--empty_num >= 0) {
      let r = Util.getRandom(lengths.length + 1);
      lengths.splice(r, 0, 0);
    }

    // 算出方块的位置和长度信息
    let grids = [];
    let pos = 0;
    for (let i = 0; i < lengths.length; ++i) {
      let length = lengths[i];
      if (length === 0) {
        ++pos;
      } else {
        grids.push({pos: pos, length: lengths[i]});
        pos += length;
      }
    }

    for (let i = 0; i < grids.length; i++) {
      let bomb = false;
      if (Util.rand01() < this.bomb_probability) {
        bomb = true;
      }
      let colorType = Util.getRandom(Config.color_num + 1, 1);
      grids[i].typeNum = bomb ? 1 : 0;
      grids[i].color = colorType;
    }
    return grids;
  },

  loadGame() {
    let grids = Global.saveData.grids;
    Global.levelData.cookie = Global.saveData.cookie;
    this.gameScene.topLevelComp.showAllItems();
    for (let i = 0; i < grids.length; ++i) {
      let units = [];
      for (let j = 0; j < grids[i].length; j++) {
        let data = grids[i][j];
        let brick = this.newBrick({gridNum: data.length, typeNum: data.typeNum, column: data.pos, eventData: data});
        units.push(brick.getComponent('gameCookie'));
      }
      this.container.push(units);
    }
  },
  //一步操作之后的回调
  operationCallback() {
    let self = this;
    this.combo = 0;
    //更新表情
    if (this.step_eliminate) {//有消除
      this.step_eliminate = false;
      this.non_eliminate_times = 0;
      if (++this.eliminate_times >= Config.tsundere_step_times) {
        let wafers = this.get_random_wafers(Config.random_face_num);
        for (let i = 0; i < wafers.length; ++i) {
          wafers[i].playAct('tsundere');
        }
      }
    } else {
      this.eliminate_times = 0;
      if (++this.non_eliminate_times >= Config.asquint_step_times) {//连续无消除
        let wafers = this.get_random_wafers(Config.random_face_num);
        for (let i = 0; i < wafers.length; ++i) {
          wafers[i].playAct('weep');
        }
      }
    }
    if (this.container.length >= Config.vCount && this.isMyPanel) {//游戏结束
      this.game_over_process(e => {
        self.gameScene.gameOver();
      });
    } else {
      this.isCanTouch = true;
      Global.saveData.grids.length = 0;
      for (let i = 0; i < this.container.length; i++) {
        let rows = [];
        for (let j = 0; j < this.container[i].length; j++) {
          let unit = this.container[i][j]
          rows.push({
            length: unit.gridNum,
            pos: unit.column,
            color: unit.colorType,
            typeNum: unit.typeNum,
            y: unit.row
          });
        }
        Global.saveData.grids.push(rows);
      }
      Global.save();
      this.checkHelp();
      //this.gameScene.updateSkillProgress(Config.one_line_score * this.combo);
    }
  },
  //升级处理
  checkLevelUp() {
    if (!this.crazyMode) {
      if (this.gameScene.checkLevelUp()) {
        if (!this.gameOver) {
          this.gameOver = true;
          this.stageOver();
        }
      }
    }
  },

  stageOver() {
    for (let i = 0; i < this.container.length; i++) {
      for (let j = 0; j < this.container[i].length; j++) {
        this.container[i][j].destroy();
      }
      this.container[i].length = 0;
    }
    Global.saveData.grids.length = 0;
    this.gameScene.stageOver();
  },
  update(dt) {
  },
  /**
  * 消除场景上所有的方块
  * @param {boolean} ignoreSpecial 消除的时候是否无视巧克力方块, 该值为true的话,会将巧克力方块当作普通方块消除
  * @param {function} cb 消除后的回调
  * */
  eliminateAll(ignoreSpecial, cb) {
    let self = this;
    let rows = [];
    let has_bomb = false;
    for (let i = this.container.length - 1; i >= 0; --i) {
      if (ignoreSpecial) {
        for (let obj of this.container[i]) {
          obj.typeNum = obj.typeNum === 1 ? 0 : obj.typeNum;
        }
      }
      rows.push(i);
    }
    if (!rows.length) {
      cb && cb();
      return;
    }
    this.removeUnit(rows, has_bomb, false, function () {
      self.check_descend(function () {
        self.generate_row();
        self.rise_upper_units(function () {
          if (Global.isGaming === false) {
            return;
          }
          self.check_emotion();
          self.checkLevelUp();
          self.settle(cb);
        });
      });
    });
  },
  showGuide(type, obj) {
    if (!Global.getHelpStatus(type)) {
      // this.gameScene.showGuide(type, obj);
    }
  },
  // 检查是否要显示游戏内引导效果
  checkHelp() {
    //if (!Global.getHelpStatus(6) && this.gameScene.slideHelp) {
    //  this.gameScene.showCakeMakeTip();
    //}
    if (this.container.length >= Config.idle_row_limit) {
      cc.EffectMgr.showAlertPanel();
      if (!Global.getHelpStatus(13)) {
        let brickNd;
        for (let i = 0; i < this.container.length; i++) {
          for (let j = 0; j < this.container[i].length; j++) {
            if (this.container[i][j].gridNum > 1) {
              (brickNd) || (brickNd = this.container[i][j]);
            }
          }
        }
        // 大方块数量大于等于8的时候，显示锤子的闪光和手指效果
        if (brickNd) {
          this.gameScene.toggleNoAct(true);
          let nd = this.gameScene.btnItemArr[1].node.getChildByName('spr_icon');
          this.gameScene.showTipLight(nd);
          this.scheduleOnce(function () {
            this.gameScene.showItemHelp(nd, brickNd, 1);
          }, 1);
          this.scheduleOnce(function () {
            this.gameScene.removeTipLight();
          }, 5);
        }
      } else if (!Global.getHelpStatus(14) && Global.getHelpStatus(13)) {
        this.gameScene.toggleNoAct(true);
        let nd = this.gameScene.btnItemArr[0].node.getChildByName('spr_icon');
        this.gameScene.showTipLight(nd);
        let brickNd;
        for (let i = 0; i < this.container.length; i++) {
          for (let j = 0; j < this.container[i].length; j++) {
            if (this.container[i][j].typeNum === 0) {
              brickNd = this.container[i][j];
              break;
            }
          }
          if (brickNd) {
            break;
          }
        }
        this.scheduleOnce(function () {
          this.gameScene.showItemHelp(nd, brickNd, 0);
        }, 1);
        this.scheduleOnce(function () {
          this.gameScene.removeTipLight();
        }, 5);
      } else {

      }
    } else {
      cc.EffectMgr.hideAlertPanel();
    }

  },
  // // 显示砖块上手指点击效果
  // showFingerOnBrick() {
  //   let nd ;
  //   if (!Global.getHelpAllStatus(5)) {
  //     nd = this.container[0][0];
  //   } else if(Global.getHelpAllStatus(5) && (!Global.getHelpAllStatus(6))){
  //     for (let i = 0; i < this.container.length; i++) {
  //       for (let j = 0; j < this.container[i].length; j++) {
  //         if (this.container[i][j].gridNum > 1) {
  //           nd = this.container[i][j];
  //           break;
  //         }
  //       }
  //       if (nd) {
  //         break;
  //       }
  //     }
  //   }
  //   if (nd) {
  //     cc.EffectMgr.showFingerClick(nd.node);
  //   }
  // },
  showCakeHelp() {
    if (!Global.getHelpStatus(6) && !this.gameScene.slideHelp) {
      cc.UIManage.hideGuide();
      this.gameScene.showNextLineHelp();
      //cc.UIManage.hideGuide(5);
      //cc.UIManage.showGuide({type: 6, target: this.cakeHouseBtn, autoShow: false});
    }
  },
  // 晃动一个方块
  shockOneBrick() {
    if (Global.isGaming) {
      this.shockNd = this.container[0][0];
      (this.shockNd && this.shockNd.parent) && (this.shockNd.getComponent(cc.Animation).play('cubeShock'));
    }
  },
  // 移除方块晃动效果
  removeBrickShock() {
    if (this.shockNd && this.shockNd.parent && Global.isGaming) {
      this.shockNd.getComponent(cc.Animation).stop('cubeShock')
      this.shockNd.node.rotation = 0;
    }
  },
  // 用于测试时右键添加方块
  onMouseDown(event) {
    let mouseType = event.getButton();
    if (mouseType === cc.Event.EventMouse.BUTTON_RIGHT){
      let loc = this.content.convertToNodeSpaceAR(event.getLocation());
      let xNum = Math.floor(loc.x / Config.singleSize);
      let yNum = Math.floor(loc.y / Config.singleSize);
      this.addOneBrick(xNum, yNum);
    }
  },
  // 随机添加一个方块
  addRandomBrick() {
    let brickMap = this.getBricksMap();
    let noneArr = [];
    for (let j = 0; j < brickMap.length; j ++) {
      let arr = brickMap[j];
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] === 0) {
          noneArr.push([i, j]);
        }
      }
    }
    if (noneArr.length > 0) {
      let target = noneArr[Util.getRandom(noneArr.length, 0)];
      this.addOneBrick(target[0], target[1]);
    }
  },
  getBricksMap() {
    let brickArr = [];
    for (let i = 0; i < Config.vCount; i ++) {
      brickArr.push([0,0,0,0,0,0,0,0]);
    }
    for (let i = 0; i < this.container.length; i ++) {
      let bricks = this.container[i];
      if (bricks.length > 0) {
        let idx = bricks[0].row;
        let cols = brickArr[idx];
        for (let k = 0; k < bricks.length; k++) {
          let obj = bricks[k];
          for (let j = 0; j < obj.gridNum; j++) {
            cols[obj.column + j] = j ? 1 : obj;
          }
        }
      }
    }

    return brickArr;
  },
  addOneBrick(xNum, yNum) {
    let brickMap = this.getBricksMap();
    let bricks = brickMap[yNum];
    if (bricks[xNum] === 0) {
      let brick = this.newBrick({gridNum: 1,
        typeNum: 0,
        column: xNum,
        hasRedPack: false,
        eventData: {y: yNum},
      });
      bricks[xNum] = brick.getComponent('gameCookie');
    }
    let brickArr = [];
    for (let i = brickMap.length - 1; i >=0 ; i --) {
      let brickRow = brickMap[i];
      if (brickRow.length > 0) {
        let subArr = [];
        for (let obj of brickRow) {
          if (obj !== 0 && obj !== 1) {
            subArr.push(obj);
          }
        }
        brickArr.push(subArr);
      }
    }
    this.container = brickArr;
  },
  checkHasBomb(units) {
    let hasBomb = false;
    if (units.length > 0) {
      for (let j = 0; j < units.length; ++j) {
        hasBomb = hasBomb || units[j].typeNum === 1;
      }
    }
    return hasBomb;
  },
  // 使用消除一行的道具消除三行
  removeOneRow(comp) {
    let self = this;
    let rows = [];
    let has_bomb;
    for (let i = this.container.length - 1; i >= 0; --i) {
      let units = this.container[i];
      if (units.length > 0) {
        has_bomb = units[0].typeNum === 1;
        for (let j = 0; j < units.length; ++j) {
          if (comp === units[j]) {
            rows.push(i);
          }
          has_bomb = has_bomb || units[j].typeNum === 1;
        }
        if (rows.length > 0) {
          break;
        }
      }
    }
    if (!rows.length) {
      return;
    }
    let currentIdx = rows[0];
    if (currentIdx > 0) {
      has_bomb = has_bomb || this.checkHasBomb(this.container[currentIdx - 1]);
      rows.unshift(currentIdx - 1);
    }
    if (currentIdx < this.container.length - 1) {
      rows.push(currentIdx + 1);
      has_bomb = has_bomb || this.checkHasBomb(this.container[currentIdx + 1]);
    }
    this.removeUnit(rows, has_bomb, true, function () {
      self.check_descend(function () {
        self.settle();
      });
    });
  },
  // 敲碎所有大方块
  breakAllBrick() {
    this.isCanTouch = false;
    for (let i = 0; i < this.container.length; i ++) {
      let units = this.container[i];
      for (let j = 0; j < units.length; j++) {
        if (units[j].gridNum > 1) {
          units[j].playItemAni('hammer');
        }
      }
    }
    let self = this;
    this.scheduleOnce(function () {
      let containers = [];
      for (let i = 0; i < self.container.length; i ++) {
        let units = self.container[i];
        let newUnits = [];
        for (let j = 0; j < units.length; j ++) {
          if (units[j].gridNum > 1) {
            let unit = units[j];
            for (let k = 0; k < unit.gridNum; ++k) {
              let new_unit = self.newBrick({
                gridNum: 1,
                newBrick: unit.typeNum,
                column: unit.column + k,
                typeNum: unit.typeNum,
                eventData: {
                  color: unit.colorType,
                  y: unit.row
                }
              }).getComponent('gameCookie');
              newUnits.push(new_unit);
            }
            unit.node.active = false;
            unit.node.parent = null;
          } else {
            newUnits.push(units[j]);
          }
        }
        newUnits.sort(function (a, b) {
          return a.column - b.column;
        });
        containers.push(newUnits);
      }
      self.container = containers;
      self.settle(function () {
        self.checkLevelUp();
      });
      self.isCanTouch = true;
      self.useItemIndex = -1;
    }, 1)
  },
  fetchCrazyRows() {
    let self = this;
    if (self.container.length < Config.crazy_min_rows) {
      for (let i = self.container.length; i < Config.crazy_min_rows; i ++) {
        self.next_grids = self.generate_grids();
        self.generate_row();
        self.rise_upper_units(function () {
        });
      }

    }
  },
});