(function() {
                    var nodeEnv = typeof require !== 'undefined' && typeof process !== 'undefined';
                    var __module = nodeEnv ? module : {exports:{}};
                    var __filename = 'preview-scripts/assets/Scripts/mod/battle/battle_model.js';
                    var __require = nodeEnv ? function (request) {
                        return cc.require(request);
                    } : function (request) {
                        return __quick_compile_project__.require(request, __filename);
                    };
                    function __define (exports, require, module) {
                        if (!nodeEnv) {__quick_compile_project__.registerModule(__filename, module);}"use strict";
cc._RF.push(module, '046a3v0XBJHTaPPjX3IPd0Q', 'battle_model');
// Scripts/mod/battle/battle_model.js

"use strict";

// --------------------------------------------------------------------
// @author: xxx@syg.com(必填, 创建模块的人员)
// @description:
//      战战斗数据控制器,其中包括了战斗场景的创建
//      flyItem attack hideUI showUI fadeOut fadeIn moveBack moveTo noActAttack  暂时实现的播报动作只有这一些
//      blackScreen blackScreen2 blackScreen3 hide show shadow 这一些已经废弃的
// <br/>Create: 2018-11-28 19:19:19
// --------------------------------------------------------------------
var BattleData = require("battle_data");

var BattleConst = require("battle_const");

var LoaderManager = require("loadermanager");

var BattleResPool = require("battle_res_pool");

var AniRes = ["hit_effect_list", // 受击点特效
"area_effect_list", // 范围特效
"act_effect_list", // 出手点特效
"bact_effect_list", // 施法特效
"trc_effect_list" // 弹道特效
];
var BattleModel = cc.Class({
  ctor: function ctor() {},
  properties: {
    init_fight_status: false
  },
  initConfig: function initConfig() {
    this.battle_controller = require("battle_controller").getInstance();
    this.hook_model = this.battle_controller.getHookModel();
    this.skill_act = require("skill_act");
    this.battle_pools = require("battle_role_pool").getInstance(); // 现在这个对象池主要是存放buff飘字以及主动技能飘字等,退出战斗没有移除掉这个对象池

    this.battle_dmg_cache_list = {}; // 战斗伤害数字的缓存纹理数据,现在退出战斗没有移除掉

    this.battle_effect_list = {}; // 当前战斗存在的非挂接角色的特效,这里存放的,退出战斗就会移除掉

    this.battle_effect_pool = {}; // 已经播放过的特效缓存对象,退出战斗就会移除掉

    this.role_time_scale = 1.1; // 二倍速下面的模型动作速率

    this.battle_speed = 1; // 当前战斗速率,服务端速率

    this.button_list_panel_time = 0; // 假战斗详情面板关闭的时间戳

    this.form_panel_time = 0; // 真战斗对战面板关闭的时间戳

    this.is_clear = true;
    this.resetInitData();
  },
  // 重设初始化数据
  resetInitData: function resetInitData() {
    this.my_group = 0; // 战斗中我自己的分组,主要区分是否是己方

    this.init_fight_status = false; // 是否是初始化进詹欧的,主要是做进场

    this.alive_num = 0; // 存活单位

    this.create_over_num = 0; // 已经创建完成的单位数量

    this.skill_plays_order_list = []; // 当前播放列表

    this.round_data_temp = {};
    this.order_list = [];
    this.round_data = {};
    this.cur_round_data = {};
    this.actor_sum = 0;
    this.actor_play_sum = 0;
    this.act_playing = false;
    this.is_play_round_start = false;
    this.cur_round = null;
    this.next_round = null;
    this.battle_data = null;
    this.combat_type = BattleConst.Fight_Type.Nil; // 当前战斗类型

    this.real_role_list = {}; // 真是战斗单位列表

    this.cur_fight_type = 0; // 当前战斗类型,如果是0:没有战斗 1:假战斗 2:真战斗

    this.buffs = {}; // 重连buff

    this.hallows_list = {}; // 神器数据

    this.scene_buff_effect_list = {}; // 场景buff特效缓存对象
  },
  // 创建一个场景特效,主要是群攻之类的,这类特效在退出战斗的时候会移除掉
  addBattleEfffect: function addBattleEfffect(parent, scene_pos, reverse, effect_id, action_name) {
    var BattleEffect = require("battle_effect");

    var battle_effect = null;
    var effect_key = Utils.getNorKey(effect_id, action_name);

    if (this.battle_effect_pool[effect_key] != null) {
      if (this.battle_effect_pool[effect_key].length > 0) {
        battle_effect = this.battle_effect_pool[effect_key].shift(); // 从头取出一个
      }
    }

    if (battle_effect == null) {
      battle_effect = new BattleEffect();
      battle_effect.createEffect(parent, scene_pos, reverse, effect_id);
    } else {
      battle_effect.resetScenePos(scene_pos);
      battle_effect.resetReverse(reverse);
      battle_effect.setTimeScale(this.role_time_scale);
      battle_effect.setActiveEffect(true);
    }

    if (this.battle_effect_list[effect_key] == null) {
      this.battle_effect_list[effect_key] = [];
    }

    this.battle_effect_list[effect_key].push(battle_effect);
    return battle_effect;
  },
  // 移除一个场景战斗特效
  delBattleEffect: function delBattleEffect(battle_effect) {
    var effect_key = battle_effect.getEffectKey();
    if (effect_key == "_") return;

    if (this.battle_effect_pool[effect_key] == null) {
      this.battle_effect_pool[effect_key] = [];
    }

    var array = this.battle_effect_list[effect_key];

    for (var index = 0; index < array.length; index++) {
      var element = array[index];

      if (element == battle_effect) {
        array.splice(index, 1);
        battle_effect.setActiveEffect(false);
        this.battle_effect_pool[effect_key].push(battle_effect);
        break;
      }
    }
  },
  // 获取伤害数字的缓存纹理数据
  getDmgFontCacheObject: function getDmgFontCacheObject(type, callback) {
    var res_path = PathTool.getPlistPath("num", "type" + type);
    var res_object = this.battle_dmg_cache_list[res_path];

    if (res_object == null) {
      LoaderManager.getInstance().loadRes(res_path, function (res_object) {
        this.battle_dmg_cache_list[res_path] = res_object;
        callback(res_object);
      }.bind(this));
    } else {
      callback(res_object);
    }
  },
  // 释放掉战斗资源,退出战斗场景之后释放掉吧,但是这里可能存在一个问题就是退出战斗场景是即时的,但是伤害数字还在处于动作中,这个时候还是释放不掉,战斗艺术字不是特别大,暂时考虑不清除
  releaseDmgFont: function releaseDmgFont() {
    for (var path in this.battle_dmg_cache_list) {
      LoaderManager.getInstance().releaseRes(path);
    }

    this.battle_dmg_cache_list = {};
  },
  // 获取一个普通文字.带背景的,暂时退出战斗没有移除对象池
  getNormalFont: function getNormalFont() {
    var pools = this.battle_pools.getFontPools();
    var node = null;

    if (pools.size() > 0) {
      node = pools.get();
    } else {
      node = new cc.Node();
      node.setAnchorPoint(0.5, 0.5);
      node.width = 176;
      node.height = 44;
      var bg_node = new cc.Node();
      bg_node.addComponent(cc.Sprite);
      node.addChild(bg_node);
      var font_node = new cc.Node();
      var font_label = font_node.addComponent(cc.Label);
      font_label.lineHeight = 20;
      font_label.fontSize = 20;
      font_node.addComponent(cc.LabelOutline);
      font_node.name = "font_label";
      node.addChild(font_node);
      var bg_path = PathTool.getUIIconPath("battle", "battle_buff_name_bg");
      LoaderManager.getInstance().loadRes(bg_path, function (bg_node, res_object) {
        bg_node.getComponent(cc.Sprite).spriteFrame = res_object;
      }.bind(this, bg_node));
    }

    return node;
  },

  /**
   * 回收对象池
   * @param {*} font 
   */
  pushBackBattleFont: function pushBackBattleFont(font) {
    this.battle_pools.pushBackFont(font);
  },

  /**
   * 真是战斗的初始化数据.战斗单位可能存在hp为0的时候,这个时候需要特殊处理
   */
  updateCurBattleData: function updateCurBattleData(data, is_init) {
    this.deleteCurBattleData();
    this.init_fight_status = is_init;

    if (this.battle_data == null) {
      this.battle_data = new BattleData();
    }

    this.battle_data.updateData(data); // 保存战斗速度

    this.saveSpeed(data.play_speed); // 更新神器数据

    for (var index = 0; index < data.hallows_list.length; index++) {
      var element = data.hallows_list[index];
      this.hallows_list[element.group] = element;
    } // 先判断对战列表中是否有自己的


    var RoleController = require("role_controller");

    var role_vo = RoleController.getInstance().getRoleVo();

    for (var key in this.battle_data.fight_object_list) {
      var role_data = this.battle_data.fight_object_list[key];

      if (Utils.getNorKey(role_data.owner_id, role_data.owner_srv_id) == Utils.getNorKey(role_vo.rid, role_vo.srv_id) && this.my_group == 0) {
        this.my_group = role_data.group;
      }

      if (role_data.hp > 0) {
        this.alive_num += 1;
      } // 处理神器的


      if (role_data.object_type == BattleConst.Unit_Type.Hallows) {
        var hallows_data = this.hallows_list[role_data.group];
        hallows_data.pos = role_data.pos;
        role_data.hallows_val = hallows_data.val;
        role_data.hallows_max = hallows_data.max;
      }
    }

    if (this.my_group == 0) {
      this.my_group = 1;
    }
  },

  /**
   * 创建完成之后通知服务端准备报了
   */
  addReadySum: function addReadySum() {
    this.create_over_num += 1;

    if (this.create_over_num >= this.alive_num) {
      this.battle_controller.csReadyFightStart();
    }
  },
  // 获取所有战斗单位
  getAllObject: function getAllObject() {
    return this.real_role_list;
  },
  // 设置战斗场景可见与否
  handleBattleSceneStatus: function handleBattleSceneStatus(status) {
    if (this.battle_scene) {
      this.battle_scene.changeVisible(status); // this.battle_scene.setVisible(status)
    }
  },
  // 是否在战斗中
  getFightStatus: function getFightStatus() {
    return this.is_real_combat;
  },
  // 返回战斗场景
  getBattleScene: function getBattleScene() {
    return this.battle_scene;
  },
  // 是否在真战斗中
  isInRealBattle: function isInRealBattle() {
    return this.is_real_combat;
  },

  /**
   * 创建战斗场景,这里是唯一的入口,这里需要判断真假战斗切换,等
   * @param {*} in_fight_type 0:没有战斗 1:假战斗 2:真战斗
   */
  createBattleScene: function createBattleScene(in_fight_type, combat_type) {
    // 不同类的战斗或者不同类的战斗状态类型,都清掉单位
    if (this.combat_type != combat_type || this.cur_fight_type != in_fight_type || in_fight_type == 1) {
      // 假战斗也移除掉单位重新创建吧
      this.clearRealRole();
      this.hook_model.clearRealRole();
    }

    this.combat_type = combat_type; // 储存当前战斗类型

    this.cur_fight_type = in_fight_type; // 保存当前之战斗状态类型

    this.is_real_combat = in_fight_type == BattleConst.Battle_In_Type.Real;

    if (this.battle_scene == null) {
      this.battle_scene = Utils.createClass("battle_scene");
    }

    this.battle_scene.updateBattleScene(this.is_real_combat); // 只有剧情战斗的时候才需要显示战斗ui

    var is_show = combat_type == BattleConst.Fight_Type.Darma;
    this.openDramaFightUI(is_show); // 只有真战斗才需要显示

    this.openFormViewUI(this.is_real_combat, combat_type);
    this.battle_controller.setIsNormaBattle(this.is_real_combat); // 这里把主城设置不可见

    require("mainscene_controller").getInstance().handleSceneStatus(false);

    this.is_clear = false;
  },
  // 剧情战斗的ui部分
  openDramaFightUI: function openDramaFightUI(status) {
    if (this.show_fight_ui_status == status && this.fight_ui_combat == this.is_real_combat) {
      return;
    }

    this.show_fight_ui_status = status;
    this.fight_ui_combat = this.is_real_combat;

    if (!status) {
      if (this.drama_fight_ui) {
        this.drama_fight_ui.hide();
        this.button_list_panel_time = gcore.SmartSocket.getTime();
      }
    } else {
      if (this.drama_fight_ui == null) {
        this.drama_fight_ui = Utils.createClass("battle_button_list_panel");
        var partner = ViewManager.getInstance().getSceneNode(SCENE_TAG.ui);
        this.drama_fight_ui.setParent(partner);
        this.drama_fight_ui.show(this.is_real_combat);
        this.drama_fight_ui.setZIndex(-2);
      } else {
        if (this.drama_fight_ui.is_onshow == false) {
          this.drama_fight_ui.show(this.is_real_combat);
        } else {
          this.drama_fight_ui.changeBattleStatus(this.is_real_combat);
        }
      }

      this.button_list_panel_time = 0;
    }

    this.battle_controller.setIsNormaBattle(this.is_real_combat);
    this.startCountDownToDelete();
  },
  // 真战斗中的阵型以及其他相关显示部分
  openFormViewUI: function openFormViewUI(status, combat_type) {
    if (!status) {
      if (this.form_fight_ui) {
        this.form_fight_ui.hide();
        this.form_panel_time = gcore.SmartSocket.getTime();
      }
    } else {
      if (this.form_fight_ui) {
        this.form_fight_ui.show(combat_type);
      } else {
        this.form_fight_ui = Utils.createClass("battle_form_panel");
        var partner = ViewManager.getInstance().getSceneNode(SCENE_TAG.ui);
        this.form_fight_ui.setAnchorPoint(0, 0);
        this.form_fight_ui.setPosition(-partner.width * 0.5, -partner.height * 0.5);
        this.form_fight_ui.setParent(partner);
        this.form_fight_ui.show(combat_type);
        this.form_fight_ui.setZIndex(-1);
      }

      this.form_panel_time = 0;
    }

    this.startCountDownToDelete();
  },
  // 关闭面板的倒计时
  startCountDownToDelete: function startCountDownToDelete() {
    if (this.form_panel_time == 0 && this.button_list_panel_time == 0) {
      if (this.close_panel_timer) {
        gcore.Timer.del(this.close_panel_timer);
        this.close_panel_timer = null;
      }
    } else {
      if (this.close_panel_timer == null) {
        this.close_panel_timer = gcore.Timer.set(function () {
          this.waitDeletePanel();
        }.bind(this), 1000, -1);
      }
    }
  },
  // 倒计时准备清楚面板
  waitDeletePanel: function waitDeletePanel() {
    if (this.form_panel_time == 0 && this.button_list_panel_time == 0) {
      this.startCountDownToDelete(); // 移除掉定时器
    } else {
      if (this.button_list_panel_time != 0) {
        var button_pass_time = gcore.SmartSocket.getTime() - this.button_list_panel_time;

        if (button_pass_time > 100) {
          if (this.drama_fight_ui) {
            this.drama_fight_ui.deleteMe();
            this.drama_fight_ui = null;
          }

          this.button_list_panel_time = 0;
        }
      }

      if (this.form_panel_time != 0) {
        var form_pass_time = gcore.SmartSocket.getTime() - this.form_panel_time;

        if (form_pass_time > 100) {
          if (this.form_fight_ui) {
            this.form_fight_ui.deleteMe();
            this.form_fight_ui = null;
          }

          this.form_panel_time = 0;
        }
      }
    }
  },
  // 引导需要
  getDramaFightUI: function getDramaFightUI() {
    if (this.drama_fight_ui) return this.drama_fight_ui.root_wnd;
    return null;
  },

  /**
   * 彻底移除一个战斗场景,比如说切换出战斗,或者非剧情战斗结束,这个结束
   */
  clearBattleScene: function clearBattleScene() {
    if (this.battle_scene && !this.is_clear) {
      // 先移除掉单位定时器
      var role_list = this.getAllBattleRoleList();

      for (var pos in role_list) {
        gcore.Timer.del("attackerActTimeout" + pos);
      }

      this.combat_type = BattleConst.Fight_Type.Nil;
      this.cur_fight_type = BattleConst.Battle_In_Type.Nil; // 移除掉战斗类型

      this.is_real_combat = false; // 战斗
      // 清楚掉场景单位

      this.clearRealRole();
      this.hook_model.clearRealRole(); // 假战斗模型资源

      this.battle_scene.deleteMe();
      this.battle_scene = null;
      this.openDramaFightUI(false);
      this.openFormViewUI(false); // 移除掉所有的战斗特效--,群攻类和子弹类

      this.cleanAllBattleEffect(); // 移除真实战斗场景的数据

      this.deleteCurBattleData(); // 这里切回主城音乐

      Utils.playMusic(AUDIO_TYPE.SCENE, "s_002", true);
      this.is_clear = true;
    }
  },
  // 清空所有的场景战斗特效
  cleanAllBattleEffect: function cleanAllBattleEffect() {
    // 回收掉场景特效资源
    for (var key in this.battle_effect_list) {
      var array = this.battle_effect_list[key];

      for (var index = 0; index < array.length; index++) {
        var element = array[index];
        element.deleEffect();
      }
    }

    this.battle_effect_list = {}; // 回收掉场景特效资源

    for (var key in this.battle_effect_pool) {
      var array = this.battle_effect_pool[key];

      for (var _index = 0; _index < array.length; _index++) {
        var _element = array[_index];

        _element.deleEffect();
      }
    }

    this.battle_effect_pool = {};
  },

  /**
   * 假战斗定帧移动地图处理,现在卸载gamestart 的update里面
   */
  mapMovescheduleUpdate: function mapMovescheduleUpdate() {
    if (this.battle_scene) {
      this.battle_scene.mapMovescheduleUpdate();
    }
  },

  /**
   * 切换战斗移动状态,比如真实剧情战斗切换到假战斗的时候,就需要开启地图移动
   * @param {*} status Bool
   */
  changeMoveMapStatus: function changeMoveMapStatus(status) {
    if (this.battle_scene) {
      this.battle_scene.changeMoveMapStatus(status);
    }
  },

  /**
   * 进入真实战斗时,是否需要播放进场动作,中途切进去的不需要处理,这个值针对初始化单位的时候需要,战斗创建一个单位不需要
   */
  needPlayEnterAction: function needPlayEnterAction() {
    return this.init_fight_status;
  },

  /**
   * 真实战斗中的单位是否是友方判断
   * @param {*} group BattleRoleData.group
   */
  isFriend: function isFriend(group) {
    return group == this.my_group;
  },

  /**
   * 当前真实战斗的初始化数据
   */
  getCurBattleData: function getCurBattleData() {
    return this.battle_data;
  },
  // 获取当前战斗类型
  getCombatType: function getCombatType() {
    return this.combat_type;
  },

  /**
   * 退出战斗,清空战斗数据,针对真实战斗
   */
  deleteCurBattleData: function deleteCurBattleData() {
    this.resetInitData();
  },
  // 判断是否可以改变战斗速度
  checkIsCanChangeBattleSpeed: function checkIsCanChangeBattleSpeed() {
    if (this.battle_data == null) {
      return false;
    }

    var next_speed = 1;

    if (this.battle_speed == 1) {
      next_speed = 2;
    }

    var speed_config = Config.combat_type_data.data_combat_speed[next_speed];

    if (speed_config == null) {
      return false;
    }

    var role_vo = require("role_controller").getInstance().getRoleVo();

    if (role_vo == null) {
      return false;
    }

    if (speed_config.limit_lev > role_vo.lev && speed_config.limit_vip_lev > role_vo.vip_lev) {
      var desc = cc.js.formatStr(Utils.TI18N("等级达到%s级或VIP%s开启"), speed_config.limit_lev, speed_config.limit_vip_lev);
      message(desc);
      return false;
    }

    var fight_config = Config.combat_type_data.data_fight_list[this.battle_data.combat_type];

    if (fight_config == null) {
      return false;
    }

    if (fight_config.is_pvp == 1) {
      message(cc.js.formatStr(Utils.TI18N("%s不能更改速度"), fight_config.desc));
      return false;
    }

    return true;
  },

  /**
   * 修改一下当前战斗速度
   */
  changeSpeed: function changeSpeed() {
    if (this.battle_speed == 1) {
      this.saveSpeed(2);
      this.battle_controller.csFightSpeed(2);
    } else {
      this.saveSpeed(1);
      this.battle_controller.csFightSpeed(1);
    }
  },

  /**
   * 当前战斗速度
   */
  getTimeScale: function getTimeScale() {
    var time_scale = 1;

    if (this.isInRealBattle() == true) {
      time_scale = this.role_time_scale;
    } // time_scale = 1.5
    // 要根据当前帧频调整播放速度


    return time_scale;
  },
  // 设置当前动作速度
  setBattleTimeScale: function setBattleTimeScale(is_reset) {
    if (this.battle_time_status == is_reset) return;
    this.battle_time_status = is_reset;
    var base_config = null;

    if (is_reset == true) {
      // 这个时候是1倍速
      base_config = Config.battle_act_data.data_get_act_data.base_speed_scale;
    } else {
      base_config = Config.battle_act_data.data_get_act_data.speed_scale;
    }

    if (base_config) {
      this.role_time_scale = base_config.val * 0.01;
    }

    this.setRoleTimeScale();
  },
  // 保存速率之后马上设置模型动作
  setRoleTimeScale: function setRoleTimeScale() {
    if (this.real_role_list) {
      for (var key in this.real_role_list) {
        var object = this.real_role_list[key];

        if (object) {
          object.setTimeScale(this.role_time_scale);
        }
      }
    } // 设置场景特效


    if (this.battle_effect_list) {
      for (var key in this.battle_effect_list) {
        var array = this.battle_effect_list[key];

        for (var index = 0; index < array.length; index++) {
          var element = array[index];

          if (element) {
            element.setTimeScale(this.role_time_scale);
          }
        }
      }
    }
  },
  // 保存当前战斗速度,这个速度只是为了改变显示
  saveSpeed: function saveSpeed(speed) {
    if (this.battle_speed == speed) return;
    this.battle_speed = speed;

    if (this.form_fight_ui) {
      this.form_fight_ui.setSpeed(speed);
    }
  },
  // 获取当前速度
  getSpeed: function getSpeed() {
    return this.battle_speed;
  },

  /**
   * 一个回合播报的动作计数,最后保证值为0就表示播完了当前动作
   * @param {*} attacker 
   */
  actStart: function actStart(attacker) {
    // 如果结算面板已经出来了,就不需要播报了
    if (this.checkoutIsRightFight(attacker) == true) {
      attacker.wait_act += 1;
      gcore.Timer.del("attackerActTimeout" + attacker.pos);
      gcore.Timer.set(function () {
        this.actTimeout(attacker);
      }.bind(this), 3000, 1, "attackerActTimeout" + attacker.pos);
    }
  },

  /**
   * 某一个动作播放完成之后,计数 -1,当为0的时候,就表示当前小回合播报结束
   * @param {*} attacker 
   */
  actFinish: function actFinish(attacker) {
    if (this.checkoutIsRightFight(attacker) == true) {
      if (attacker.wait_act > 0) {
        attacker.wait_act -= 1;

        if (attacker.wait_act <= 0) {
          if (attacker.is_real) {
            this.playOrder(attacker);
            gcore.Timer.del("attackerActTimeout" + attacker.pos);
          } else {
            this.hook_model.playOrder(attacker);
          }
        }
      }
    }
  },

  /**
  * 判断是都是正式战斗
  *
  */
  checkoutIsRightFight: function checkoutIsRightFight(attacker) {
    if (attacker.is_real == true) {
      if (this.battle_data && this.cur_round_data && this.battle_data.combat_type == this.cur_round_data.combat_type) {
        return true;
      }
    } else {
      var battle_data = this.hook_model.getUnrealBattleData();

      if (battle_data && battle_data.combat_type == BattleConst.Fight_Type.Darma) {
        return true;
      }
    }

    return false;
  },

  /**
   * 小回合播报超时处理
   * @param {*} attacker 
   */
  actTimeout: function actTimeout(attacker) {
    if (attacker == null) return;
    attacker.wait_act = 1;
    this.actFinish(attacker);
  },

  /**
   * 回合开始的播报,包括站位的初始化等,因为有一些是需要在回合开始的时候播放的播报  包含回合开始的buff
   * @param {*} data 协议 20002 的数据
   */
  playRoundStart: function playRoundStart(data) {
    if (this.getBattleScene() == null || this.battle_data == null || this.battle_data.combat_type != data.combat_type) {
      return;
    }

    this.is_play_round_start = true; // 处理回合buff

    this.dealRoundBuff(data.round_buff); // 处理神器的回合进度

    if (data && data.hallows_list) {
      for (var index = 0; index < data.hallows_list.length; index++) {
        var element = data.hallows_list[index];

        if (element) {
          var hallows = this.hallows_list[element.group];

          if (hallows && hallows.pos) {
            var role = this.real_role_list[hallows.pos];

            if (role) {
              role.setHallowsRound(element.val);
            }
          }
        }
      }
    } // 回合开始也处理掉那些假死的模型


    if (data && data.all_alive) {
      var temp_list = {};

      for (var _index2 = 0; _index2 < data.all_alive.length; _index2++) {
        var _element2 = data.all_alive[_index2];

        if (_element2) {
          temp_list[_element2.pos] = true;
        }
      }

      for (var key in this.real_role_list) {
        if (!temp_list[key]) {
          var role = this.real_role_list[key];

          if (role && !role.is_die && role.role_data && role.role_data.object_type != BattleConst.Unit_Type.Hallows) {
            role.doDied();
          }
        }
      }
    } // 没有技能播报列表,直接通知服务端结束


    if (data == null || data.skill_plays.length == 0) {
      this.battle_controller.csRoundFightEnd(); // 初始化位置层级等相关信息

      this.handlePlayRoundStart(data);
    } else {
      this.addRoundData(data);
    }

    if (this.form_fight_ui) {
      this.form_fight_ui.updateRound(data.action_count);
    }
  },

  /**
   * 正常回合播报,回合开始播报结束之后,进入正常回合播报 包含回合结束buff和效果播报的buff
   * @param {*} data 协议 20004 的数据
   */
  playRoundIn: function playRoundIn(data) {
    this.is_play_round_start = false; // 回合结束后的buff可能需要处理的

    if (data.round_buff && data.round_buff.length > 0) {
      this.act_after_buff_list = data.round_buff;
    } else {
      this.act_after_buff_list = null;
    }

    this.addRoundData(data);
  },
  // 更新buff
  setBuffsList: function setBuffsList(data) {
    this.buffs = data;
  },

  /**
   * 更新下一波怪物的数据
   * @param {*} data 
   */
  upDateNextMon: function upDateNextMon(data) {
    if (this.real_role_list == null || data == null) return; // 清掉上一回合的死亡对象

    for (var key in this.real_role_list) {
      var role = this.real_role_list[key];

      if (role && role.is_die == true) {
        role.deleteRole();
        this.real_role_list[key] = null;
      }
    }

    this.setBuffsList(data.buffs);

    if (this.getBattleScene()) {
      for (var index = 0; index < data.objects.length; index++) {
        var element = data.objects[index];
        var role = this.real_role_list[element.pos];

        if (this.isFriend(element.group) && role) {
          role.updataNextBattleRole(element);
        } else {
          this.createRole(element, true, null, true);
        }
      }
    } // 更新战斗基本数据


    if (this.battle_data) {
      this.battle_data.updateData(data);

      if (this.form_fight_ui) {
        this.form_fight_ui.updateBaseInfo();
      }
    }
  },

  /**addReConnectReadySum
   * 
   * 处理回合开始的数据
   * @param {*} data 协议 20002 的数据
   */
  handlePlayRoundStart: function handlePlayRoundStart(data) {
    if (this.battle_data == null || this.battle_data.combat_type != data.combat_type) {
      return;
    }

    if (this.battle_scene == null) {
      return;
    }

    this.resetBattleRoleBaseInfo();
  },
  // 处理回合buff
  dealRoundBuff: function dealRoundBuff(buff_list, attacker) {
    if (buff_list == null || buff_list.length == 0) return;

    for (var index = 0; index < buff_list.length; index++) {
      var element = buff_list[index];
      var battle_role = this.real_role_list[element.target];
      var buff_config = Config.skill_data.data_get_buff[element.buff_bid];

      if (battle_role && buff_config) {
        this.playRoundBuff(battle_role, element, attacker);
      }
    }
  },

  /**
   * 回合中的播报,这个是播报的主入口
   * @param {*} data 协议 20004 的数据 
   */
  addRoundData: function addRoundData(data) {
    if (this.getBattleScene() == null || this.battle_data == null || this.battle_data.combat_type != data.combat_type) {
      return;
    } // 更新当前回合数


    if (this.form_fight_ui && data.action_count) {
      this.form_fight_ui.updateRound(data.action_count);
    } // 播报数据


    this.cur_round = null;
    this.next_round = null;
    this.cur_round_data = data;
    this.skill_plays_order_list = [];
    this.round_data_temp = {};

    if (this.form_fight_ui) {
      this.form_fight_ui.updateRound(data.action_count);
    } // 技能播报数据, 解析技能数据


    for (var j = 0; j < data.skill_plays.length; j++) {
      var skill_element = data.skill_plays[j];

      for (var i = 0; i < skill_element.effect_play.length; i++) {
        var effect_element = skill_element.effect_play[i];

        if (this.round_data_temp[skill_element.order] == null) {
          this.round_data_temp[skill_element.order] = [];
          this.skill_plays_order_list.push({
            skill_order: skill_element.order,
            priority: skill_element.order * 1000 + j
          });
        }

        effect_element.skill_bid = effect_element.skill_bid_of_effect;
        effect_element.talk_pos = skill_element.talk_pos;
        effect_element.talk_content = skill_element.talk_content;
        effect_element.index = i;
        effect_element.skill_order = skill_element.order;
        effect_element.priority = effect_element.order * 10000 + j * 100 + i;
        this.round_data_temp[skill_element.order].push(effect_element);
      }
    } // 对出手进行排序


    this.skill_plays_order_list.sort(function (a, b) {
      return a.priority - b.priority;
    }); // cc.log("HHHHHHHHHHHHHHHHHHHHH");
    // cc.log(this.skill_plays_order_list);

    this.preloadBattleRes(data, function () {
      this.analyseTempRoundData();
    }.bind(this));
  },
  // 分析当前播报数据
  analyseTempRoundData: function analyseTempRoundData() {
    this.order_list = [];
    this.round_data = {};

    if (Object.keys(this.round_data_temp).length > 0) {
      for (var index = 0; index < this.skill_plays_order_list.length; index++) {
        var element = this.skill_plays_order_list[index];
        var temp = this.round_data_temp[element.skill_order];

        for (var i = 0; i < temp.length; i++) {
          var one_temp = temp[i];

          if (this.round_data[one_temp.order] == null) {
            this.round_data[one_temp.order] = {};
            this.order_list.push({
              order: one_temp.order,
              priority: one_temp.priority
            });
          }

          if (this.round_data[one_temp.order][one_temp.actor] == null) {
            this.round_data[one_temp.order][one_temp.actor] = {
              order: one_temp.order,
              actor: one_temp.actor,
              skill_bid: one_temp.skill_bid,
              talk_content: one_temp.talk_content,
              talk_pos: one_temp.talk_pos,
              index: one_temp.index,
              target_list: []
            };
          }

          var object = this.round_data[one_temp.order][one_temp.actor];
          object.target_list.push(one_temp);
        }
      } // 对出售惊醒排序


      this.order_list.sort(function (a, b) {
        return a.priority - b.priority;
      });
      this.round_data_temp = {};
    } // cc.log("出售顺序HHHHH");
    // cc.log(Utils.deepCopy(this.order_list));
    // cc.log(Utils.deepCopy(this.round_data));


    this.round();
  },
  // 回合播报
  round: function round() {
    if (this.round_num && this.round_num > 0) return;
    this.round_num = 0;
    this.actor_sum = 0;
    this.actor_play_sum = 0;
    this.cur_round = null;
    this.next_round = null; // 回合播报之前重置掉所有单位受击状态

    if (this.battle_scene) {
      var role_list = this.getAllBattleRoleList();

      for (var key in role_list) {
        var role = role_list[key];

        if (role) {
          role.dmg_index = 0;
          role.dmg_aid_y_offset = 0;
          role.is_hurt_play = false;
          role.is_big_play = false;
        }
      }
    }

    if (this.order_list.length == 0) {
      this.cancleBlackScreen(); // 回合后的buff处理

      if (this.act_after_buff_list && this.act_after_buff_list.length > 0) {
        this.dealRoundBuff(this.act_after_buff_list);
        this.act_after_buff_list = null;
      } // 重置一些状态,可能是一些数值类的


      if (this.real_role_list) {
        for (var key in this.real_role_list) {
          var battle_role = this.real_role_list[key];

          if (battle_role) {
            battle_role.temp_skill_bid = 0;
          }
        }
      } // 通知服务端播报完成,区分回合开始和中间回合播报


      if (this.is_play_round_start == true) {
        this.battle_controller.csRoundFightEnd();
      } else {
        this.battle_controller.csSkillPlayEnd();
      } // 这个时候设置所有的单位初始状态

    } else {
      var first_data = this.order_list.shift();
      var round_data = this.round_data[first_data.order];

      if (this.order_list.length > 0) {
        var second_order = this.order_list[0].order;
        var second_data = this.round_data[second_order]; // 找到下一个回合播报,于当前回合播报做比较判断是不是多段攻击,从而在当前播报结束之后,是否需要重置

        for (var actor in second_data) {
          if (this.next_round == null) {
            this.next_round = second_data[actor];
            break;
          }
        }
      }

      this.round_num = Object.keys(round_data).length;

      for (var actor in round_data) {
        this.round_num -= 1;
        var round_one_temp = round_data[actor];

        if (this.cur_round == null) {
          this.cur_round = round_one_temp;
        }

        if (round_one_temp.target_list.length > 0) {
          var attacker = this.getBattleRoleByPos(round_one_temp.actor);

          if (attacker) {
            this.actor_sum = this.actor_sum + 1;
            this.initOrder(attacker, round_one_temp);
          } else {
            this.round();
          }
        } else {
          this.round();
        }
      }
    }
  },
  // 播放回合buff,可能是回合开始,效果播报结束,也可能是回合结束, 这个buff是协议数据来的
  playRoundBuff: function playRoundBuff(target, buff, attacker, effect_hit) {
    if (target == null || buff == null) return;
    this.addBuff(attacker, target, buff);

    if (buff.change_type == 1) {
      // 血量变化的时候
      this.battleRoleHPChange(target, buff.change_value, buff.is_dead, effect_hit, true);
    }
  },
  // buff类的气血上号
  battleRoleHPChange: function battleRoleHPChange(target, value, is_dead, effect_hit, is_buff, camp_restrain) {
    if (target == null) return;
    target.updateHP(value, is_dead, true, 0);
    this.mutiHurtNum(target, value, effect_hit, is_buff, camp_restrain);
  },
  // 初始化动作列表,准备开战了,初始化一些数据
  initOrder: function initOrder(attacker, one) {
    one.target_list.sort(function (a, b) {
      return a.priority - b.priority;
    }); // 这个后续再看看要不要动态设置层级

    if (this.cur_round && this.last_round_actor && this.cur_round.actor == this.last_round_actor) {} else {
      attacker.resetZOrder();
      attacker.targe_zorder = 9999;
    }

    var list = one.target_list;
    var col_target = list[0].target;

    if (col_target > GIRD_POS_OFFSET) {
      col_target = col_target - GIRD_POS_OFFSET;
    }

    var col = Pos_To_Col[col_target - 1];
    var target = this.getBattleRoleByPos(col_target);

    if (target) {
      target.resetZOrder();
      attacker.targe_zorder = target.getLocalZOrder();
    }

    attacker.col = col;
    attacker.is_round = false;
    attacker.attacker_info = one;
    attacker.skill_data = gdata('skill_data', 'data_get_skill', one.skill_bid);
    attacker.target_pos = attacker.grid_pos;
    attacker.play_order_index = one.target_list[0].effect_bid;
    this.calcTargetPos(attacker); // 如果没有效果id则不处理,所有播报驱动都是效果驱动

    if (attacker.play_order_index == null || attacker.play_order_index == 0) {
      this.actor_play_sum += 1;
      var effect_play = one.target_list[0];

      if (effect_play) {
        if (effect_play.sub_effect_play_list && effect_play.sub_effect_play_list.length > 0) {
          this.handleSubEffectPlaylist(effect_play, attacker);
        }

        this.dealRoundBuff(effect_play.buff_list, attacker);
      }

      this.round();
      return;
    }

    var effect_config = gdata('skill_data', 'data_get_effect', attacker.play_order_index);

    if (effect_config) {
      attacker.play_order = Utils.deepCopy(effect_config.action_list); // 动作列表

      attacker.shake_id = effect_config.shake_id; // 震屏ID

      attacker.effect_type = effect_config.effect_type; // 效果类型

      attacker.play_stand = effect_config.play_stand; // 是否收招

      attacker.anime_res = effect_config.anime_res; // 攻击动作资源

      attacker.split_hurt = effect_config.split_hurt;
      attacker.hit_action = effect_config.hit_action; // 受击处理

      attacker.effect_desc = effect_config.effect_desc; // 效果飘字

      attacker.is_must_die = effect_config.is_must_die; // 死亡的时候是否移除,这个主要是判断连击中的时候

      attacker.anime_user_atk = effect_config.anime_user_atk; // 攻击动作名

      attacker.attack_sound = effect_config.attack_sound; // 攻击音效

      attacker.ready_sound = effect_config.ready_sound; // 准备音效

      attacker.shout_trick = effect_config.shout_trick; // 喊招音效

      attacker.hit_sound = effect_config.hit_sound; // 受击音效

      attacker.hit_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.hit_effect_list)); // 记录打击特效列表

      attacker.area_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.area_effect_list)); // 记录范围人物特效

      attacker.act_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.act_effect_list)); // 记录出手点特效

      attacker.bact_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.bact_effect_list)); // 记录施法特效

      attacker.trc_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.trc_effect_list)); // 记录弹道特效
    } // 是否有群攻


    if (attacker.area_effect_list.length > 0) {
      attacker.attacker_info.is_calc = false;
      attacker.in_area_effect = true;
      attacker.area_hit_num = 1;
      attacker.area_hit_time = 0;
    } else {
      attacker.in_area_effect = false;
    }

    var start_attack = function () {
      this.playOrder(attacker);
    }.bind(this); // 主动技能和被动技能喊招处理


    var show_skill_nme = function () {
      var skill_type = attacker.skill_data.type;

      if (skill_type == BattleConst.Skill_Type.PASSIVE_SKILL && attacker.skill_data.passive_skill_show == 1) {
        this.playFontMessage(attacker, attacker.skill_data.name, null, null, null, null, null, function () {
          start_attack();
        }.bind(this));
      } else if (skill_type == BattleConst.Skill_Type.ACTIVE_SKILL) {
        if (this.form_fight_ui) {
          this.form_fight_ui.showActiveSkillName(attacker, function () {
            start_attack();
          });
        }
      } else {
        start_attack();
      }
    }.bind(this);

    if (attacker.skill_data == null) {
      this.talk(attacker, start_attack);
    } else {
      this.talk(attacker, show_skill_nme);
    }

    this.act_playing = true;
  },

  /**
   * 计算目标点
   * @param {*} attacker 
   * @param {*} object_list 
   */
  calcTargetPos: function calcTargetPos(attacker, object_list) {
    if (attacker == null || attacker.attacker_info == null) {
      return;
    }

    var target_list = attacker.attacker_info.target_list;
    var target = null;

    for (var index = 0; index < target_list.length; index++) {
      var element = target_list[index];

      if (object_list) {
        target = object_list[element.target];
      } else {
        target = this.getBattleRoleByPos(element.target);
      }

      if (target && target.obj_type != attacker.obj_type) {
        break;
      }
    }

    if (target) {
      attacker.target_pos = target.grid_pos;
      attacker.target_pos_base = target.grid_pos;
      attacker.target_name = target.role_data.object_name;
    }
  },
  // 效果列表
  getCurEffectList: function getCurEffectList(list) {
    var effect_list = [];

    for (var index = 0; index < list.length; index++) {
      var element = list[index];
      var effect_data = Config.skill_data.data_get_effect_data[element];
      effect_list.push(effect_data);
    }

    return effect_list;
  },
  // 单位喊话
  talk: function talk(attacker, callback) {
    var msg = attacker.attacker_info.talk_content || "";
    var actor = attacker.attacker_info.talk_pos;

    if (msg == "") {
      if (callback) {
        callback();
      }

      return;
    } // 然后播放气泡.....


    if (callback) {
      callback();
    }
  },
  // 获取播报动作
  singleAct: function singleAct(act_data, attacker) {
    if (act_data instanceof Array) {
      return this.mutiAct(act_data, attacker);
    } else {
      var act_config = Utils.deepCopy(Config.skill_data.data_get_act_data[act_data]);

      if (act_config) {
        var args = act_config.act_args;
        var funname = args[0];

        if (funname == null || this[funname] == null) {
          return;
        }

        if (this[funname] instanceof Function) {
          var params = args[1] || [];
          params.unshift(attacker);
          return this[funname].apply(this, params);
        } else {
          Log.info("动作错误,动作BID:" + act_data);
        }
      }
    }
  },
  // 获取多段播报动作
  mutiAct: function mutiAct(args, attacker) {
    var acts = [];

    for (var index = 0; index < args.length; index++) {
      var element = args[index];
      var act = this.singleAct(element, attacker);
      acts.push(act);
    }

    if (acts.length == 1) {
      return acts[0];
    } else {
      return cc.spawn.apply(null, acts);
    }
  },

  /**
   * 技能动作附带糊掉函数
   * @param {*} attacker 
   * @param {*} args 
   */
  callfun: function callfun(attacker, args) {
    var funname = "";
    var params = null;

    if (args instanceof Array) {
      funname = args[0];
      params = args[1] || [];
    } else {
      funname = args;
    }

    if (funname == "") {
      return;
    }

    if (this[funname] instanceof Function) {
      if (params == null) {
        params = [];
      }

      params.unshift(attacker);
      this[funname].apply(this, params);
    } else if (typeof funname == "number") {
      var act = this.singleAct(funname, attacker);
      attacker.runAction(act);
    }
  },

  /**
   * 普通近战攻击
   * @param {*} attack 
   * @param {*} delay_time 
   * @param {*} hit_fun 
   * @param {*} start_fun 攻击开始动作
   * @param {*} is_reverse 是否是移动到背面
   */
  attack: function attack(attacker, delay_time, hit_fun, start_fun, is_reverse) {
    if (attacker && attacker.anime_user_atk) {
      delay_time = delay_time || 0;
      is_reverse = is_reverse == 1;

      var start_callback = function () {
        this.callfun(attacker, start_fun);
      }.bind(this);

      var hit_callback = function () {
        this.callfun(attacker, hit_fun);
      }.bind(this);

      return this.skill_act.attack(attacker, delay_time, attacker.anime_user_atk, hit_callback, start_callback, is_reverse, null, attacker.anime_res);
    }
  },

  /**
   * 远程攻击子弹
   * @param {*} attacker 
   * @param {*} delay_time 
   * @param {*} move_time 
   * @param {*} is_back 
   * @param {*} funname 
   * @param {*} start_height 
   */
  flyItem: function flyItem(attacker, delay_time, move_time, is_back, funname, start_height) {
    if (this.checkIsInBattle(attacker) == false) {
      return;
    }

    var effect_list = attacker.trc_effect_list; // 这个效果可能有多个,这个时候主要取第一个吧

    if (effect_list == null || effect_list.length == 0) {
      Log.info("播放远程攻击效果失败,不存在远程的效果,效果id为:  " + attacker.play_order_index);
      this.actStart(attacker);
      return;
    }

    var effect_object = effect_list[0]; // 主要第一个

    var is_friend = attacker.is_friend; // 是否是友方

    var res_up = effect_object.res_up; //

    if (is_friend == true && effect_object.spec_res_up != "") {
      res_up = effect_object.spec_res_up;
    }

    var scale = effect_object.scale * 0.001;
    var x_fix = effect_object.x_fix * attacker.obj_type;
    var y_fix = effect_object.y_fix == 0 ? 50 : effect_object.y_fix;
    var anima_name = attacker.anime_user_atk || PlayerAction.action_2;

    var attack_func = function () {
      var target_list = attacker.attacker_info.target_list;

      if (target_list.length <= 1) {
        // 只有一个攻击对象的时候
        var target_pos = this.center_pos(attacker, y_fix);
        return this.item(attacker, delay_time, res_up, move_time, funname, start_height, target_pos, scale, effect_object.bid, x_fix, y_fix);
      } else {
        this.playSelfEffect();
        var act_list = []; // 动作列表

        var array = attacker.attacker_info.target_list;

        for (var index = 0; index < array.length; index++) {
          var element = array[index];
          var target = this.getBattleRoleByPos(element.target);

          if (target) {
            // 目标
            var target_pos = {
              x: target.scene_pos.x,
              y: target.scene_pos.y + y_fix
            };

            if (target.group != attacker.group) {
              var func = this.getItem(attacker, delay_time, res_up, move_time, "hurtOne", start_height, target_pos, scale, effect_object.bid, x_fix, y_fix);
              act_list.push(func);
            }
          }
        } // 关键数据


        var finish_func = cc.callFunc(function () {
          if (attacker.attacker_info.last_effect) {
            for (var _index3 = 0; _index3 < attacker.attacker_info.last_effect.length; _index3++) {
              var _element3 = attacker.attacker_info.last_effect[_index3];

              if (attacker.is_real) {
                this.playMagic(attacker, _element3);
              } else {
                this.hook_model.playMagic(attacker, _element3);
              }
            }
          }
        }.bind(this));

        if (act_list.length > 0) {
          var act_start = this.skill_act.normalStart(attacker);
          var act_finish = this.skill_act.normalFinish(attacker);
          var act = cc.sequence(act_start, cc.spawn.apply(null, act_list), act_finish);
          attacker.runAction(act);
        }
      }
    }.bind(this);

    return this.skill_act.attack(attacker, delay_time, anima_name, null, null, false, attack_func, attacker.anime_res);
  },
  // 渐隐掉的播报
  fadeOut: function fadeOut(attacker, delay_time, time) {
    time = time || 10;
    return this.skill_act.fadeOut(attacker, delay_time, time);
  },
  // 渐现出来
  fadeIn: function fadeIn(attacker, delay_time, time) {
    time = time || 1;
    return this.skill_act.fadeIn(attacker, delay_time, time);
  },
  // 处理友方特效
  playSelfEffect: function playSelfEffect(attacker) {
    if (attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null) return;
    var last_effect = [];
    var target = null;

    for (var index = 0; index < attacker.attacker_info.target_list.length; index++) {
      var element = attacker.attacker_info.target_list[index];
      target = this.getBattleRoleByPos(element.target);

      if (target && attacker.group == target.group) {
        last_effect.push(element);
      }
    }

    attacker.attacker_info.effect_play = last_effect;
    attacker.attacker_info.last_effect = last_effect;
  },
  // 回合播报结束设置施法者战力动作
  resetAttackerStandStatus: function resetAttackerStandStatus(attacker) {
    if (this.battle_scene == null || attacker == null) {
      return;
    }

    var next_round_actor = 0;

    if (this.next_round) {
      next_round_actor = this.next_round.actor;
    }

    if (this.cur_round) {
      this.last_round_actor = this.cur_round.actor;
    }

    if (next_round_actor == 0 || this.cur_round && this.cur_round.actor != next_round_actor) {
      this.skill_act.setAnimation(attacker, PlayerAction.battle_stand, true);
      this.cancleBlackScreen();
      attacker.resetZOrder();
    }
  },

  /**
   * 实例化远程子弹动作
   * @param {*} attacker 
   * @param {*} delay_time 
   * @param {*} effect_name 
   * @param {*} move_time 
   * @param {*} funname 
   * @param {*} start_height 
   * @param {*} target_pos 
   * @param {*} scale 
   * @param {*} bid 
   * @param {*} x_fix 
   * @param {*} y_fix 
   */
  item: function item(attacker, delay_time, effect_name, move_time, funname, start_height, target_pos, scale, bid, x_fix, y_fix) {
    if (attacker == null || this.battle_scene == null) {
      return;
    }

    start_height = (start_height || 0) * attacker.model_height * 0.01;
    move_time = move_time || 10;

    var hit_callback = function () {
      this.callfun(attacker, funname); // 这里暂时注释掉不知道有没有问题
      // if(attacker.attacker_info.target_list.length > 0){
      //     attacker.attacker_info.target_list.unshift();
      // }
    }.bind(this);

    if (!attacker.is_real) {
      hit_callback();
    } else {
      attacker.runAction(this.skill_act.flyItem(attacker, delay_time, effect_name, move_time, hit_callback, start_height, target_pos, scale, bid, x_fix, y_fix));
    }
  },

  /**
   * 获取移动动作
   * @param {*} attacker 
   * @param {*} delay_time 
   * @param {*} effect_name 
   * @param {*} move_time 
   * @param {*} funname 
   * @param {*} start_height 
   * @param {*} target_pos 
   * @param {*} scale 
   * @param {*} bid 
   * @param {*} x_fix 
   * @param {*} y_fix 
   */
  getItem: function getItem(attacker, delay_time, effect_name, move_time, funname, start_height, target_pos, scale, bid, x_fix, y_fix) {
    start_height = start_height || 60;
    move_time = move_time || 10;

    var hit_callback = function () {
      this.callfun(attacker, funname); // 这里暂时注释掉不知道有没有问题
      // if(attacker.attacker_info.target_list.length > 0){
      //     attacker.attacker_info.target_list.unshift();
      // }
    }.bind(this);

    var act = this.skill_act.flyItem(attacker, delay_time, effect_name, move_time, hit_callback, start_height, target_pos, scale, bid, x_fix, y_fix);
    return act;
  },
  // 播报,动作施法者
  playOrder: function playOrder(attacker) {
    if (attacker == null) return;
    if (attacker.wait_act && attacker.wait_act != 0) return; // 没有技能效果的时候,直接移除掉

    if (attacker.play_order_index == null || attacker.play_order_index == 0) return; // 每个动作的计数器,当一个动作开始之后开始计数,为0标识这个动作做完了

    attacker.wait_act = 0;

    if (attacker.play_order == null || attacker.play_order.length == 0) {
      this.actor_play_sum += 1;

      if (!attacker.is_die) {
        this.resetAttackerStandStatus(attacker);
      }

      if (!attacker.is_round) {
        this.act_playing = false;

        if (this.actor_play_sum >= this.actor_sum) {
          this.round();
        }
      }
    } else {
      var index = attacker.play_order.shift();
      var act = this.singleAct(index, attacker);

      if (act) {
        attacker.runAction(act);
      }
    }
  },
  // 处理群攻效果,比如说音效不要播太多
  batchPlayHurt: function batchPlayHurt(attacker) {
    if (attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null) {
      return;
    }

    var target_list = attacker.attacker_info.target_list;

    if (target_list.length == 0) {
      return;
    }

    var had_play = false; // 多个受击音效只需要播放一次

    for (var index = 0; index < target_list.length; index++) {
      var element = target_list[index];

      if (attacker.is_real) {
        var play_effect = false;

        if (element.hp_changed && element.hp_changed < 0 && had_play == false) {
          had_play = true;
          play_effect = true;
        }

        this.playMagic(attacker, element, play_effect);
      } else {
        this.hook_model.playMagic(attacker, element, play_effect);
      }
    }
  },

  /**
   * 播放普通战斗飘字
   * @param {*} target 战斗目标单位
   * @param {*} desc 当前文本
   * @param {*} parent 父节点,如果没有,则默认是战斗场景特效层1
   * @param {*} x x方向的偏移值
   * @param {*} y y方向的偏移值
   * @param {*} color 文字颜色
   * @param {*} outline 文字描边色
   */
  playFontMessage: function playFontMessage(target, desc, parent, x, y, color, outline, callback) {
    if (this.checkIsInBattle(target) == false) {
      return;
    }

    if (parent == null) {
      parent = this.battle_scene.getBattleEffectLayer(1); // 默认放在特效1层上面
    }

    x = x || 0;
    y = y || 0;
    var target_x = target.scene_pos.x + x;
    var target_y = target.scene_pos.y + y + target.model_height / 2;

    if (color == null) {
      color = 217;
    }

    if (outline == null) {
      outline = 218;
    } // 设置字体默认颜色


    var normal_node = this.getNormalFont();
    normal_node.setPosition(target_x, target_y);
    var font_node = normal_node.getChildByName("font_label");
    var hex = Config.color_data.data_color16[color];
    var _color = font_node.color;

    _color.fromHEX(hex);

    font_node.color = _color; // 设置描边颜色

    var out_hex = Config.color_data.data_color16[outline];
    var out_line = font_node.getComponent(cc.LabelOutline);
    var _color1 = out_line.color;

    _color1.fromHEX(out_hex);

    out_line.color = _color1; // 设置字体

    var label = font_node.getComponent(cc.Label);
    label.string = desc;
    parent.addChild(normal_node);

    if (target.buff_show_index == null) {
      target.buff_show_index = 0;
    }

    target.buff_show_index = target.buff_show_index + 1;
    var show = cc.show();
    var delay = cc.delayTime(0.3 * target.buff_show_index);
    var delay_over = cc.callFunc(function () {
      target.buff_show_index -= 1;
    }.bind(this));
    var scale_to_1 = cc.scaleTo(0.4, 1.2);
    var move_by_1 = cc.moveBy(0.4, 0, 50);
    var fade_in = cc.fadeIn(0.4);
    var scale_to_2 = cc.scaleTo(0.6, 0.9);
    var fade_out = cc.fadeOut(0.6);
    var move_by_2 = cc.moveBy(0.6, 0, 25);
    var hide = cc.hide();
    normal_node.runAction(cc.sequence(show, delay, delay_over, cc.spawn(scale_to_1, move_by_1, fade_in), cc.spawn(scale_to_2, fade_out, move_by_2), hide, cc.callFunc(function () {
      if (callback) {
        callback();
      }

      this.pushBackBattleFont(normal_node);
    }.bind(this))));
  },

  /**
   * 播放魔法特效
   * @param {*} attacker 
   * @param {*} effect_play 
   * @param {*} no_die 
   * @param {*} play_effect 
   */
  playMagic: function playMagic(attacker, effect_play, play_effect) {
    if (this.battle_scene == null) {
      return;
    }

    if (effect_play.target == null) {
      return;
    }

    if (attacker == null) {
      return;
    }

    if (effect_play.play_num != null && effect_play.play_num <= 0) {
      return;
    }

    if (effect_play.play_num == null && attacker.split_hurt) {
      effect_play.play_num = attacker.split_hurt || 1;

      if (effect_play.play_num > 1) {
        effect_play.avg_hp_changed = Math.ceil(effect_play.hp_changed / effect_play.play_num);
      }
    }

    effect_play.play_num = effect_play.play_num || 1;
    effect_play.play_num -= 1;
    var effect_hit = 1;
    var target = this.getBattleRoleByPos(effect_play.target);

    if (target) {
      if (effect_play.is_hit == 0 || effect_play.is_blind == 1) {
        // 闪躲或者未命中
        effect_hit = 0;
        var desc = Utils.TI18N("闪躲");

        if (effect_play.is_blind == 1) {
          desc = Utils.TI18N("未命中");
        }

        if (effect_play.is_dead == 0) {
          // 非死亡情况下才飘字
          this.playFontMessage(target, desc, null, null, null, 227, 228);
        }
      }

      var hp_changed = effect_play.avg_hp_changed || effect_play.hp_changed || 0;
      var dmg = Math.floor(hp_changed);

      if (effect_play.is_crit == 1) {
        // 暴击
        effect_hit = 2;
      }

      var is_dead = effect_play.is_dead;

      if (effect_play.play_num > 0) {
        // 多次伤害的话第一次不能死
        is_dead = 0;
      } // 处理召唤列表


      if (effect_play.summon_list.length > 0) {
        this.addRoleList(effect_play.summon_list, attacker);
      } // 处理子效果


      if (effect_play.sub_effect_play_list.length > 0) {
        this.handleSubEffectPlaylist(effect_play, attacker);
      } // 副本中需要的特殊处理


      this.handleExtendDungeon(effect_play); // 处理援护

      if (effect_play.aid_actor != 0) {
        this.handleAidActor(effect_play, attacker, effect_hit, target);
      } // 播放受击处理


      this.playBattleRoleHurt(attacker, target, dmg, play_effect); // 飘字处理

      if (attacker.effect_desc != "" && effect_play.is_hit != 0 && effect_play.play_num <= 0) {
        this.showbuffName(target, attacker.effect_desc, 229, 230, attacker.play_order_index);
      } // 把扣血放到最后,因为有死亡动作


      this.updateTargetHp(attacker, target, dmg, is_dead, effect_hit, effect_play); // 处理buff列表,非死亡的时候才处理,如果上面播报已经说死了,不需要处理buff了

      if (effect_play.play_num <= 0 && effect_play.buff_list.length > 0) {
        this.handleBufflist(attacker, effect_play.buff_list, 1);
      }
    }
  },
  // 播放受击处理
  playBattleRoleHurt: function playBattleRoleHurt(attacker, target, dmg, play_effect) {
    if (attacker == null || target == null) return;
    if (target.is_hurt_play == true) return;
    target.is_hurt_play = true;

    if (!target.is_big_play) {
      target.is_big_play = true;
      this.playHurtEffect(attacker, target);
    }

    if (attacker.pos != target.pos && dmg < 0 && attacker.group != target.group) {
      // 播放受击动作
      if (attacker.hit_action != "no-hurt") {
        this.skill_act.hurt(attacker, target, attacker.hit_action, play_effect);
      }
    }
  },

  /**
   * 更新血条处理
   * @param {*} attacker 
   * @param {*} target 
   * @param {*} dmg 
   * @param {*} is_die 
   * @param {*} effect_hit 1是是普通, 2是暴击
   * @param {*} is_yuanhu 
   * @param {*} is_normal 
   * @param {*} effect_play 
   */
  updateTargetHp: function updateTargetHp(attacker, target, dmg, is_die, effect_hit, effect_play) {
    if (target == null) return;
    if (attacker == null) return;
    if (dmg == 0) return;
    effect_hit = effect_hit || 1;
    this.mutiHurtNum(target, dmg, effect_hit, false, effect_play.camp_restrain); // 储存具体数据

    target.updateHP(dmg, is_die, false, attacker.is_must_die);
  },

  /**
   * 播放伤害飘血
   * @param {*} tatget 
   * @param {*} dmg 
   * @param {*} effect_hit 1是是普通, 2是暴击
   * @param {*} is_normal 
   * @param {*} is_buff 
   * @param {*} camp_restrain 
   */
  mutiHurtNum: function mutiHurtNum(target, dmg, effect_hit, is_buff, camp_restrain) {
    if (this.checkIsInBattle(target) == false || dmg == 0 || target.is_real == false) {
      return;
    } // 这个数值用于处理飘血高度的...放置叠加到一起


    if (target.dmg_index == null) {
      target.dmg_index = 0;
    }

    target.dmg_index += 1;
    this.skill_act.playDmgMessage(target, dmg, effect_hit, is_buff, camp_restrain);
  },

  /**
   * 处理buff效果
   * @param {*} attacker 
   * @param {*} list 
   * @param {*} effect_hit 是否是暴击
   */
  handleBufflist: function handleBufflist(attacker, list, effect_hit) {
    if (this.checkIsInBattle(attacker) == false) {
      return;
    }

    for (var index = 0; index < list.length; index++) {
      var buff = list[index];
      var target = this.getBattleRoleByPos(buff.target);

      if (target) {
        this.playRoundBuff(target, buff, attacker, effect_hit);
      }
    }
  },

  /**
   * 添加一个buf
   * @param {*} attacker buff的发起者.可能没有
   * @param {*} target 
   * @param {*} buff 
   */
  addBuff: function addBuff(attacker, target, buff) {
    if (target == null || buff == null) return;
    var buff_data = Config.skill_data.data_get_buff[buff.buff_bid];
    if (buff_data == null) return;

    if (buff_data.is_passive == 1) {
      this.playBuffEffect(attacker, target, buff, buff_data);
    }

    if (buff.action_type == 4) return;

    if (buff.action_type == 2) {
      this.removeBuff(target, buff, buff_data);
    } else {
      if (buff_data.is_passive == 1 || buff_data.group == 3211) {
        // 不可复活组的buff额外处理
        if (buff.action_type == 1 || buff.action_type == 3) {
          // 主处理新增或者是展示的buff
          if (buff_data.group != 3211) {
            if (buff_data.buff_spine && buff_data.buff_data != "") {
              // 存在变身的buff
              target.changeSpine(true, buff_data.buff_spine, PlayerAction.battle_stand);
            }

            if (buff_data.group == 3703) {
              // 隐身buff
              target.setOpacity(true, 155);
            }
          }

          if (buff.action_type == 1 && buff.remain_round != 0) {
            // 新增buff才处理,这里主要是开始增加血条下面的bufficon
            target.updateBuffList(buff, buff_data);
          }
        }
      }
    }
  },
  // 移除一个buff,包含移除一个对象的特效和移除一个buff图标
  removeBuff: function removeBuff(target, buff, buff_data) {
    if (this.getBattleScene() == null || target == null) return;
    if (buff == null || buff_data == null) return;
    var had_buff = target.hadBuff(buff.id);

    if (had_buff == true) {
      target.removeBuffList(buff.id); // 移除一个buff,并且包含移除buff图标

      if (buff_data.group == 3703) {
        // 隐身buff
        target.setOpacity(false);
      }

      if (buff_data.buff_spine && buff_data.buff_spine != "") {
        // 移除变身效果
        target.changeSpine(false);
      } // 如果是场景buff,则移除


      var effect_config = Config.skill_data.data_get_effect_data[buff_data.res];

      if (effect_config && effect_config.play_type == BattleConst.Effect_Play_Type.ROLE_SCENE) {
        this.removeSceneBuffEffect(target.group, effect_config.bid);
      } // 移除buff存在的特效绑在自身上的


      if (effect_config) {
        this.removeBattleSpineEffect(target, effect_config);
      }
    }
  },
  // 添加一个场景buff特效
  addSceneBuffEffect: function addSceneBuffEffect(group, bid, effect_res, effect) {
    if (group == null || bid == null || effect_res == null || effect == null) return;
    var key = Utils.getNorKey(group, bid);

    if (this.scene_buff_effect_list[key] == null) {
      this.scene_buff_effect_list[key] = {};
    } // 如果存在的话,先丢到对象池里面去


    if (this.scene_buff_effect_list[key][effect_res]) {
      this.delBattleEffect(this.scene_buff_effect_list[key][effect_res]);
    }

    this.scene_buff_effect_list[key][effect_res] = effect;
  },
  // 移除一个场景buff特效
  removeSceneBuffEffect: function removeSceneBuffEffect(group, effect_bid) {
    if (group == null || effect_bid == null) {
      if (this.scene_buff_effect_list) {
        for (var key in this.scene_buff_effect_list) {
          for (var res in this.scene_buff_effect_list[key]) {
            var effect = this.scene_buff_effect_list[key][res];
            this.delBattleEffect(this.scene_buff_effect_list[key][effect]);
          }
        }

        this.scene_buff_effect_list = {};
      }
    } else {
      var key = Utils.getNorKey(group, effect_bid);
      var effect_list = this.scene_buff_effect_list[key];

      if (effect_list) {
        for (var key in effect_list) {
          this.delBattleEffect(effect_list[key]);
        }
      }

      this.scene_buff_effect_list[key] = null;
    }
  },
  // 移除一个绑在单位身上的buff特效,这里会根据特效配置去判断上下层特效资源
  removeBattleSpineEffect: function removeBattleSpineEffect(target, effect_config) {
    if (target == null || effect_config == null) return;
    var action_name = PlayerAction.action;

    if (effect_config.up_action_name != "") {
      action_name = effect_config.up_action_name;
    }

    target.delBattleEffect(effect_config.res_up, action_name); // 移除上层特效

    action_name = PlayerAction.action;

    if (effect_config.down_action_name != "") {
      action_name = effect_config.down_action_name;
    }

    target.delBattleEffect(effect_config.res_down, action_name); // 移除下层特效
  },
  // 播放buff效果,以及添加bufficon等
  playBuffEffect: function playBuffEffect(attacker, target, buff, buff_data) {
    if (buff == null || buff_data == null) return;
    var text_color = null;
    var outline_color = null;

    if (buff_data.client_desc != "") {
      if (buff.action_type == 1 || buff.action_type == 4) {
        // 增益
        if (buff_data.positive_or_negative == 1) {
          text_color = 221;
          outline_color = 222;
        } else if (buff_data.positive_or_negative == 2) {
          // 减益
          text_color = 223;
          outline_color = 224;
        } else if (buff_data.positive_or_negative == 3) {
          // 控制
          text_color = 225;
          outline_color = 226;
        }

        this.showbuffName(target, buff_data.client_desc, text_color, outline_color, buff.buff_bid);
      }
    }

    if (attacker == null) return;
    var hadbuff = target.hadBuff(buff.id);

    if (!hadbuff && buff.action_type == 1 && buff_data.res != 0) {
      // 不存在的buff才需要处理
      var config = Config.skill_data.data_get_effect_data[buff_data.res];

      if (config) {
        if (config.play_type == BattleConst.Effect_Play_Type.ROLE_SCENE) {
          var key = Utils.getNorKey(target.group, buff_data.res);

          if (this.scene_buff_effect_list[key] == null || Utils.next(this.scene_buff_effect_list[key]) == false) {
            this.effectArea(attacker, [config.res_up, config.res_down], 0, null, config.play_type, config.x_fix, config.y_fix, buff_data.res, config.is_col_effect, false);
          }
        } else {
          this.effectSpineUser(attacker, buff_data.is_release == 1, config.x_fix * target.obj_type, config.y_fix, [config.res_up, config.res_down], target, 1, null, buff_data.bid, buff_data.res);
        }
      }
    } // 一次效果


    if (buff.action_type == 3 && buff_data.efftive_effect != 0) {
      var config = Config.skill_data.data_get_effect_data[buff_data.efftive_effect];

      if (config) {
        this.effectSpineUser(attacker, true, config.x_fix * target.obj_type, config.y_fix, [config.res_up, config.res_down], target, 1, null, buff_data.bid, buff_data.res);
      }
    }
  },
  // 播放buff描述文字,这里需要对这个对象做判断,如果bid的飘字存在,则不处理了...
  showbuffName: function showbuffName(target, desc, color, outline_color, bid) {
    if (target == null || bid == null) return;
    if (target.tips_list[bid]) return;
    target.addTips(bid);

    var callback = function () {
      target.removeTips(bid);
    }.bind(this);

    this.playFontMessage(target, desc, null, null, null, color, outline_color, callback);
  },

  /**
   * 添加召唤列表
   * @param {*} list 
   * @param {*} attacker 
   */
  addRoleList: function addRoleList(list, attacker) {
    if (list == null || list.length == 0) return;
  },

  /**
   * 处理子效果
   * @param {*} effect_play 
   * @param {*} attacker 
   */
  handleSubEffectPlaylist: function handleSubEffectPlaylist(effect_play, attacker) {
    if (effect_play == null || effect_play.sub_effect_play_list == null || effect_play.sub_effect_play_list.length == 0) return;

    for (var index = 0; index < effect_play.sub_effect_play_list.length; index++) {
      var element = effect_play.sub_effect_play_list[index];
      var sub_target = this.real_role_list[element.sub_target];

      if (sub_target) {
        // 播放气血变化的
        this.battleRoleHPChange(sub_target, element.sub_hp_changed, false, 1, true);

        if (element.extra_effect && element.extra_effect.length > 0) {
          for (var n = 0; n < element.extra_effect.length; n++) {
            var extra = element.extra_effect[n];

            if (extra.extra_key == 2) {
              // 护盾吸收
              this.skill_act.playBuffAbsorbHurt(sub_target, extra.extra_param);
            }
          }
        } // 技能效果是否飘字


        var effect_config = gdata('skill_data', 'data_get_effect', element.sub_effect_id);

        if (effect_config && effect_config.effect_desc != "" && element.sub_is_hit != 0) {
          this.showbuffName(sub_target, effect_config.effect_desc, 229, 230, element.sub_effect_id);
        } // 被动技能是否飘字


        var skill_config = gdata('skill_data', 'data_get_skill', element.sub_skill_id);

        if (skill_config && skill_config.passive_skill_show == 1) {
          this.showbuffName(sub_target, skill_config.name, 217, 218, element.sub_skill_id);
        } // 闪躲处理


        if (element.sub_is_hit == 0 && effect_play.is_dead == 0) {
          this.showbuffName(sub_target, Utils.TI18N("躲闪"), 227, 228, element.sub_effect_id);
        }
      }
    }
  },

  /**
   * 副本数据特殊处理
   * @param {*} effect_play 
   */
  handleExtendDungeon: function handleExtendDungeon(effect_play) {
    if (this.battle_data == null || this.battle_data.combat_type != BattleConst.Fight_Type.GuildDun) return;

    if (this.form_fight_ui) {
      this.form_fight_ui.addGuildBossUI(effect_play.total_hurt);
    }
  },

  /**
   * 处理援护
   * @param {*} effect_play 
   * @param {*} attacker 
   * @param {*} effect_hit 是否暴击
   * @param {*} target
   */
  handleAidActor: function handleAidActor(effect_play, attacker, effect_hit, target) {
    if (effect_play == null || effect_play.aid_actor == 0) return;
    var aid_target = this.real_role_list[effect_play.aid_actor];

    if (aid_target) {
      var aid_dmg = effect_play.actor_hp_changed; // 援护者血量变化

      var friend_pos = target.scene_pos; // 

      var role_width = target.model_width * target.obj_type;
      var camp_restrain = effect_play.camp_restrain; // 是否是阵营压制

      aid_target.setLocalZOrder(target.getLocalZOrder() + 1); // 层级放到上面来

      aid_target.setScenePos(cc.v2(friend_pos.x + role_width, friend_pos.y)); // 设置援护坐标

      this.actStart(attacker);
      this.skill_act.aid_hurt(attacker, aid_target, "hurt");
      this.battleRoleHPChange(aid_target, aid_dmg, effect_play.actor_is_dead, effect_hit, false, camp_restrain);
      this.playHurtEffect(attacker, aid_target);
    }
  },

  /**
   * 播放伤害特效
   * @param {*} attacker 
   * @param {*} target 
   */
  playHurtEffect: function playHurtEffect(attacker, target) {
    if (this.battle_scene == null || attacker == null || attacker.hit_effect_list == null || attacker.hit_effect_list.length == 0) {
      return;
    }

    var array = attacker.hit_effect_list;

    for (var index = 0; index < array.length; index++) {
      var element = array[index];
      this.effectSpineUser(attacker, true, element.x_fix * attacker.obj_type, element.y_fix, [element.res_up, element.res_down], target, element.scale * 0.001, null, element.bid);
    }
  },

  /**
   * 出手前动作
   * @param {*} attacker 
   */
  attackReady: function attackReady(attacker) {
    if (attacker == null) {
      return;
    }

    if (attacker.bact_effect_list == null || attacker.bact_effect_list.length == 0) {
      return;
    } // 播放出手前音效


    if (attacker.ready_sound && attacker.ready_sound != "" && attacker.is_real == true) {
      Utils.playEffectSound(AUDIO_TYPE.BATTLE, attacker.ready_sound);
    }

    var array = attacker.bact_effect_list;

    for (var index = 0; index < array.length; index++) {
      var element = array[index];

      if (element && element.play_type == BattleConst.Effect_Play_Type.ROLE) {
        if (element.res_up != "" || element.res_down != "") {
          this.effectSpineUser(attacker, true, element.x_fix * attacker.obj_type, element.y_fix, [element.res_up, element.res_down], attacker, element.scale * 0.001, null, element.bid);
        }
      }
    }
  },

  /**
   * 创建单位跟随特效
   * @param {*} attacker 
   * @param {*} is_release 
   * @param {*} x_fix 
   * @param {*} height 
   * @param {*} effect_list
   * @param {*} target 目标对象,也可能是自己,也可能是被攻击者 
   * @param {*} scale 
   * @param {*} callback 
   * @param {*} bid 
   * @param {*} buff_bid 如果这个值不为0,即最终值
   */
  effectSpineUser: function effectSpineUser(attacker, is_release, x_fix, height, effect_list, target, scale, callback, bid, buff_bid) {
    if (buff_bid && buff_bid != 0) {
      bid = buff_bid;
    }

    var obj_type = BattleConst.Battle_Type_Conf.TYPE_ROLE;

    if (attacker) {
      obj_type = attacker.obj_type;
    }

    this.skill_act.effectSpineUser(attacker, is_release, x_fix, height, effect_list, target, scale, callback, bid, obj_type);
  },
  // 群攻
  areaHurt: function areaHurt(attacker) {
    var hurt_func = function () {
      if (this.battle_scene) {
        var role_list = this.getAllBattleRoleList();

        for (var key in role_list) {
          var role = role_list[key];

          if (role) {
            role.is_hurt_play = false;
            role.is_big_play = false;
          }
        }
      }

      this.batchPlayHurt(attacker);
    }.bind(this);

    this.playSceneAreaEffect(attacker, hurt_func);
  },
  // 播放范围特效
  playSceneAreaEffect: function playSceneAreaEffect(attacker, callback) {
    if (attacker == null || attacker.play_order_index == null || attacker.area_effect_list == null || attacker.area_effect_list.length == 0) {
      return;
    }

    var array = attacker.area_effect_list;

    for (var index = 0; index < array.length; index++) {
      var element = array[index];

      if (element && (element.res_down != "" || element.res_up != "")) {
        this.effectArea(attacker, [element.res_up, element.res_down], 0, callback, element.play_type, element.x_fix, element.y_fix, element.bid, element.is_col_effect);
      }
    }
  },

  /**
   * 播放范围特效
   * @param {*} attacker 
   * @param {*} effect_list
   * @param {*} height 
   * @param {*} is_reverse 
   * @param {*} hit_callback 
   * @param {*} play_type 
   * @param {*} x_fix 
   * @param {*} y_fix 
   * @param {*} bid 
   * @param {*} is_col_effect
   * @param {*} is_release 播完是否释放
   */
  effectArea: function effectArea(attacker, effect_list, height, hit_callback, play_type, x_fix, y_fix, bid, is_col_effect, is_release) {
    height = height || 0;
    var reverse = attacker.obj_type;
    var is_left = attacker.is_friend;
    var scene_pos = null;

    if (is_col_effect == 1) {
      var temp_list = null;

      if (is_left) {
        temp_list = [{
          x: 34,
          y: 17
        }, {
          x: 34,
          y: 23
        }, {
          x: 34,
          y: 29
        }];
      } else {
        temp_list = [{
          x: 44,
          y: 17
        }, {
          x: 44,
          y: 23
        }, {
          x: 44,
          y: 29
        }];
      }

      var pos = temp_list[attacker.col];

      if (pos) {
        var temp_pos = this.skill_act.gridPosToScreenPos(pos);
        scene_pos = {
          x: temp_pos.x + x_fix,
          y: temp_pos.y + y_fix
        };
      }
    } else {
      if (play_type == BattleConst.Effect_Play_Type.SCENE) {
        // 暂时看到是作废的
        scene_pos = {
          x: SCREEN_WIDTH * 0.5,
          y: SCREEN_HEIGHT * 0.5
        };
      } else if (play_type == BattleConst.Effect_Play_Type.ROLE_SCENE || play_type == BattleConst.Effect_Play_Type.ENEMY_SCENE) {
        x_fix = attacker.obj_type * x_fix;

        if (is_left) {
          if (play_type == BattleConst.Effect_Play_Type.ROLE_SCENE) {
            //  友方阵型
            scene_pos = {
              x: SCREEN_WIDTH * 22 / 100 + x_fix,
              y: SCREEN_HEIGHT * 1 / 4 + y_fix
            };
          } else {
            // 敌方阵型
            scene_pos = {
              x: SCREEN_WIDTH * 78 / 100 + x_fix,
              y: SCREEN_HEIGHT * 1 / 4 + y_fix
            };
          }
        } else {
          if (play_type == BattleConst.Effect_Play_Type.ENEMY_SCENE) {
            scene_pos = {
              x: SCREEN_WIDTH * 22 / 100 + x_fix,
              y: SCREEN_HEIGHT * 1 / 4 + y_fix
            };
          } else {
            scene_pos = {
              x: SCREEN_WIDTH * 78 / 100 + x_fix,
              y: SCREEN_HEIGHT * 1 / 4 + y_fix
            };
          }
        }
      } else {
        scene_pos = this.center_pos(attacker);
      }
    }

    if (scene_pos) {
      scene_pos.y = scene_pos.y + height;
      this.skill_act.effectArea(attacker, effect_list, reverse, is_release, scene_pos, hit_callback, bid);
    }
  },
  // 获取施法者目标对象的中心位置
  center_pos: function center_pos(attacker, height_fix) {
    height_fix = height_fix || 0;
    var scene_pos = {
      x: 0,
      y: 0
    };

    if (this.battle_scene && attacker && attacker.attacker_info && attacker.attacker_info.target_list && attacker.attacker_info.target_list.length > 0) {
      var array = attacker.attacker_info.target_list;

      for (var index = 0; index < array.length; index++) {
        var element = array[index];
        var target = this.getBattleRoleByPos(element.target);

        if (target && target.scene_pos) {
          scene_pos.x = target.scene_pos.x;
          scene_pos.y = target.scene_pos.y + target.model_height * height_fix * 0.01; // 这个计算位置好奇葩..竟然不是直接用偏移高度去算..

          break;
        }
      }
    }

    return scene_pos;
  },
  // 播放攻击动作之类的
  actHurt: function actHurt(attacker, is_big) {
    if (attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null) return;
    var had_play = false;

    for (var index = 0; index < attacker.attacker_info.target_list.length; index++) {
      var effect_list = attacker.attacker_info.target_list[index];
      var play_effect = false;

      if (effect_list.hp_changed && effect_list.hp_changed < 0 && had_play == false) {
        had_play = true;
        play_effect = true;
      }

      this.playMagic2(attacker, effect_list, is_big, play_effect);
    }
  },
  // 提前播放受击特效,回播受击动作
  playMagic2: function playMagic2(attacker, effect_play, is_big, play_effect) {
    if (attacker == null || effect_play == null) return;
    var target = this.real_role_list[effect_play.target];
    if (target == null) return;

    if (is_big == true) {
      if (!target.is_big_play) {
        target.is_big_play = true;
        this.playHurtEffect(attacker, target);
      }
    } else {
      if (attacker.pos != target.pos && attacker.group != target.group) {
        this.skill_act.hurt(attacker, target, PlayerAction.hurt, play_effect);
      }
    }
  },
  // 攻击上层特效处理
  attackPoint: function attackPoint(attacker) {
    if (attacker && attacker.attack_sound != "" && attacker.is_real == true) {
      Utils.playEffectSound(AUDIO_TYPE.BATTLE, attacker.attack_sound);
    }

    if (attacker.act_effect_list == null || attacker.act_effect_list.length == 0) {
      return;
    }

    var is_friend = attacker.is_friend;
    var array = attacker.act_effect_list;

    for (var index = 0; index < array.length; index++) {
      var element = array[index];
      var anime_res_up = element.res_up;

      if (element.spec_res_up != "" && is_friend == true) {
        anime_res_up = element.spec_res_up;
      }

      if (anime_res_up != "" || element.res_down != "") {
        this.effectSpineUser(attacker, true, element.x_fix * attacker.obj_type, element.y_fix, [anime_res_up, element.res_down], attacker, element.scale * 0.001, null, element.bid);
      }
    }
  },

  /**
   * 处理普通伤害
   * @param {*} attacker 
   * @param {*} role_list 
   */
  hurt: function hurt(attacker, object_list) {
    if (this.battle_scene == null || attacker == null) {
      return;
    }

    if (attacker.area_effect_list.length == 0) {
      var hit_num = !attacker.in_area_effect ? attacker.hit_num : attacker.area_hit_num || 1;
      var split_hurt = attacker.split_hurt || 1;

      if (hit_num == 1 || split_hurt > 1) {} else {
        var role_list = object_list || this.getAllBattleRoleList();

        for (var key in role_list) {
          var role = role_list[key];

          if (role) {
            role.is_hurt_play = false;
            role.is_big_play = false;
          }
        }
      }

      this.batchPlayHurt(attacker);
    }
  },

  /**
   * 伤害一个人的时候
   * @param {*} attacker 
   */
  hurtOne: function hurtOne(attacker) {
    if (this.checkIsInBattle(attacker) == false) {
      return;
    }

    var effect_play_num = attacker.attacker_info.target_list.length;

    if (effect_play_num > 0) {
      if (attacker.is_real) {
        this.playMagic(attacker, attacker.attacker_info.target_list[0]);
      } else {
        this.hook_model.playMagic(attacker, attacker.attacker_info.target_list[0]);
      }
    }
  },
  // 隐藏血条
  hideUI: function hideUI(attacker, delay_time) {
    if (attacker) {
      return this.skill_act.hideUI(attacker, delay_time);
    }
  },
  // 无动作并行攻击
  noActAttack: function noActAttack(attacker, delay_time, hit_fun, start_fun, next_delay_time) {
    if (!this.getBattleScene()) return;
    if (!attacker) return;

    var start_callback = function () {
      this.callfun(attacker, start_fun);
    }.bind(this);

    var hit_callback = function () {
      this.callfun(attacker, hit_fun);
    }.bind(this);

    return this.skill_act.noActAttack(attacker, delay_time, hit_callback, start_callback, next_delay_time);
  },
  // 显示血条
  showUI: function showUI(attacker, delay_time) {
    if (attacker) {
      return this.skill_act.showUI(attacker, delay_time);
    }
  },
  // 判断是否存在反击buff
  getBuffTag: function getBuffTag(attacker) {
    if (attacker == null || attacker.buff_list == null || attacker.buff_list.length == null) {
      return false;
    }

    var array = attacker.buff_list;

    for (var index = 0; index < array.length; index++) {
      var element = array[index];
      var config = Config.skill_data.data_get_buff[element.bid];

      if (config && config.group == 3108) {
        return true;
      }
    }

    return false;
  },
  // 近战移动归位
  moveBack: function moveBack(attacker, delay_time, move_time, grid_pos_x, action_name, is_jump, is_jump_delay, is_get_point, is_move, is_reverse) {
    if (!this.getBattleScene()) return;
    if (!attacker) return;
    var target_pos = attacker.scene_pos;
    var skill_act = this.skill_act.move(attacker, target_pos, delay_time, move_time);
    attacker.runAction(skill_act);
  },
  // 移动到指定区域
  moveToArea: function moveToArea(attacker, config) {
    if (!this.getBattleScene()) return;
    if (!attacker) return;
    if (!config) return;
    var grid_pos_x = config.move_model_x * this.skill_act.gridSizeX();
    var grid_pos_y = config.move_model_y * this.skill_act.gridSizeY();
    var target_pos = {
      x: SCREEN_WIDTH * 32 / 64 + grid_pos_x * attacker.obj_type,
      y: SCREEN_HEIGHT * 11 / 36 + grid_pos_y
    };
    var skill_act = this.skill_act.move(attacker, target_pos, config.move_delay_time, config.move_time);
    attacker.runAction(skill_act);
  },
  // act_args={ [[moveTo]],{ 0, 10,- 7, 0, [[run]], 0, 0, 0, 1, 1}}},
  // 移动到目标处
  moveTo: function moveTo(attacker, delay_time, move_time, grid_pos_x, grid_pos_y, action_name, is_jump, is_jump_delay, is_get_point, is_move, is_reverse, is_col_act) {
    if (!this.getBattleScene()) return;
    if (!attacker) return;
    move_time = move_time || 30;

    if (grid_pos_x == null) {
      grid_pos_x = 0;
    }

    if (grid_pos_y == null) {
      grid_pos_y = 0;
    }

    var direct = is_reverse == 1 ? -1 : 1;
    var target_pos = null;
    var scene_pos = attacker.scene_pos;

    if (is_col_act == 1) {
      var is_left = attacker.is_friend; // 是否是己方,己方就是在左边

      var temp_list = null;

      if (is_left) {
        temp_list = [{
          x: 34,
          y: 17
        }, {
          x: 34,
          y: 23
        }, {
          x: 34,
          y: 29
        }];
      } else {
        temp_list = [{
          x: 44,
          y: 17
        }, {
          x: 44,
          y: 23
        }, {
          x: 44,
          y: 29
        }];
      }

      var pos = temp_list[attacker.col];

      if (pos) {
        var temp_pos = this.skill_act.gridPosToScreenPos(pos);
        target_pos = {
          x: temp_pos.x + grid_pos_x,
          y: temp_pos.y + grid_pos_y
        };
      }
    } else if (grid_pos_x > 0) {
      target_pos = {
        x: scene_pos.x + grid_pos_x * attacker.obj_type * direct,
        y: scene_pos.y + grid_pos_y
      };
    } else {
      if (is_reverse == 1 && attacker.target_pos_base) {
        // 反转
        target_pos = this.skill_act.gridPosToScreenPos({
          x: attacker.target_pos_base.x + grid_pos_x * attacker.obj_type * direct,
          y: attacker.target_pos_base.y + grid_pos_y * attacker.obj_type * direct
        });
      } else {
        target_pos = this.skill_act.gridPosToScreenPos({
          x: attacker.target_pos.x + grid_pos_x * attacker.obj_type * direct,
          y: attacker.target_pos.y + grid_pos_y
        });
      }
    }

    if (is_get_point == null || is_get_point == 0) {
      var skill_act = this.skill_act.move(attacker, target_pos, delay_time, move_time);
      attacker.runAction(skill_act);
    } else {
      return this.skill_act.move(attacker, target_pos, delay_time, move_time);
    }
  },
  // 一些播报判断
  checkIsInBattle: function checkIsInBattle(attacker) {
    if (this.battle_scene == null || attacker == null) {
      return false;
    }

    return true;
  },
  // -------------------------------创景单位这一块,真是战斗单位
  createRoleList: function createRoleList() {
    var battle_data = this.battle_data;
    var need_enter = this.needPlayEnterAction();

    for (var key in battle_data.fight_object_list) {
      var role_data = battle_data.fight_object_list[key];
      this.createRole(role_data, need_enter, true, true);
    }
  },
  // 创建具体单位
  createRole: function createRole(role_data, enter_run, talk_back, is_real) {
    if (this.battle_scene == null) return;
    if (role_data == null || role_data.hp == 0) return;
    var role_layer = this.battle_scene.getBattleRoleLayer();
    if (role_layer == null) return;
    if (this.real_role_list[role_data.pos] != null) return;
    var role = Utils.createClass("battle_role");
    role.createRole(role_layer, role_data, enter_run, talk_back, is_real);
    this.real_role_list[role_data.pos] = role;
  },
  // 重置战斗单位初始化信息,比如位置层级和动作状态
  resetBattleRoleBaseInfo: function resetBattleRoleBaseInfo() {
    for (var key in this.real_role_list) {
      var battle_role = this.real_role_list[key];

      if (battle_role) {
        battle_role.resetBaseInfo();
      }
    }
  },
  // 清楚掉单位
  clearRealRole: function clearRealRole() {
    if (Object.keys(this.real_role_list).length == 0) {
      return;
    }

    for (var key in this.real_role_list) {
      // 清楚掉定时器
      gcore.Timer.del("attackerActTimeout" + key);
      var battle_role = this.real_role_list[key];

      if (battle_role) {
        battle_role.deleteRole();
        battle_role = null;
      }
    }

    this.real_role_list = {};
  },
  // 当前所有单位
  getAllBattleRoleList: function getAllBattleRoleList() {
    return this.real_role_list;
  },
  // 指定单位上的对象
  getBattleRoleByPos: function getBattleRoleByPos(pos) {
    if (this.real_role_list[pos]) {
      return this.real_role_list[pos];
    }
  },
  // 魅魔技能黑屏,暂时也没配置了
  blackScreen: function blackScreen(attacker) {},
  // 只显示攻击于被攻击放,暂时都没有配置
  blackScreen2: function blackScreen2(attacker) {},
  // 黑屏------后续一律使用这个黑屏
  blackScreen3: function blackScreen3(attacker, delay_time, time, alpha) {
    if (time == null) {
      time = 15;
    }

    var begin_fun = function () {
      if (this.battle_scene) {
        this.battle_scene.setBlack(true, alpha);
      }

      this.is_black = true;
    }.bind(this);

    var end_fun = function () {}.bind(this);

    return this.skill_act.blackScreen(attacker, delay_time, time, begin_fun, end_fun);
  },
  // 取消黑屏
  cancleBlackScreen: function cancleBlackScreen() {
    this.is_black = false;

    if (this.battle_scene) {
      this.battle_scene.setBlack(false);
    }
  },
  // 震屏
  playShakeScreen: function playShakeScreen(shake_id) {
    if (shake_id == null || shake_id == 0) return;

    if (this.battle_scene) {
      this.battle_scene.shakeScreen(shake_id);
    }
  },
  // 隐身,暂时没有配置了
  hide: function hide(attacker) {},
  // 显示,暂时也没有配置了
  show: function show(attacker) {},
  // 残影,也是没有配置了
  shadow: function shadow(attacker) {},
  // 返回主界面控制器
  getMainUICtrl: function getMainUICtrl() {
    if (this.mainui_ctrl == null) {
      this.mainui_ctrl = require("mainui_controller").getInstance();
    }

    return this.mainui_ctrl;
  },
  // -------------------------战斗结束
  //结算界面
  showWin: function showWin(data, is_replay) {
    if (data.show_panel_type == null || data.combat_type == null) return;

    if (data.show_panel_type == 1) {
      // 显示战斗结算界面,这个时候不要立即清除掉,
      if (data.combat_type == this.combat_type && this.battle_controller.getWatchReplayStatus() || is_replay == true) {} // 这个时候都需要显示结算界面


      this.setBattleTimeScale(true);
      this.showWinView(data);
    } else {
      if (data.combat_type == this.combat_type) {
        // 
        if (is_replay == true) {
          this.clearView();
        } else {
          this.clearBattleScene();
          gcore.GlobalEvent.fire(EventId.EXIT_FIGHT, data.combat_type);
        }
      }
    }
  },
  //游戏退出结算
  showWinView: function showWinView(data) {
    if (data == null) return;
    this.battle_controller.openFinishView(true, data.combat_type, data);
  },
  //战斗结果
  result: function result(data, is_self_exit) {
    if (data == null) return;

    if (this.cur_fight_type == 2 && this.combat_type == data.combat_type) {
      this.clearView();
    }
  },
  clearView: function clearView() {
    this.setBattleTimeScale(true); // 还原动作速率

    if (this.battle_controller.getWatchReplayStatus() == true) {
      // 如果是录像状态下,退出录像
      this.battle_controller.setWatchReplayStatus(false);
    } // 派发退出战斗事件,通知各个系统处理


    gcore.GlobalEvent.fire(EventId.EXIT_FIGHT, this.combat_type);

    var MainuiController = require("mainui_controller");

    if (this.combat_type == BattleConst.Fight_Type.Darma) {
      if (MainuiController.getInstance().checkIsInDramaUIFight()) {
        // 剧情副本中结束战斗,则切到假战斗
        this.battle_controller.send20060(BattleConst.Fight_Type.Darma);
      }
    } else {
      if (this.battle_controller.getWatchReplayStatus() == true || this.combat_type == BattleConst.Fight_Type.PK || this.combat_type == BattleConst.Fight_Type.HeroTestWar) {
        if (MainuiController.getInstance().checkIsInDramaUIFight()) {
          // 剧情副本中结束战斗,则切到假战斗
          this.battle_controller.send20060(BattleConst.Fight_Type.Darma);
        } else {
          this.clearBattleScene();
        }
      } else {
        this.clearBattleScene();
      }
    }
  },
  // 播放资产掉落的动作
  playResourceCollect: function playResourceCollect(x, y, pos) {
    if (this.drama_fight_ui) {
      this.drama_fight_ui.playResourceCollect(x, y, pos);
    }
  },
  //获取group
  getGroup: function getGroup() {
    return this.my_group;
  },
  getCampIconConfigByIds: function getCampIconConfigByIds(id_list) {
    if (!id_list || Utils.next(id_list) == null) return;

    if (id_list.length == 1) {
      var id = id_list[0];
      return Config.combat_halo_data.data_halo_icon[id];
    } else {
      var min_id = Math.min(id_list[0], id_list[1]);
      var max_id = Math.max(id_list[0], id_list[1]);

      var _id = min_id * 100 + max_id;

      return Config.combat_halo_data.data_halo_icon[_id];
    }
  },
  getEffectRes: function getEffectRes(effect_id) {},
  // 开始准备战斗资源
  preloadBattleRes: function preloadBattleRes(data, finish_cb) {
    // skill_plays
    var battle_res = {};

    for (var skill_i in data.skill_plays) {
      var skill_data = data.skill_plays[skill_i];

      for (var effect_i in skill_data.effect_play) {
        var effect_data = skill_data.effect_play[effect_i];
        if (!effect_data.effect_bid) continue;
        var effect_config = gdata('skill_data', 'data_get_effect', effect_data.effect_bid);

        if (!effect_config) {
          continue;
        }

        var actor = this.real_role_list[effect_data.actor];
        var target = this.real_role_list[effect_data.target]; // 攻击动作资源

        if (effect_config.anime_res && actor) {
          var anime_res_path = actor.getResPath(effect_config.anime_res);

          if (anime_res_path) {
            battle_res[anime_res_path] = true;
          }
        } // 受击动作资源


        if (effect_config.hit_action && target) {
          if (effect_config.hit_action != "no-hurt") {
            var hit_action_path = target.getResPath(effect_config.hit_action);

            if (hit_action_path) {
              battle_res[hit_action_path] = true;
            }
          }
        } // 特效资源加载


        for (var effect_d in AniRes) {
          var effct_list = Utils.deepCopy(this.getCurEffectList(effect_config[AniRes[effect_d]]));

          for (var effect_i in effct_list) {
            var effect_info = effct_list[effect_i];

            if (effect_info.res_up) {
              var action_name = PlayerAction.action; // if (effect_info.up_action_name)
              //     action_name = effect_info.up_action_name;

              var res_path = "spine/" + effect_info.res_up + "/" + action_name;
              battle_res[res_path] = true;
            }

            if (effect_info.res_down) {
              var action_name = PlayerAction.action; // if (effect_info.down_action_name) {
              //     action_name = effect_info.down_action_name;
              // }

              var res_path = "spine/" + effect_info.res_down + "/" + action_name;
              battle_res[res_path] = true;
            }
          }
        }
      }
    }

    var total_num = 0;
    var finish_num = 0;

    for (var battle_i in battle_res) {
      total_num++;
    }

    for (var battle_i in battle_res) {
      var skeleton_path = battle_i + ".atlas";
      BattleResPool.getInstance().preLoadRes(skeleton_path, function (skeleton_path, res_object) {
        finish_num++;

        if (finish_num == total_num) {
          if (finish_cb) finish_cb();
        }
      }.bind(this, skeleton_path));
    }

    if (total_num == 0) {
      if (finish_cb) finish_cb();
    }
  }
});
module.exports = BattleModel;

cc._RF.pop();
                    }
                    if (nodeEnv) {
                        __define(__module.exports, __require, __module);
                    }
                    else {
                        __quick_compile_project__.registerModuleFunc(__filename, function () {
                            __define(__module.exports, __require, __module);
                        });
                    }
                })();
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["assets\\Scripts\\mod\\battle\\battle_model.js"],"names":["BattleData","require","BattleConst","LoaderManager","BattleResPool","AniRes","BattleModel","cc","Class","ctor","properties","init_fight_status","initConfig","battle_controller","getInstance","hook_model","getHookModel","skill_act","battle_pools","battle_dmg_cache_list","battle_effect_list","battle_effect_pool","role_time_scale","battle_speed","button_list_panel_time","form_panel_time","is_clear","resetInitData","my_group","alive_num","create_over_num","skill_plays_order_list","round_data_temp","order_list","round_data","cur_round_data","actor_sum","actor_play_sum","act_playing","is_play_round_start","cur_round","next_round","battle_data","combat_type","Fight_Type","Nil","real_role_list","cur_fight_type","buffs","hallows_list","scene_buff_effect_list","addBattleEfffect","parent","scene_pos","reverse","effect_id","action_name","BattleEffect","battle_effect","effect_key","Utils","getNorKey","length","shift","createEffect","resetScenePos","resetReverse","setTimeScale","setActiveEffect","push","delBattleEffect","getEffectKey","array","index","element","splice","getDmgFontCacheObject","type","callback","res_path","PathTool","getPlistPath","res_object","loadRes","bind","releaseDmgFont","path","releaseRes","getNormalFont","pools","getFontPools","node","size","get","Node","setAnchorPoint","width","height","bg_node","addComponent","Sprite","addChild","font_node","font_label","Label","lineHeight","fontSize","LabelOutline","name","bg_path","getUIIconPath","getComponent","spriteFrame","pushBackBattleFont","font","pushBackFont","updateCurBattleData","data","is_init","deleteCurBattleData","updateData","saveSpeed","play_speed","group","RoleController","role_vo","getRoleVo","key","fight_object_list","role_data","owner_id","owner_srv_id","rid","srv_id","hp","object_type","Unit_Type","Hallows","hallows_data","pos","hallows_val","val","hallows_max","max","addReadySum","csReadyFightStart","getAllObject","handleBattleSceneStatus","status","battle_scene","changeVisible","getFightStatus","is_real_combat","getBattleScene","isInRealBattle","createBattleScene","in_fight_type","clearRealRole","Battle_In_Type","Real","createClass","updateBattleScene","is_show","Darma","openDramaFightUI","openFormViewUI","setIsNormaBattle","handleSceneStatus","show_fight_ui_status","fight_ui_combat","drama_fight_ui","hide","gcore","SmartSocket","getTime","partner","ViewManager","getSceneNode","SCENE_TAG","ui","setParent","show","setZIndex","is_onshow","changeBattleStatus","startCountDownToDelete","form_fight_ui","setPosition","close_panel_timer","Timer","del","set","waitDeletePanel","button_pass_time","deleteMe","form_pass_time","getDramaFightUI","root_wnd","clearBattleScene","role_list","getAllBattleRoleList","cleanAllBattleEffect","playMusic","AUDIO_TYPE","SCENE","deleEffect","mapMovescheduleUpdate","changeMoveMapStatus","needPlayEnterAction","isFriend","getCurBattleData","getCombatType","checkIsCanChangeBattleSpeed","next_speed","speed_config","Config","combat_type_data","data_combat_speed","limit_lev","lev","limit_vip_lev","vip_lev","desc","js","formatStr","TI18N","message","fight_config","data_fight_list","is_pvp","changeSpeed","csFightSpeed","getTimeScale","time_scale","setBattleTimeScale","is_reset","battle_time_status","base_config","battle_act_data","data_get_act_data","base_speed_scale","speed_scale","setRoleTimeScale","object","speed","setSpeed","getSpeed","actStart","attacker","checkoutIsRightFight","wait_act","actTimeout","actFinish","is_real","playOrder","getUnrealBattleData","playRoundStart","dealRoundBuff","round_buff","hallows","role","setHallowsRound","all_alive","temp_list","is_die","doDied","skill_plays","csRoundFightEnd","handlePlayRoundStart","addRoundData","updateRound","action_count","playRoundIn","act_after_buff_list","setBuffsList","upDateNextMon","deleteRole","objects","updataNextBattleRole","createRole","updateBaseInfo","resetBattleRoleBaseInfo","buff_list","battle_role","target","buff_config","skill_data","data_get_buff","buff_bid","playRoundBuff","j","skill_element","i","effect_play","effect_element","order","skill_order","priority","skill_bid","skill_bid_of_effect","talk_pos","talk_content","sort","a","b","preloadBattleRes","analyseTempRoundData","Object","keys","temp","one_temp","actor","target_list","round","round_num","dmg_index","dmg_aid_y_offset","is_hurt_play","is_big_play","cancleBlackScreen","temp_skill_bid","csSkillPlayEnd","first_data","second_order","second_data","round_one_temp","getBattleRoleByPos","initOrder","buff","effect_hit","addBuff","change_type","battleRoleHPChange","change_value","is_dead","value","is_buff","camp_restrain","updateHP","mutiHurtNum","one","last_round_actor","resetZOrder","targe_zorder","list","col_target","GIRD_POS_OFFSET","col","Pos_To_Col","getLocalZOrder","is_round","attacker_info","gdata","target_pos","grid_pos","play_order_index","effect_bid","calcTargetPos","sub_effect_play_list","handleSubEffectPlaylist","effect_config","play_order","deepCopy","action_list","shake_id","effect_type","play_stand","anime_res","split_hurt","hit_action","effect_desc","is_must_die","anime_user_atk","attack_sound","ready_sound","shout_trick","hit_sound","hit_effect_list","getCurEffectList","area_effect_list","act_effect_list","bact_effect_list","trc_effect_list","is_calc","in_area_effect","area_hit_num","area_hit_time","start_attack","show_skill_nme","skill_type","Skill_Type","PASSIVE_SKILL","passive_skill_show","playFontMessage","ACTIVE_SKILL","showActiveSkillName","talk","object_list","obj_type","target_pos_base","target_name","object_name","effect_list","effect_data","data_get_effect_data","msg","singleAct","act_data","Array","mutiAct","act_config","args","act_args","funname","Function","params","unshift","apply","Log","info","acts","act","spawn","callfun","runAction","attack","delay_time","hit_fun","start_fun","is_reverse","start_callback","hit_callback","flyItem","move_time","is_back","start_height","checkIsInBattle","effect_object","is_friend","res_up","spec_res_up","scale","x_fix","y_fix","anima_name","PlayerAction","action_2","attack_func","center_pos","item","bid","playSelfEffect","act_list","x","y","func","getItem","finish_func","callFunc","last_effect","playMagic","act_start","normalStart","act_finish","normalFinish","sequence","fadeOut","time","fadeIn","resetAttackerStandStatus","next_round_actor","setAnimation","battle_stand","effect_name","model_height","batchPlayHurt","had_play","play_effect","hp_changed","color","outline","getBattleEffectLayer","target_x","target_y","normal_node","getChildByName","hex","color_data","data_color16","_color","fromHEX","out_hex","out_line","_color1","label","string","buff_show_index","delay","delayTime","delay_over","scale_to_1","scaleTo","move_by_1","moveBy","fade_in","scale_to_2","fade_out","move_by_2","play_num","avg_hp_changed","Math","ceil","is_hit","is_blind","dmg","floor","is_crit","summon_list","addRoleList","handleExtendDungeon","aid_actor","handleAidActor","playBattleRoleHurt","showbuffName","updateTargetHp","handleBufflist","playHurtEffect","hurt","playDmgMessage","buff_data","is_passive","playBuffEffect","action_type","removeBuff","buff_spine","changeSpine","setOpacity","remain_round","updateBuffList","had_buff","hadBuff","id","removeBuffList","res","play_type","Effect_Play_Type","ROLE_SCENE","removeSceneBuffEffect","removeBattleSpineEffect","addSceneBuffEffect","effect_res","effect","action","up_action_name","down_action_name","res_down","text_color","outline_color","client_desc","positive_or_negative","hadbuff","config","next","effectArea","is_col_effect","effectSpineUser","is_release","efftive_effect","tips_list","addTips","removeTips","sub_target","sub_hp_changed","extra_effect","n","extra","extra_key","playBuffAbsorbHurt","extra_param","sub_effect_id","sub_is_hit","skill_config","sub_skill_id","GuildDun","addGuildBossUI","total_hurt","aid_target","aid_dmg","actor_hp_changed","friend_pos","role_width","model_width","setLocalZOrder","setScenePos","v2","aid_hurt","actor_is_dead","attackReady","playEffectSound","BATTLE","ROLE","Battle_Type_Conf","TYPE_ROLE","areaHurt","hurt_func","playSceneAreaEffect","is_left","temp_pos","gridPosToScreenPos","SCREEN_WIDTH","SCREEN_HEIGHT","ENEMY_SCENE","height_fix","actHurt","is_big","playMagic2","attackPoint","anime_res_up","hit_num","hurtOne","effect_play_num","hideUI","noActAttack","next_delay_time","showUI","getBuffTag","moveBack","grid_pos_x","is_jump","is_jump_delay","is_get_point","is_move","move","moveToArea","move_model_x","gridSizeX","grid_pos_y","move_model_y","gridSizeY","move_delay_time","moveTo","is_col_act","direct","createRoleList","need_enter","enter_run","talk_back","role_layer","getBattleRoleLayer","resetBaseInfo","blackScreen","blackScreen2","blackScreen3","alpha","begin_fun","setBlack","is_black","end_fun","playShakeScreen","shakeScreen","shadow","getMainUICtrl","mainui_ctrl","showWin","is_replay","show_panel_type","getWatchReplayStatus","showWinView","clearView","GlobalEvent","fire","EventId","EXIT_FIGHT","openFinishView","result","is_self_exit","setWatchReplayStatus","MainuiController","checkIsInDramaUIFight","send20060","PK","HeroTestWar","playResourceCollect","getGroup","getCampIconConfigByIds","id_list","combat_halo_data","data_halo_icon","min_id","min","max_id","getEffectRes","finish_cb","battle_res","skill_i","effect_i","anime_res_path","getResPath","hit_action_path","effect_d","effct_list","effect_info","total_num","finish_num","battle_i","skeleton_path","preLoadRes","module","exports"],"mappings":"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","sourceRoot":"/","sourcesContent":["// --------------------------------------------------------------------\n// @author: xxx@syg.com(必填, 创建模块的人员)\n// @description:\n//      战战斗数据控制器,其中包括了战斗场景的创建\n//      flyItem attack hideUI showUI fadeOut fadeIn moveBack moveTo noActAttack  暂时实现的播报动作只有这一些\n//      blackScreen blackScreen2 blackScreen3 hide show shadow 这一些已经废弃的\n// <br/>Create: 2018-11-28 19:19:19\n// --------------------------------------------------------------------\nvar BattleData = require(\"battle_data\");\nvar BattleConst = require(\"battle_const\");\nvar LoaderManager = require(\"loadermanager\");\nvar BattleResPool = require(\"battle_res_pool\");\n\nvar AniRes = [\n    \"hit_effect_list\",   // 受击点特效\n    \"area_effect_list\",  // 范围特效\n    \"act_effect_list\",   // 出手点特效\n    \"bact_effect_list\",  // 施法特效\n    \"trc_effect_list\"    // 弹道特效\n]\n\nvar BattleModel = cc.Class({\n    ctor: function () {\n    },\n\n    properties: {\n        init_fight_status:false,\n    },\n\n    initConfig:function () {\n        this.battle_controller = require(\"battle_controller\").getInstance();\n        this.hook_model = this.battle_controller.getHookModel();\n        this.skill_act = require(\"skill_act\");\n\n        this.battle_pools = require(\"battle_role_pool\").getInstance();      // 现在这个对象池主要是存放buff飘字以及主动技能飘字等,退出战斗没有移除掉这个对象池\n        \n        this.battle_dmg_cache_list = {};     // 战斗伤害数字的缓存纹理数据,现在退出战斗没有移除掉\n\n        this.battle_effect_list = {};        // 当前战斗存在的非挂接角色的特效,这里存放的,退出战斗就会移除掉\n        this.battle_effect_pool = {};        // 已经播放过的特效缓存对象,退出战斗就会移除掉\n\n        this.role_time_scale = 1.1;          // 二倍速下面的模型动作速率\n        this.battle_speed = 1;               // 当前战斗速率,服务端速率\n\n        this.button_list_panel_time = 0;     // 假战斗详情面板关闭的时间戳\n        this.form_panel_time = 0;            // 真战斗对战面板关闭的时间戳\n        this.is_clear = true;\n\n        this.resetInitData();\n    },\n\n    // 重设初始化数据\n    resetInitData:function(){\n        this.my_group = 0;                      // 战斗中我自己的分组,主要区分是否是己方\n        this.init_fight_status = false;         // 是否是初始化进詹欧的,主要是做进场\n        this.alive_num = 0                      // 存活单位\n        this.create_over_num = 0                // 已经创建完成的单位数量\n        this.skill_plays_order_list = []        // 当前播放列表\n        this.round_data_temp = {}\n        this.order_list = [];\n        this.round_data = {};\n        this.cur_round_data = {}\n        this.actor_sum = 0;\n        this.actor_play_sum = 0;\n        this.act_playing = false;\n        this.is_play_round_start = false;\n        this.cur_round = null;\n        this.next_round = null;\n        this.battle_data = null;\n        this.combat_type = BattleConst.Fight_Type.Nil;  // 当前战斗类型\n        this.real_role_list = {};                       // 真是战斗单位列表\n        this.cur_fight_type = 0;                        // 当前战斗类型,如果是0:没有战斗 1:假战斗 2:真战斗\n        this.buffs = {};                                // 重连buff\n        this.hallows_list = {};                         // 神器数据\n        this.scene_buff_effect_list = {};               // 场景buff特效缓存对象\n    },\n\n    // 创建一个场景特效,主要是群攻之类的,这类特效在退出战斗的时候会移除掉\n    addBattleEfffect: function (parent, scene_pos, reverse, effect_id, action_name){\n        var BattleEffect = require(\"battle_effect\");\n        var battle_effect = null;\n        var effect_key = Utils.getNorKey(effect_id, action_name)\n\n        if (this.battle_effect_pool[effect_key] != null){\n            if (this.battle_effect_pool[effect_key].length > 0)\n            {\n                battle_effect = this.battle_effect_pool[effect_key].shift();          // 从头取出一个\n            }\n        }\n        if(battle_effect == null){\n            battle_effect = new BattleEffect();\n            battle_effect.createEffect(parent, scene_pos, reverse, effect_id);\n        } else {\n            battle_effect.resetScenePos(scene_pos);\n            battle_effect.resetReverse(reverse);\n            battle_effect.setTimeScale(this.role_time_scale);\n            battle_effect.setActiveEffect(true);\n        }\n\n        if (this.battle_effect_list[effect_key] == null){\n            this.battle_effect_list[effect_key] = []\n        }\n        this.battle_effect_list[effect_key].push(battle_effect);\n        return battle_effect;\n    },\n\n    // 移除一个场景战斗特效\n    delBattleEffect:function(battle_effect){\n        var effect_key = battle_effect.getEffectKey();\n        if (effect_key == \"_\") return;\n        if (this.battle_effect_pool[effect_key] == null){\n            this.battle_effect_pool[effect_key] = []\n        }\n        var array = this.battle_effect_list[effect_key];\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            if (element == battle_effect){\n                array.splice(index, 1);\n                battle_effect.setActiveEffect(false);\n                this.battle_effect_pool[effect_key].push(battle_effect);\n                break;\n            }\n        }\n    },\n\n    // 获取伤害数字的缓存纹理数据\n    getDmgFontCacheObject:function(type, callback){\n        var res_path = PathTool.getPlistPath(\"num\", \"type\" + type);\n        var res_object = this.battle_dmg_cache_list[res_path];\n        if(res_object == null){\n            LoaderManager.getInstance().loadRes(res_path, function(res_object){\n                this.battle_dmg_cache_list[res_path] = res_object;\n                callback(res_object);\n            }.bind(this))\n        }else{\n            callback(res_object);\n        }\n    },\n\n    // 释放掉战斗资源,退出战斗场景之后释放掉吧,但是这里可能存在一个问题就是退出战斗场景是即时的,但是伤害数字还在处于动作中,这个时候还是释放不掉,战斗艺术字不是特别大,暂时考虑不清除\n    releaseDmgFont:function(){\n        for(var path in this.battle_dmg_cache_list){\n            LoaderManager.getInstance().releaseRes(path);\n        }\n        this.battle_dmg_cache_list = {};\n    },\n\n    // 获取一个普通文字.带背景的,暂时退出战斗没有移除对象池\n    getNormalFont:function(){\n        var pools = this.battle_pools.getFontPools();\n        var node = null;\n        if (pools.size() > 0) {\n            node = pools.get();\n        } else {\n            node = new cc.Node();\n            node.setAnchorPoint(0.5, 0.5);\n            node.width = 176;\n            node.height = 44;\n\n            var bg_node = new cc.Node();\n            bg_node.addComponent(cc.Sprite);\n            node.addChild(bg_node);\n\n            var font_node = new cc.Node();\n            var font_label = font_node.addComponent(cc.Label);\n            font_label.lineHeight = 20;\n            font_label.fontSize = 20;\n            font_node.addComponent(cc.LabelOutline);\n            font_node.name = \"font_label\";\n            node.addChild(font_node);\n\n            var bg_path = PathTool.getUIIconPath(\"battle\", \"battle_buff_name_bg\");\n            LoaderManager.getInstance().loadRes(bg_path, function (bg_node, res_object) {\n                bg_node.getComponent(cc.Sprite).spriteFrame = res_object;\n            }.bind(this, bg_node))\n        }\n        return node;\n    },\n    /**\n     * 回收对象池\n     * @param {*} font \n     */\n    pushBackBattleFont: function (font) {\n        this.battle_pools.pushBackFont(font)\n    },\n\n    /**\n     * 真是战斗的初始化数据.战斗单位可能存在hp为0的时候,这个时候需要特殊处理\n     */\n    updateCurBattleData:function(data, is_init){\n        this.deleteCurBattleData();\n\n        this.init_fight_status = is_init;        \n        if (this.battle_data == null){\n            this.battle_data = new BattleData();\n        }\n        this.battle_data.updateData(data);\n\n        // 保存战斗速度\n        this.saveSpeed(data.play_speed);\n\n        // 更新神器数据\n        for (let index = 0; index < data.hallows_list.length; index++) {\n            const element = data.hallows_list[index];\n            this.hallows_list[element.group] = element;\n        }\n\n        // 先判断对战列表中是否有自己的\n        var RoleController = require(\"role_controller\");\n        var role_vo = RoleController.getInstance().getRoleVo();\n        for(var key in this.battle_data.fight_object_list){\n            var role_data = this.battle_data.fight_object_list[key];\n            if (Utils.getNorKey(role_data.owner_id, role_data.owner_srv_id) == Utils.getNorKey(role_vo.rid, role_vo.srv_id) && this.my_group == 0) {\n                this.my_group = role_data.group;\n            }\n            if (role_data.hp > 0){\n                this.alive_num += 1;\n            }\n            // 处理神器的\n            if (role_data.object_type == BattleConst.Unit_Type.Hallows) {\n                var hallows_data = this.hallows_list[role_data.group];\n                hallows_data.pos = role_data.pos;\n                role_data.hallows_val = hallows_data.val;\n                role_data.hallows_max = hallows_data.max;\n            }\n        }\n        if(this.my_group == 0){\n            this.my_group = 1;\n        }\n    },\n\n    /**\n     * 创建完成之后通知服务端准备报了\n     */\n    addReadySum:function(){\n        this.create_over_num += 1;\n        if (this.create_over_num >= this.alive_num){\n            this.battle_controller.csReadyFightStart();\n        }\n    },\n\n    // 获取所有战斗单位\n    getAllObject:function(){\n        return this.real_role_list;\n    },\n\n    // 设置战斗场景可见与否\n    handleBattleSceneStatus:function(status){\n        if(this.battle_scene){\n            this.battle_scene.changeVisible(status)\n            // this.battle_scene.setVisible(status)\n        }\n    },\n\n    // 是否在战斗中\n    getFightStatus:function(){\n        return this.is_real_combat;\n    },\n\n    // 返回战斗场景\n    getBattleScene:function(){\n        return this.battle_scene;\n    },\n\n    // 是否在真战斗中\n    isInRealBattle:function(){\n        return this.is_real_combat;\n    },\n\n    /**\n     * 创建战斗场景,这里是唯一的入口,这里需要判断真假战斗切换,等\n     * @param {*} in_fight_type 0:没有战斗 1:假战斗 2:真战斗\n     */\n    createBattleScene:function(in_fight_type, combat_type){\n        // 不同类的战斗或者不同类的战斗状态类型,都清掉单位\n        if(this.combat_type != combat_type || this.cur_fight_type != in_fight_type || in_fight_type == 1){  // 假战斗也移除掉单位重新创建吧\n            this.clearRealRole();\n            this.hook_model.clearRealRole();\n        }\n        this.combat_type = combat_type;         // 储存当前战斗类型\n        this.cur_fight_type = in_fight_type;    // 保存当前之战斗状态类型\n        this.is_real_combat = (in_fight_type == BattleConst.Battle_In_Type.Real);\n\n        if (this.battle_scene == null) {\n            this.battle_scene = Utils.createClass(\"battle_scene\");\n        }\n        this.battle_scene.updateBattleScene(this.is_real_combat);\n\n        // 只有剧情战斗的时候才需要显示战斗ui\n        var is_show = (combat_type == BattleConst.Fight_Type.Darma)\n        this.openDramaFightUI(is_show);\n\n        // 只有真战斗才需要显示\n        this.openFormViewUI(this.is_real_combat, combat_type);\n        this.battle_controller.setIsNormaBattle(this.is_real_combat);\n\n        // 这里把主城设置不可见\n        require(\"mainscene_controller\").getInstance().handleSceneStatus(false);\n\n        this.is_clear = false;\n    },\n\n    // 剧情战斗的ui部分\n    openDramaFightUI:function(status){\n        if (this.show_fight_ui_status == status && this.fight_ui_combat == this.is_real_combat){\n            return;\n        }\n        this.show_fight_ui_status = status;\n        this.fight_ui_combat = this.is_real_combat;\n        \n        if (!status){\n            if (this.drama_fight_ui){\n                this.drama_fight_ui.hide();\n                this.button_list_panel_time = gcore.SmartSocket.getTime();\n            }\n        }else{\n            if (this.drama_fight_ui == null) {\n                this.drama_fight_ui = Utils.createClass(\"battle_button_list_panel\");\n                var partner = ViewManager.getInstance().getSceneNode(SCENE_TAG.ui);\n                this.drama_fight_ui.setParent(partner);\n                this.drama_fight_ui.show(this.is_real_combat);\n                this.drama_fight_ui.setZIndex(-2);\n            }else{\n                if (this.drama_fight_ui.is_onshow == false) {\n                    this.drama_fight_ui.show(this.is_real_combat);\n                }else{\n                    this.drama_fight_ui.changeBattleStatus(this.is_real_combat);\n                }\n            }\n            this.button_list_panel_time = 0;\n        }\n        this.battle_controller.setIsNormaBattle(this.is_real_combat);\n\n        this.startCountDownToDelete();\n    },\n\n    // 真战斗中的阵型以及其他相关显示部分\n    openFormViewUI:function(status, combat_type){\n        if(!status){\n            if(this.form_fight_ui){\n                this.form_fight_ui.hide();\n                this.form_panel_time = gcore.SmartSocket.getTime();\n            }\n        }else{\n            if (this.form_fight_ui){\n                this.form_fight_ui.show(combat_type);\n            } else {\n                this.form_fight_ui = Utils.createClass(\"battle_form_panel\");\n                var partner = ViewManager.getInstance().getSceneNode(SCENE_TAG.ui);\n                this.form_fight_ui.setAnchorPoint(0, 0);\n                this.form_fight_ui.setPosition(-partner.width * 0.5, -partner.height * 0.5);\n\n                this.form_fight_ui.setParent(partner);\n                this.form_fight_ui.show(combat_type);\n                this.form_fight_ui.setZIndex(-1);\n            }\n            this.form_panel_time = 0;\n        }\n        this.startCountDownToDelete();\n    },\n\n    // 关闭面板的倒计时\n    startCountDownToDelete:function(){\n        if (this.form_panel_time == 0 && this.button_list_panel_time == 0){\n            if (this.close_panel_timer){\n                gcore.Timer.del(this.close_panel_timer);\n                this.close_panel_timer = null;\n            }\n        }else{\n            if (this.close_panel_timer == null){\n                this.close_panel_timer = gcore.Timer.set(function(){\n                    this.waitDeletePanel();\n                }.bind(this), 1000, -1);\n            }\n        }\n    },\n\n    // 倒计时准备清楚面板\n    waitDeletePanel:function(){\n        if (this.form_panel_time == 0 && this.button_list_panel_time == 0){\n            this.startCountDownToDelete();  // 移除掉定时器\n        }else{\n            if (this.button_list_panel_time != 0) {\n                var button_pass_time = gcore.SmartSocket.getTime() - this.button_list_panel_time;\n                if (button_pass_time > 100) {\n                    if (this.drama_fight_ui) {\n                        this.drama_fight_ui.deleteMe();\n                        this.drama_fight_ui = null;\n                    }\n                    this.button_list_panel_time = 0;\n                }\n            }\n            if (this.form_panel_time != 0) {\n                var form_pass_time = gcore.SmartSocket.getTime() - this.form_panel_time;\n                if (form_pass_time > 100) {\n                    if (this.form_fight_ui) {\n                        this.form_fight_ui.deleteMe();\n                        this.form_fight_ui = null;\n                    }\n                    this.form_panel_time = 0;\n                }\n            }\n        }\n    },\n\n    // 引导需要\n    getDramaFightUI: function () {\n        if (this.drama_fight_ui)\n            return this.drama_fight_ui.root_wnd;\n        return null;\n    },\n\n    /**\n     * 彻底移除一个战斗场景,比如说切换出战斗,或者非剧情战斗结束,这个结束\n     */\n    clearBattleScene: function () {\n        if (this.battle_scene && !this.is_clear) {\n            // 先移除掉单位定时器\n            var role_list = this.getAllBattleRoleList();\n            for(var pos in role_list){\n                gcore.Timer.del(\"attackerActTimeout\" + pos);\n            }\n            this.combat_type = BattleConst.Fight_Type.Nil;\n            this.cur_fight_type = BattleConst.Battle_In_Type.Nil;       // 移除掉战斗类型\n            this.is_real_combat = false;                                // 战斗\n\n            // 清楚掉场景单位\n            this.clearRealRole();\n            this.hook_model.clearRealRole();    // 假战斗模型资源\n\n            this.battle_scene.deleteMe();\n            this.battle_scene = null;\n\n            this.openDramaFightUI(false);\n            this.openFormViewUI(false);\n\n            // 移除掉所有的战斗特效--,群攻类和子弹类\n            this.cleanAllBattleEffect();\n\n            // 移除真实战斗场景的数据\n            this.deleteCurBattleData();\n\n            // 这里切回主城音乐\n            Utils.playMusic(AUDIO_TYPE.SCENE, \"s_002\", true);\n            this.is_clear = true;\n        }\n    },\n\n    // 清空所有的场景战斗特效\n    cleanAllBattleEffect:function(){\n        // 回收掉场景特效资源\n        for (var key in this.battle_effect_list) {\n            var array = this.battle_effect_list[key]\n            for (let index = 0; index < array.length; index++) {\n                const element = array[index];\n                element.deleEffect();\n            }\n        }\n        this.battle_effect_list = {};\n\n        // 回收掉场景特效资源\n        for (var key in this.battle_effect_pool) {\n            var array = this.battle_effect_pool[key]\n            for (let index = 0; index < array.length; index++) {\n                const element = array[index];\n                element.deleEffect();\n            }\n        }\n        this.battle_effect_pool = {};\n    },\n\n    /**\n     * 假战斗定帧移动地图处理,现在卸载gamestart 的update里面\n     */\n    mapMovescheduleUpdate: function () {\n        if (this.battle_scene) {\n            this.battle_scene.mapMovescheduleUpdate();\n        }\n    },\n\n    /**\n     * 切换战斗移动状态,比如真实剧情战斗切换到假战斗的时候,就需要开启地图移动\n     * @param {*} status Bool\n     */\n    changeMoveMapStatus: function (status) {\n        if (this.battle_scene) {\n            this.battle_scene.changeMoveMapStatus(status);\n        }\n    },\n\n    /**\n     * 进入真实战斗时,是否需要播放进场动作,中途切进去的不需要处理,这个值针对初始化单位的时候需要,战斗创建一个单位不需要\n     */\n    needPlayEnterAction:function(){\n        return this.init_fight_status;\n    },\n\n    /**\n     * 真实战斗中的单位是否是友方判断\n     * @param {*} group BattleRoleData.group\n     */\n    isFriend:function(group){\n        return (group == this.my_group);\n    },\n\n    /**\n     * 当前真实战斗的初始化数据\n     */\n    getCurBattleData:function(){\n        return this.battle_data;\n    },\n\n    // 获取当前战斗类型\n    getCombatType:function(){\n        return this.combat_type;\n    },\n\n    /**\n     * 退出战斗,清空战斗数据,针对真实战斗\n     */\n    deleteCurBattleData:function(){\n        this.resetInitData();\n    },\n\n    // 判断是否可以改变战斗速度\n    checkIsCanChangeBattleSpeed:function(){\n        if(this.battle_data == null){\n            return false;\n        }\n        var next_speed = 1;\n        if (this.battle_speed == 1){\n            next_speed = 2;\n        }\n        var speed_config = Config.combat_type_data.data_combat_speed[next_speed];\n        if (speed_config == null){\n            return false;\n        }\n        var role_vo = require(\"role_controller\").getInstance().getRoleVo();\n        if (role_vo == null){\n            return false;\n        }\n        if (speed_config.limit_lev > role_vo.lev && speed_config.limit_vip_lev > role_vo.vip_lev){\n            var desc = cc.js.formatStr(Utils.TI18N(\"等级达到%s级或VIP%s开启\"), speed_config.limit_lev, speed_config.limit_vip_lev);\n            message(desc);\n            return false;\n        }\n        var fight_config = Config.combat_type_data.data_fight_list[this.battle_data.combat_type];\n        if(fight_config == null){\n            return false;\n        }\n        if (fight_config.is_pvp == 1){\n            message(cc.js.formatStr(Utils.TI18N(\"%s不能更改速度\"), fight_config.desc));\n            return false;\n        }\n        return true;\n    },\n\n    /**\n     * 修改一下当前战斗速度\n     */\n    changeSpeed:function(){\n        if (this.battle_speed == 1) {\n            this.saveSpeed(2);\n            this.battle_controller.csFightSpeed(2);\n        } else {\n            this.saveSpeed(1);\n            this.battle_controller.csFightSpeed(1);\n        }\n    },\n\n    /**\n     * 当前战斗速度\n     */\n    getTimeScale:function(){\n        var time_scale = 1\n        if (this.isInRealBattle() == true){\n            time_scale = this.role_time_scale;\n        }\n        // time_scale = 1.5\n        // 要根据当前帧频调整播放速度\n        return time_scale\n    },\n\n    // 设置当前动作速度\n    setBattleTimeScale: function (is_reset) {\n        if(this.battle_time_status == is_reset) return;\n        this.battle_time_status = is_reset;\n        var base_config = null;\n        if (is_reset == true){      // 这个时候是1倍速\n            base_config = Config.battle_act_data.data_get_act_data.base_speed_scale;\n        }else{\n            base_config = Config.battle_act_data.data_get_act_data.speed_scale;\n        }\n        if(base_config){\n            this.role_time_scale = base_config.val * 0.01;\n        }\n        this.setRoleTimeScale();\n    },\n\n    // 保存速率之后马上设置模型动作\n    setRoleTimeScale: function () {\n        if(this.real_role_list){\n            for(var key in this.real_role_list){\n                var object = this.real_role_list[key];\n                if(object){\n                    object.setTimeScale(this.role_time_scale);\n                }\n            }\n        }\n\n        // 设置场景特效\n        if(this.battle_effect_list){\n            for(var key in this.battle_effect_list){\n                var array = this.battle_effect_list[key]\n                for (let index = 0; index < array.length; index++) {\n                    const element = array[index];\n                    if (element){\n                        element.setTimeScale(this.role_time_scale);\n                    }\n                }\n            }\n        }\n    },\n\n    // 保存当前战斗速度,这个速度只是为了改变显示\n    saveSpeed: function (speed) {\n        if (this.battle_speed == speed) return;\n        this.battle_speed = speed;\n        if(this.form_fight_ui){\n            this.form_fight_ui.setSpeed(speed);\n        }\n    },\n\n    // 获取当前速度\n    getSpeed:function(){\n        return this.battle_speed;\n    },\n\n    /**\n     * 一个回合播报的动作计数,最后保证值为0就表示播完了当前动作\n     * @param {*} attacker \n     */\n    actStart:function(attacker){\n        // 如果结算面板已经出来了,就不需要播报了\n        if (this.checkoutIsRightFight(attacker) == true){\n            attacker.wait_act += 1;\n            gcore.Timer.del(\"attackerActTimeout\" + attacker.pos);\n            gcore.Timer.set((function () {\n                this.actTimeout(attacker)\n            }).bind(this), 3000, 1, \"attackerActTimeout\" + attacker.pos)\n        }\n    },\n\n    /**\n     * 某一个动作播放完成之后,计数 -1,当为0的时候,就表示当前小回合播报结束\n     * @param {*} attacker \n     */\n    actFinish:function(attacker){\n        if (this.checkoutIsRightFight(attacker) == true){\n            if (attacker.wait_act > 0) {\n                attacker.wait_act -= 1;\n                if (attacker.wait_act <= 0) {\n                    if (attacker.is_real) {\n                        this.playOrder(attacker);\n                        gcore.Timer.del(\"attackerActTimeout\" + attacker.pos);\n                    } else {\n                        this.hook_model.playOrder(attacker);\n                    }\n                }\n            }\n        }\n    },\n\n    /**\n    * 判断是都是正式战斗\n    *\n    */\n    checkoutIsRightFight:function(attacker){\n        if(attacker.is_real == true){\n            if(this.battle_data && this.cur_round_data && this.battle_data.combat_type == this.cur_round_data.combat_type){\n                return true;\n            }\n        }else{\n            var battle_data = this.hook_model.getUnrealBattleData();\n            if(battle_data && battle_data.combat_type == BattleConst.Fight_Type.Darma){\n                return true;\n            }\n        }\n        return false;\n    },\n\n    /**\n     * 小回合播报超时处理\n     * @param {*} attacker \n     */\n    actTimeout:function(attacker){\n        if(attacker == null) return;\n        attacker.wait_act = 1;\n        this.actFinish(attacker);\n    },\n\n    /**\n     * 回合开始的播报,包括站位的初始化等,因为有一些是需要在回合开始的时候播放的播报  包含回合开始的buff\n     * @param {*} data 协议 20002 的数据\n     */\n    playRoundStart:function(data){\n        if (this.getBattleScene() == null || this.battle_data == null || this.battle_data.combat_type != data.combat_type){\n            return;\n        }\n        this.is_play_round_start = true;\n        // 处理回合buff\n        this.dealRoundBuff(data.round_buff);\n\n        // 处理神器的回合进度\n        if(data && data.hallows_list){\n            for (let index = 0; index < data.hallows_list.length; index++) {\n                const element = data.hallows_list[index];\n                if(element){\n                    var hallows = this.hallows_list[element.group];\n                    if (hallows && hallows.pos){\n                        var role = this.real_role_list[hallows.pos];\n                        if (role){\n                            role.setHallowsRound(element.val);\n                        }\n                    }\n                }\n            }\n        }\n        // 回合开始也处理掉那些假死的模型\n        if (data && data.all_alive){\n            var temp_list = {};\n            for (let index = 0; index < data.all_alive.length; index++) {\n                const element = data.all_alive[index];\n                if (element){\n                    temp_list[element.pos] = true;\n                }\n            }\n            for(var key in this.real_role_list){\n                if ( !temp_list[key]){\n                    var role = this.real_role_list[key];\n                    if (role && !role.is_die && role.role_data && role.role_data.object_type != BattleConst.Unit_Type.Hallows){\n                        role.doDied();\n                    }\n                }\n            }\n        }\n        // 没有技能播报列表,直接通知服务端结束\n        if (data == null || data.skill_plays.length == 0){\n            this.battle_controller.csRoundFightEnd();\n            // 初始化位置层级等相关信息\n            this.handlePlayRoundStart(data);\n        }else{\n            this.addRoundData(data);\n        }\n        if (this.form_fight_ui) {\n            this.form_fight_ui.updateRound(data.action_count);\n        }\n    },\n\n    /**\n     * 正常回合播报,回合开始播报结束之后,进入正常回合播报 包含回合结束buff和效果播报的buff\n     * @param {*} data 协议 20004 的数据\n     */\n    playRoundIn: function (data) {\n        this.is_play_round_start = false\n        // 回合结束后的buff可能需要处理的\n        if (data.round_buff && data.round_buff.length > 0) {\n            this.act_after_buff_list = data.round_buff;\n        }else{\n            this.act_after_buff_list = null;\n        }\n        this.addRoundData(data);\n    },\n\n    // 更新buff\n    setBuffsList:function(data){\n        this.buffs = data\n    },\n\n    /**\n     * 更新下一波怪物的数据\n     * @param {*} data \n     */\n    upDateNextMon:function(data){\n        if(this.real_role_list == null || data == null) return;\n        // 清掉上一回合的死亡对象\n        for(var key in this.real_role_list){\n            var role = this.real_role_list[key];\n            if (role && role.is_die == true){\n                role.deleteRole();\n                this.real_role_list[key] = null;\n            }\n        }\n        this.setBuffsList(data.buffs);\n        if(this.getBattleScene()){\n            for (let index = 0; index < data.objects.length; index++) {\n                const element = data.objects[index];\n                var role = this.real_role_list[element.pos]\n                if (this.isFriend(element.group) && role){\n                    role.updataNextBattleRole(element);\n                }else{\n                    this.createRole(element, true, null, true)\n                }\n            }\n        }\n\n        // 更新战斗基本数据\n        if(this.battle_data){\n            this.battle_data.updateData(data)\n\n            if(this.form_fight_ui){\n                this.form_fight_ui.updateBaseInfo();\n            }\n        }\n    },\n\n    /**addReConnectReadySum\n     * \n     * 处理回合开始的数据\n     * @param {*} data 协议 20002 的数据\n     */\n    handlePlayRoundStart: function (data) {\n        if (this.battle_data == null || this.battle_data.combat_type != data.combat_type) { return; }\n        if (this.battle_scene == null) { return; }\n        this.resetBattleRoleBaseInfo();\n    },\n\n    // 处理回合buff\n    dealRoundBuff: function(buff_list, attacker){\n        if (buff_list == null || buff_list.length == 0) return;\n        for (let index = 0; index < buff_list.length; index++) {\n            const element = buff_list[index];\n            var battle_role = this.real_role_list[element.target];\n            var buff_config = Config.skill_data.data_get_buff[element.buff_bid];\n            if (battle_role && buff_config){\n                this.playRoundBuff(battle_role, element, attacker);\n            }\n        }\n    },\n\n    /**\n     * 回合中的播报,这个是播报的主入口\n     * @param {*} data 协议 20004 的数据 \n     */\n    addRoundData: function (data) {\n        if (this.getBattleScene() == null || this.battle_data == null || this.battle_data.combat_type != data.combat_type){ \n            return; \n        }\n        // 更新当前回合数\n        if (this.form_fight_ui && data.action_count) {\n            this.form_fight_ui.updateRound(data.action_count);\n        }\n\n        // 播报数据\n        this.cur_round = null;\n        this.next_round = null;\n\n        this.cur_round_data = data;\n        this.skill_plays_order_list = [];\n        this.round_data_temp = {};\n\n        if (this.form_fight_ui) {\n            this.form_fight_ui.updateRound(data.action_count);\n        }\n        // 技能播报数据, 解析技能数据\n        for (let j = 0; j < data.skill_plays.length; j++) {\n            const skill_element = data.skill_plays[j];\n            for (let i = 0; i < skill_element.effect_play.length; i++) {\n                const effect_element = skill_element.effect_play[i];\n                if (this.round_data_temp[skill_element.order] == null){\n                    this.round_data_temp[skill_element.order] = []\n                    this.skill_plays_order_list.push({ skill_order: skill_element.order, priority: skill_element.order * 1000 + j})\n                }\n                effect_element.skill_bid = effect_element.skill_bid_of_effect\n                effect_element.talk_pos = skill_element.talk_pos\n                effect_element.talk_content = skill_element.talk_content\n                effect_element.index = i\n                effect_element.skill_order = skill_element.order\n                effect_element.priority = effect_element.order * 10000 + j * 100 + i\n\n                this.round_data_temp[skill_element.order].push(effect_element)\n            }\n        }\n        // 对出手进行排序\n        this.skill_plays_order_list.sort(function(a, b){\n            return a.priority - b.priority ;\n        })\n\n        // cc.log(\"HHHHHHHHHHHHHHHHHHHHH\");\n        // cc.log(this.skill_plays_order_list);\n\n        this.preloadBattleRes(data, function() {\n            this.analyseTempRoundData();\n        }.bind(this));\n\n    },\n\n    // 分析当前播报数据\n    analyseTempRoundData: function () {\n        this.order_list = [];\n        this.round_data = {};\n        if (Object.keys(this.round_data_temp).length > 0){\n            for (let index = 0; index < this.skill_plays_order_list.length; index++) {\n                const element = this.skill_plays_order_list[index];\n                const temp = this.round_data_temp[element.skill_order];\n                for (let i = 0; i < temp.length; i++) {\n                    const one_temp = temp[i];\n                    if (this.round_data[one_temp.order] == null){\n                        this.round_data[one_temp.order] = {};\n                        this.order_list.push({order:one_temp.order, priority:one_temp.priority});\n                    }\n                    if (this.round_data[one_temp.order][one_temp.actor] == null){\n                        this.round_data[one_temp.order][one_temp.actor] = {\n                            order: one_temp.order,\n                            actor: one_temp.actor,\n                            skill_bid: one_temp.skill_bid,\n                            talk_content: one_temp.talk_content,\n                            talk_pos: one_temp.talk_pos,\n                            index: one_temp.index,\n                            target_list: [],\n                        }\n                    }\n\n                    const object = this.round_data[one_temp.order][one_temp.actor];\n                    object.target_list.push(one_temp);\n                }\n            }\n            // 对出售惊醒排序\n            this.order_list.sort(function (a, b) {\n                return a.priority - b.priority;\n            })\n            this.round_data_temp = {};\n        }\n\n        // cc.log(\"出售顺序HHHHH\");\n        // cc.log(Utils.deepCopy(this.order_list));\n        // cc.log(Utils.deepCopy(this.round_data));\n\n        this.round();\n    },\n\n    // 回合播报\n    round:function(){\n        if (this.round_num && this.round_num > 0) return;\n        this.round_num = 0\n        this.actor_sum = 0;\n        this.actor_play_sum = 0;\n        this.cur_round = null;\n        this.next_round = null;\n\n        // 回合播报之前重置掉所有单位受击状态\n        if(this.battle_scene){\n            var role_list = this.getAllBattleRoleList();\n            for(var key in role_list){\n                var role = role_list[key];\n                if (role) {\n                    role.dmg_index = 0;\n                    role.dmg_aid_y_offset = 0;\n                    role.is_hurt_play = false;\n                    role.is_big_play = false;\n                }\n            }\n        }\n\n        if (this.order_list.length == 0){\n            this.cancleBlackScreen();\n            // 回合后的buff处理\n            if (this.act_after_buff_list && this.act_after_buff_list.length > 0){\n                this.dealRoundBuff(this.act_after_buff_list);\n                this.act_after_buff_list = null;\n            }\n            // 重置一些状态,可能是一些数值类的\n            if(this.real_role_list){\n                for(var key in this.real_role_list){\n                    var battle_role = this.real_role_list[key];\n                    if(battle_role){\n                        battle_role.temp_skill_bid = 0;\n                    }\n                }\n            }\n            // 通知服务端播报完成,区分回合开始和中间回合播报\n            if (this.is_play_round_start == true) {\n                this.battle_controller.csRoundFightEnd();\n            }else{\n                this.battle_controller.csSkillPlayEnd();\n            }\n            // 这个时候设置所有的单位初始状态\n        } else {\n            var first_data = this.order_list.shift();\n            var round_data = this.round_data[first_data.order];\n            if(this.order_list.length > 0){\n                var second_order = this.order_list[0].order\n                var second_data = this.round_data[second_order];\n                // 找到下一个回合播报,于当前回合播报做比较判断是不是多段攻击,从而在当前播报结束之后,是否需要重置\n                for (var actor in second_data){\n                    if(this.next_round == null){\n                        this.next_round = second_data[actor];\n                        break;\n                    }\n                }\n            }\n            this.round_num = Object.keys(round_data).length;\n            \n            for (var actor in round_data){\n                this.round_num -= 1;\n                var round_one_temp = round_data[actor];\n                if (this.cur_round == null){\n                    this.cur_round = round_one_temp;\n                }\n                if (round_one_temp.target_list.length > 0){\n                    var attacker = this.getBattleRoleByPos(round_one_temp.actor)\n                    if (attacker){\n                        this.actor_sum = this.actor_sum + 1;\n                        this.initOrder(attacker, round_one_temp)\n                    }else{\n                        this.round();\n                    }\n                }else{\n                    this.round();\n                }\n            }\n        }\n    },\n\n    // 播放回合buff,可能是回合开始,效果播报结束,也可能是回合结束, 这个buff是协议数据来的\n    playRoundBuff:function(target, buff, attacker, effect_hit){\n        if (target == null || buff == null) return;\n        this.addBuff(attacker, target, buff);\n\n        if (buff.change_type == 1) { // 血量变化的时候\n            this.battleRoleHPChange(target, buff.change_value, buff.is_dead, effect_hit, true);\n        }\n    },\n\n    // buff类的气血上号\n    battleRoleHPChange:function(target, value, is_dead, effect_hit, is_buff, camp_restrain){\n        if (target == null) return;\n        target.updateHP(value, is_dead, true, 0);\n        this.mutiHurtNum(target, value, effect_hit, is_buff, camp_restrain);\n    },\n\n    // 初始化动作列表,准备开战了,初始化一些数据\n    initOrder: function (attacker, one){\n        one.target_list.sort(function(a, b){\n            return a.priority - b.priority;\n        })\n        // 这个后续再看看要不要动态设置层级\n        if (this.cur_round && this.last_round_actor && this.cur_round.actor == this.last_round_actor){\n\n        }else{\n            attacker.resetZOrder();\n            attacker.targe_zorder = 9999;\n        }\n\n        var list = one.target_list;\n        var col_target = list[0].target;\n        if (col_target > GIRD_POS_OFFSET) {\n            col_target = col_target - GIRD_POS_OFFSET;\n        }\n        var col = Pos_To_Col[col_target - 1];\n        var target = this.getBattleRoleByPos(col_target);\n        if (target){\n            target.resetZOrder();\n            attacker.targe_zorder = target.getLocalZOrder();\n        }\n        attacker.col = col;\n        attacker.is_round = false;\n        attacker.attacker_info = one;\n        attacker.skill_data = gdata('skill_data', 'data_get_skill', one.skill_bid); \n        attacker.target_pos = attacker.grid_pos;\n        attacker.play_order_index = one.target_list[0].effect_bid;\n        this.calcTargetPos(attacker);\n\n        // 如果没有效果id则不处理,所有播报驱动都是效果驱动\n        if (attacker.play_order_index == null || attacker.play_order_index == 0){\n            this.actor_play_sum += 1;\n            var effect_play = one.target_list[0];\n            if (effect_play) {\n                if (effect_play.sub_effect_play_list && effect_play.sub_effect_play_list.length > 0){\n                    this.handleSubEffectPlaylist(effect_play, attacker);\n                }\n                this.dealRoundBuff(effect_play.buff_list, attacker);\n            }\n            this.round()\n            return\n        }\n        var effect_config = gdata('skill_data', 'data_get_effect', attacker.play_order_index);\n        if (effect_config) {\n            attacker.play_order = Utils.deepCopy(effect_config.action_list);                                    // 动作列表\n            attacker.shake_id = effect_config.shake_id;                                                         // 震屏ID\n            attacker.effect_type = effect_config.effect_type;                                                   // 效果类型\n            attacker.play_stand = effect_config.play_stand;                                                     // 是否收招\n            attacker.anime_res = effect_config.anime_res;                                                       // 攻击动作资源\n            attacker.split_hurt = effect_config.split_hurt;\n            attacker.hit_action = effect_config.hit_action;                                                     // 受击处理\n            attacker.effect_desc = effect_config.effect_desc;                                                   // 效果飘字\n            attacker.is_must_die = effect_config.is_must_die;                                                   // 死亡的时候是否移除,这个主要是判断连击中的时候\n            attacker.anime_user_atk = effect_config.anime_user_atk;                                             // 攻击动作名\n            attacker.attack_sound = effect_config.attack_sound;                                                 // 攻击音效\n            attacker.ready_sound = effect_config.ready_sound;                                                   // 准备音效\n            attacker.shout_trick = effect_config.shout_trick;                                                   // 喊招音效\n            attacker.hit_sound = effect_config.hit_sound;                                                       // 受击音效\n            attacker.hit_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.hit_effect_list));    // 记录打击特效列表\n            attacker.area_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.area_effect_list));  // 记录范围人物特效\n            attacker.act_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.act_effect_list));    // 记录出手点特效\n            attacker.bact_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.bact_effect_list));  // 记录施法特效\n            attacker.trc_effect_list = Utils.deepCopy(this.getCurEffectList(effect_config.trc_effect_list));    // 记录弹道特效\n        }\n        // 是否有群攻\n        if (attacker.area_effect_list.length > 0){\n            attacker.attacker_info.is_calc = false\n            attacker.in_area_effect = true\n            attacker.area_hit_num = 1\n            attacker.area_hit_time = 0\n        }else{\n            attacker.in_area_effect = false\n        }\n        var start_attack = (function(){\n            this.playOrder(attacker);\n        }).bind(this);\n\n        // 主动技能和被动技能喊招处理\n        var show_skill_nme = (function(){\n            var skill_type = attacker.skill_data.type\n            if (skill_type == BattleConst.Skill_Type.PASSIVE_SKILL && attacker.skill_data.passive_skill_show == 1){\n                this.playFontMessage(attacker, attacker.skill_data.name, null, null, null, null, null, function(){\n                    start_attack()\n                }.bind(this))\n            }else if(skill_type == BattleConst.Skill_Type.ACTIVE_SKILL){\n                if(this.form_fight_ui){\n                    this.form_fight_ui.showActiveSkillName(attacker, function (){\n                        start_attack()\n                    })\n                }\n            }else{\n                start_attack()\n            }\n        }).bind(this);\n\n        if(attacker.skill_data == null){\n            this.talk(attacker, start_attack);\n        } else {\n            this.talk(attacker, show_skill_nme);\n        }\n        this.act_playing = true\n    },\n\n    /**\n     * 计算目标点\n     * @param {*} attacker \n     * @param {*} object_list \n     */\n    calcTargetPos:function(attacker, object_list){\n        if (attacker == null || attacker.attacker_info == null){\n            return;\n        }\n        var target_list = attacker.attacker_info.target_list;\n        var target = null;\n        for (let index = 0; index < target_list.length; index++) {\n            const element = target_list[index];\n            if (object_list){\n                target = object_list[element.target];\n            }else{\n                target = this.getBattleRoleByPos(element.target);\n            }\n            if (target && target.obj_type != attacker.obj_type){\n                break;\n            }\n        }\n        if (target){\n            attacker.target_pos = target.grid_pos;\n            attacker.target_pos_base = target.grid_pos;\n            attacker.target_name = target.role_data.object_name;\n        }\n    },\n\n    // 效果列表\n    getCurEffectList: function(list){\n        var effect_list = []\n        for (let index = 0; index < list.length; index++) {\n            const element = list[index];\n            var effect_data = Config.skill_data.data_get_effect_data[element]\n            effect_list.push(effect_data)\n        }\n        return effect_list;\n    },\n\n    // 单位喊话\n    talk:function(attacker, callback){\n        var msg = attacker.attacker_info.talk_content || \"\"\n        var actor = attacker.attacker_info.talk_pos\n        if (msg == \"\"){\n            if(callback){\n                callback()\n            }\n            return;\n        }\n        // 然后播放气泡.....\n        if(callback){\n            callback()\n        }\n    },\n\n    // 获取播报动作\n    singleAct:function(act_data, attacker){\n        if ((act_data instanceof Array)){\n            return this.mutiAct(act_data, attacker);\n        }else{\n            var act_config = Utils.deepCopy(Config.skill_data.data_get_act_data[act_data])\n            if (act_config){\n                var args = act_config.act_args;\n                var funname = args[0];\n\n                if(funname == null || this[funname] == null){\n                    return;\n                }\n                if(this[funname] instanceof Function){\n                    var params = args[1] || [];\n                    params.unshift(attacker);\n                    return this[funname].apply(this, params);\n                } else {\n                    Log.info(\"动作错误,动作BID:\"+act_data);\n                }\n            } \n        }\n    },\n\n    // 获取多段播报动作\n    mutiAct:function(args, attacker){\n        var acts = [];\n        for (let index = 0; index < args.length; index++) {\n            const element = args[index];\n            var act = this.singleAct(element, attacker);\n            acts.push(act);\n        }\n        \n        if (acts.length == 1){\n            return acts[0];\n        }else{\n            return cc.spawn.apply(null, acts);\n        }\n    },\n\n    /**\n     * 技能动作附带糊掉函数\n     * @param {*} attacker \n     * @param {*} args \n     */\n    callfun: function (attacker, args){\n        var funname = \"\";\n        var params = null;\n        if( args instanceof Array){\n            funname = args[0];\n            params = args[1] || [];\n        }else{\n            funname = args\n        }\n        if (funname == \"\"){\n            return;\n        }\n        if(this[funname] instanceof Function){\n            if (params == null){\n                params = [];\n            }\n            params.unshift(attacker);\n            this[funname].apply(this, params);\n        }else if(typeof(funname) == \"number\"){\n            var act = this.singleAct(funname, attacker)\n            attacker.runAction(act);\n        }\n    },\n\n    /**\n     * 普通近战攻击\n     * @param {*} attack \n     * @param {*} delay_time \n     * @param {*} hit_fun \n     * @param {*} start_fun 攻击开始动作\n     * @param {*} is_reverse 是否是移动到背面\n     */\n    attack:function(attacker, delay_time, hit_fun, start_fun, is_reverse){\n        if (attacker && attacker.anime_user_atk) {\n            delay_time = delay_time || 0;\n            is_reverse = (is_reverse == 1);\n            \n            var start_callback = (function () {\n                this.callfun(attacker, start_fun)\n            }).bind(this);\n\n            var hit_callback = (function () {\n                this.callfun(attacker, hit_fun)\n            }).bind(this);\n            return this.skill_act.attack(attacker, delay_time, attacker.anime_user_atk, hit_callback, start_callback, is_reverse, null, attacker.anime_res)\n        }\n    },\n\n    /**\n     * 远程攻击子弹\n     * @param {*} attacker \n     * @param {*} delay_time \n     * @param {*} move_time \n     * @param {*} is_back \n     * @param {*} funname \n     * @param {*} start_height \n     */\n    flyItem: function (attacker, delay_time, move_time, is_back, funname, start_height){\n        if(this.checkIsInBattle(attacker) == false){\n            return;\n        }\n        const effect_list = attacker.trc_effect_list;       // 这个效果可能有多个,这个时候主要取第一个吧\n        if (effect_list == null || effect_list.length == 0){\n            Log.info(\"播放远程攻击效果失败,不存在远程的效果,效果id为:  \" + attacker.play_order_index);\n            this.actStart(attacker)\n            return;\n        }\n        const effect_object = effect_list[0];       // 主要第一个\n        const is_friend = attacker.is_friend;       // 是否是友方\n        var res_up = effect_object.res_up;          //\n        if (is_friend == true && effect_object.spec_res_up != \"\"){\n            res_up = effect_object.spec_res_up\n        }\n        let scale = effect_object.scale * 0.001;\n        let x_fix = effect_object.x_fix * attacker.obj_type;\n        let y_fix = (effect_object.y_fix == 0) ? 50 : effect_object.y_fix;\n        let anima_name = attacker.anime_user_atk || PlayerAction.action_2;\n        var attack_func = (function(){\n            const target_list = attacker.attacker_info.target_list;\n            if(target_list.length <= 1){            // 只有一个攻击对象的时候\n                var target_pos = this.center_pos(attacker, y_fix);\n                return this.item(attacker, delay_time, res_up, move_time, funname, start_height, target_pos, scale, effect_object.bid, x_fix, y_fix);\n            }else{\n                this.playSelfEffect();\n                var act_list = []; // 动作列表\n                var array = attacker.attacker_info.target_list;\n                for (let index = 0; index < array.length; index++) {\n                    const element = array[index];\n                    const target = this.getBattleRoleByPos(element.target);\n                    if(target){     // 目标\n                        var target_pos = {x:target.scene_pos.x, y:target.scene_pos.y + y_fix};\n                        if (target.group != attacker.group){\n                            var func = this.getItem(attacker, delay_time, res_up, move_time, \"hurtOne\", start_height, target_pos, scale, effect_object.bid, x_fix, y_fix)\n                            act_list.push(func);\n                        }\n                    }\n                }\n\n                // 关键数据\n                var finish_func = cc.callFunc(function(){\n                    if (attacker.attacker_info.last_effect){\n                        for (let index = 0; index < attacker.attacker_info.last_effect.length; index++) {\n                            const element = attacker.attacker_info.last_effect[index];\n                            if (attacker.is_real){\n                                this.playMagic(attacker, element)\n                            } else {\n                                this.hook_model.playMagic(attacker, element)\n                            }\n                        }\n                    }\n                }.bind(this))\n\n                if(act_list.length > 0){\n                    var act_start = this.skill_act.normalStart(attacker);\n                    var act_finish = this.skill_act.normalFinish(attacker);\n                    var act = cc.sequence(act_start, cc.spawn.apply(null, act_list), act_finish);\n                    attacker.runAction(act);\n                }\n            }\n\n        }).bind(this);\n        return this.skill_act.attack(attacker, delay_time, anima_name, null, null, false, attack_func, attacker.anime_res);\n    },\n\n    // 渐隐掉的播报\n    fadeOut:function(attacker, delay_time, time){\n        time = time || 10;\n        return this.skill_act.fadeOut(attacker, delay_time, time);\n    },\n\n    // 渐现出来\n    fadeIn:function(attacker, delay_time, time){\n        time = time || 1;\n        return this.skill_act.fadeIn(attacker, delay_time, time);\n    },\n\n    // 处理友方特效\n    playSelfEffect:function(attacker){\n        if (attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null) return;\n        var last_effect = [];\n        var target = null;\n        for (let index = 0; index < attacker.attacker_info.target_list.length; index++) {\n            const element = attacker.attacker_info.target_list[index];\n            target = this.getBattleRoleByPos(element.target);\n            if (target && attacker.group == target.group){\n                last_effect.push(element);\n            }            \n        }\n        attacker.attacker_info.effect_play = last_effect;\n        attacker.attacker_info.last_effect = last_effect;\n    },\n    \n    // 回合播报结束设置施法者战力动作\n    resetAttackerStandStatus:function(attacker){\n        if(this.battle_scene == null || attacker == null){\n            return;\n        }\n        var next_round_actor = 0;\n        if (this.next_round) {\n            next_round_actor = this.next_round.actor;\n        }\n        if (this.cur_round){\n            this.last_round_actor = this.cur_round.actor;\n        }\n        if (next_round_actor == 0 || (this.cur_round && this.cur_round.actor != next_round_actor)) {\n            this.skill_act.setAnimation(attacker, PlayerAction.battle_stand, true);\n            this.cancleBlackScreen();\n            attacker.resetZOrder();\n        }\n    },\n\n    /**\n     * 实例化远程子弹动作\n     * @param {*} attacker \n     * @param {*} delay_time \n     * @param {*} effect_name \n     * @param {*} move_time \n     * @param {*} funname \n     * @param {*} start_height \n     * @param {*} target_pos \n     * @param {*} scale \n     * @param {*} bid \n     * @param {*} x_fix \n     * @param {*} y_fix \n     */\n    item:function(attacker, delay_time, effect_name, move_time, funname, start_height, target_pos, scale, bid, x_fix, y_fix){\n        if(attacker == null || this.battle_scene == null){\n            return;\n        }\n        start_height = (start_height || 0) * attacker.model_height * 0.01;\n        move_time = move_time || 10;\n        var hit_callback = (function(){\n            this.callfun(attacker, funname);\n            // 这里暂时注释掉不知道有没有问题\n            // if(attacker.attacker_info.target_list.length > 0){\n            //     attacker.attacker_info.target_list.unshift();\n            // }\n        }).bind(this);\n\n        if (!attacker.is_real){\n            hit_callback();\n        }else{\n            attacker.runAction(this.skill_act.flyItem(attacker, delay_time, effect_name, move_time, hit_callback, start_height, target_pos, scale, bid, x_fix, y_fix));\n        }\n    },\n\n    /**\n     * 获取移动动作\n     * @param {*} attacker \n     * @param {*} delay_time \n     * @param {*} effect_name \n     * @param {*} move_time \n     * @param {*} funname \n     * @param {*} start_height \n     * @param {*} target_pos \n     * @param {*} scale \n     * @param {*} bid \n     * @param {*} x_fix \n     * @param {*} y_fix \n     */\n    getItem:function(attacker, delay_time, effect_name, move_time, funname, start_height, target_pos, scale, bid, x_fix, y_fix){\n        start_height = start_height || 60;\n        move_time = move_time || 10;\n        var hit_callback = (function(){\n            this.callfun(attacker, funname);\n            // 这里暂时注释掉不知道有没有问题\n            // if(attacker.attacker_info.target_list.length > 0){\n            //     attacker.attacker_info.target_list.unshift();\n            // }\n        }).bind(this);\n        var act = this.skill_act.flyItem(attacker, delay_time, effect_name, move_time, hit_callback, start_height, target_pos, scale, bid, x_fix, y_fix);\n        return act;\n    },\n\n    // 播报,动作施法者\n    playOrder:function(attacker){\n        if (attacker == null) return;\n        if (attacker.wait_act && attacker.wait_act != 0) return;\n        // 没有技能效果的时候,直接移除掉\n        if (attacker.play_order_index == null || attacker.play_order_index == 0) return;\n        // 每个动作的计数器,当一个动作开始之后开始计数,为0标识这个动作做完了\n        attacker.wait_act = 0;\n\n        if (attacker.play_order == null || attacker.play_order.length == 0){\n            this.actor_play_sum += 1;\n\n            if(!attacker.is_die){\n                this.resetAttackerStandStatus(attacker);\n            }\n\n            if(!attacker.is_round){\n                this.act_playing = false;\n                if (this.actor_play_sum >= this.actor_sum){\n                    this.round();\n                }\n            }\n        }else{\n            var index = attacker.play_order.shift();\n            var act = this.singleAct(index, attacker);\n            if(act){\n                attacker.runAction(act);\n            }\n        }\n    },\n\n    // 处理群攻效果,比如说音效不要播太多\n    batchPlayHurt:function(attacker){\n        if(attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null){\n            return;\n        }\n        var target_list = attacker.attacker_info.target_list;\n        if (target_list.length == 0){\n            return\n        }\n        var had_play = false;           // 多个受击音效只需要播放一次\n        for (let index = 0; index < target_list.length; index++) {\n            const element = target_list[index];\n            if (attacker.is_real){\n                var play_effect = false;\n                if (element.hp_changed && element.hp_changed < 0 && had_play == false){\n                    had_play = true;\n                    play_effect = true;\n                }\n                this.playMagic(attacker, element, play_effect) \n            }else{\n                this.hook_model.playMagic(attacker, element, play_effect)\n            }\n        }\n    },\n\n    /**\n     * 播放普通战斗飘字\n     * @param {*} target 战斗目标单位\n     * @param {*} desc 当前文本\n     * @param {*} parent 父节点,如果没有,则默认是战斗场景特效层1\n     * @param {*} x x方向的偏移值\n     * @param {*} y y方向的偏移值\n     * @param {*} color 文字颜色\n     * @param {*} outline 文字描边色\n     */\n    playFontMessage:function(target, desc, parent, x, y, color, outline, callback){\n        if(this.checkIsInBattle(target) == false){\n            return;\n        }\n        if(parent == null){\n            parent = this.battle_scene.getBattleEffectLayer(1)      // 默认放在特效1层上面\n        }\n        x = x || 0;\n        y = y || 0;\n        var target_x = target.scene_pos.x + x;\n        var target_y = target.scene_pos.y + y + target.model_height/2;\n        if (color == null){\n            color = 217;\n        }\n        if (outline == null){\n            outline = 218;\n        }\n\n        // 设置字体默认颜色\n        var normal_node = this.getNormalFont();\n        normal_node.setPosition(target_x, target_y);\n\n        var font_node = normal_node.getChildByName(\"font_label\");\n        var hex = Config.color_data.data_color16[color];\n        var _color = font_node.color;\n        _color.fromHEX(hex);\n        font_node.color = _color;\n\n        // 设置描边颜色\n        var out_hex = Config.color_data.data_color16[outline];\n        var out_line = font_node.getComponent(cc.LabelOutline);\n        var _color1 = out_line.color;\n        _color1.fromHEX(out_hex);\n        out_line.color = _color1;\n\n        // 设置字体\n        var label = font_node.getComponent(cc.Label);\n        label.string = desc;\n        parent.addChild(normal_node);\n\n        if (target.buff_show_index == null){\n            target.buff_show_index = 0;\n        }\n        target.buff_show_index = target.buff_show_index + 1;\n\n        var show = cc.show();\n        var delay = cc.delayTime(0.3 * target.buff_show_index);\n        var delay_over = cc.callFunc(function () {\n            target.buff_show_index -= 1;\n        }.bind(this))\n        var scale_to_1 = cc.scaleTo(0.4, 1.2);\n        var move_by_1 = cc.moveBy(0.4, 0, 50);\n        var fade_in = cc.fadeIn(0.4);\n\n        var scale_to_2 = cc.scaleTo(0.6, 0.9);\n        var fade_out = cc.fadeOut(0.6);\n        var move_by_2 = cc.moveBy(0.6, 0, 25);\n        var hide = cc.hide();\n\n        normal_node.runAction(cc.sequence(show, delay, delay_over, cc.spawn(scale_to_1, move_by_1, fade_in), cc.spawn(scale_to_2, fade_out, move_by_2), hide, cc.callFunc(function () {\n            if (callback) {\n                callback();\n            }\n            this.pushBackBattleFont(normal_node);\n        }.bind(this))));\n    },\n\n    /**\n     * 播放魔法特效\n     * @param {*} attacker \n     * @param {*} effect_play \n     * @param {*} no_die \n     * @param {*} play_effect \n     */\n    playMagic: function (attacker, effect_play, play_effect){\n        if (this.battle_scene == null){ return; }\n        if (effect_play.target == null){ return; }\n        if (attacker == null){ return; }\n        if (effect_play.play_num != null && effect_play.play_num <= 0){ return; }\n        if (effect_play.play_num == null && attacker.split_hurt){\n            effect_play.play_num = attacker.split_hurt || 1;\n            if(effect_play.play_num > 1){\n                effect_play.avg_hp_changed = Math.ceil(effect_play.hp_changed / effect_play.play_num)\n            }\n        }\n        effect_play.play_num = effect_play.play_num || 1;\n        effect_play.play_num -= 1;\n        var effect_hit = 1;\n        var target = this.getBattleRoleByPos(effect_play.target);\n        if (target){\n            if (effect_play.is_hit == 0 || effect_play.is_blind == 1){          // 闪躲或者未命中\n                effect_hit = 0\n                var desc = Utils.TI18N(\"闪躲\");\n                if(effect_play.is_blind == 1){\n                    desc = Utils.TI18N(\"未命中\");\n                }\n                if(effect_play.is_dead == 0){       // 非死亡情况下才飘字\n                    this.playFontMessage(target, desc, null, null, null, 227, 228);\n                }\n            }\n            var hp_changed = effect_play.avg_hp_changed || effect_play.hp_changed || 0;\n            var dmg = Math.floor(hp_changed);\n            if(effect_play.is_crit == 1){   // 暴击\n                effect_hit = 2;\n            }\n            var is_dead = effect_play.is_dead;\n            if(effect_play.play_num > 0){       // 多次伤害的话第一次不能死\n                is_dead = 0\n            }\n            // 处理召唤列表\n            if (effect_play.summon_list.length > 0){\n                this.addRoleList(effect_play.summon_list, attacker)\n            }\n            // 处理子效果\n            if (effect_play.sub_effect_play_list.length > 0){\n                this.handleSubEffectPlaylist(effect_play, attacker)\n            }\n            // 副本中需要的特殊处理\n            this.handleExtendDungeon(effect_play)\n            // 处理援护\n            if (effect_play.aid_actor != 0){\n                this.handleAidActor(effect_play, attacker, effect_hit, target)\n            }\n            // 播放受击处理\n            this.playBattleRoleHurt(attacker, target, dmg, play_effect);\n\n            // 飘字处理\n            if(attacker.effect_desc != \"\" && effect_play.is_hit != 0 && effect_play.play_num <= 0){\n                this.showbuffName(target, attacker.effect_desc, 229, 230, attacker.play_order_index);\n            }\n            // 把扣血放到最后,因为有死亡动作\n            this.updateTargetHp(attacker, target, dmg, is_dead, effect_hit, effect_play);\n            \n            // 处理buff列表,非死亡的时候才处理,如果上面播报已经说死了,不需要处理buff了\n            if (effect_play.play_num <= 0 && effect_play.buff_list.length > 0) {\n                this.handleBufflist(attacker, effect_play.buff_list, 1)\n            }\n        }\n    },\n\n    // 播放受击处理\n    playBattleRoleHurt:function(attacker, target, dmg, play_effect){\n        if (attacker == null || target == null) return;\n        if (target.is_hurt_play == true) return;\n        target.is_hurt_play = true\n\n        if (!target.is_big_play) {\n            target.is_big_play = true\n            this.playHurtEffect(attacker, target)\n        }\n        if (attacker.pos != target.pos && dmg < 0 && attacker.group != target.group) {    // 播放受击动作\n            if (attacker.hit_action != \"no-hurt\") {\n                this.skill_act.hurt(attacker, target, attacker.hit_action, play_effect)\n            }\n        }\n    },\n\n    /**\n     * 更新血条处理\n     * @param {*} attacker \n     * @param {*} target \n     * @param {*} dmg \n     * @param {*} is_die \n     * @param {*} effect_hit 1是是普通, 2是暴击\n     * @param {*} is_yuanhu \n     * @param {*} is_normal \n     * @param {*} effect_play \n     */\n    updateTargetHp:function(attacker, target, dmg, is_die, effect_hit, effect_play){\n        if (target == null) return;\n        if (attacker == null) return;\n        if (dmg == 0) return;\n        effect_hit = effect_hit || 1;\n        this.mutiHurtNum(target, dmg, effect_hit, false, effect_play.camp_restrain);\n        // 储存具体数据\n        target.updateHP(dmg, is_die, false, attacker.is_must_die);\n    },\n\n    /**\n     * 播放伤害飘血\n     * @param {*} tatget \n     * @param {*} dmg \n     * @param {*} effect_hit 1是是普通, 2是暴击\n     * @param {*} is_normal \n     * @param {*} is_buff \n     * @param {*} camp_restrain \n     */\n    mutiHurtNum:function(target, dmg, effect_hit, is_buff, camp_restrain){\n        if(this.checkIsInBattle(target) == false || dmg == 0 || target.is_real == false){\n            return;\n        }\n        // 这个数值用于处理飘血高度的...放置叠加到一起\n        if (target.dmg_index == null){\n            target.dmg_index = 0;\n        }\n        target.dmg_index += 1;\n        this.skill_act.playDmgMessage(target, dmg, effect_hit, is_buff, camp_restrain);\n    },\n\n    /**\n     * 处理buff效果\n     * @param {*} attacker \n     * @param {*} list \n     * @param {*} effect_hit 是否是暴击\n     */\n    handleBufflist:function(attacker,list,effect_hit){\n        if(this.checkIsInBattle(attacker) == false){\n            return;\n        }\n        for (let index = 0; index < list.length; index++) {\n            const buff = list[index];\n            const target = this.getBattleRoleByPos(buff.target);\n            if(target){\n                this.playRoundBuff(target, buff, attacker, effect_hit);\n            }\n        }\n    },\n\n    /**\n     * 添加一个buf\n     * @param {*} attacker buff的发起者.可能没有\n     * @param {*} target \n     * @param {*} buff \n     */\n    addBuff:function(attacker, target, buff){\n        if (target == null || buff == null) return;\n        var buff_data = Config.skill_data.data_get_buff[buff.buff_bid]; \n        if (buff_data == null) return;\n        if (buff_data.is_passive == 1){\n            this.playBuffEffect(attacker, target, buff, buff_data);\n        }\n        if (buff.action_type == 4) return;\n        if (buff.action_type == 2){\n            this.removeBuff(target, buff, buff_data);\n        }else{\n\n            if (buff_data.is_passive == 1 || buff_data.group == 3211){    // 不可复活组的buff额外处理\n                if (buff.action_type == 1 || buff.action_type == 3){    // 主处理新增或者是展示的buff\n                    if (buff_data.group != 3211) {\n                        if (buff_data.buff_spine && buff_data.buff_data != \"\") {    // 存在变身的buff\n                            target.changeSpine(true, buff_data.buff_spine, PlayerAction.battle_stand);\n                        }\n                        if (buff_data.group == 3703) {        // 隐身buff\n                            target.setOpacity(true, 155);\n                        }\n                    }\n                    if (buff.action_type == 1 && buff.remain_round != 0){     // 新增buff才处理,这里主要是开始增加血条下面的bufficon\n                        target.updateBuffList(buff, buff_data);\n                    }\n                }\n            }\n        }\n    },\n\n    // 移除一个buff,包含移除一个对象的特效和移除一个buff图标\n    removeBuff:function(target, buff, buff_data){\n        if(this.getBattleScene() == null || target == null) return;\n        if(buff == null || buff_data == null) return;\n        var had_buff = target.hadBuff(buff.id);\n        if (had_buff == true){\n            target.removeBuffList(buff.id); // 移除一个buff,并且包含移除buff图标\n            if (buff_data.group == 3703){   // 隐身buff\n                target.setOpacity(false);\n            }\n            if (buff_data.buff_spine && buff_data.buff_spine != \"\"){    // 移除变身效果\n                target.changeSpine(false);\n            }\n            // 如果是场景buff,则移除\n            var effect_config = Config.skill_data.data_get_effect_data[buff_data.res];\n            if (effect_config && effect_config.play_type == BattleConst.Effect_Play_Type.ROLE_SCENE){\n                this.removeSceneBuffEffect(target.group, effect_config.bid);\n            }\n            // 移除buff存在的特效绑在自身上的\n            if (effect_config){\n                this.removeBattleSpineEffect(target, effect_config);\n            }\n        }\n    },\n\n    // 添加一个场景buff特效\n    addSceneBuffEffect:function(group, bid, effect_res, effect){\n        if(group == null || bid == null || effect_res == null || effect == null) return;\n        var key = Utils.getNorKey(group, bid);\n        if (this.scene_buff_effect_list[key] == null){\n            this.scene_buff_effect_list[key] = {};\n        }\n        // 如果存在的话,先丢到对象池里面去\n        if (this.scene_buff_effect_list[key][effect_res]){\n            this.delBattleEffect(this.scene_buff_effect_list[key][effect_res]);\n        }\n        this.scene_buff_effect_list[key][effect_res] = effect;\n    },\n\n    // 移除一个场景buff特效\n    removeSceneBuffEffect:function(group, effect_bid){\n        if(group == null || effect_bid == null){\n            if (this.scene_buff_effect_list){\n                for(var key in this.scene_buff_effect_list){\n                    for(var res in this.scene_buff_effect_list[key]){\n                        var effect = this.scene_buff_effect_list[key][res];\n                        this.delBattleEffect(this.scene_buff_effect_list[key][effect]);\n                    }\n                }\n                this.scene_buff_effect_list = {};\n            }\n        }else{\n            var key = Utils.getNorKey(group, effect_bid);\n            var effect_list = this.scene_buff_effect_list[key];\n            if (effect_list){\n                for (var key in effect_list){\n                    this.delBattleEffect(effect_list[key]);\n                }\n            }\n            this.scene_buff_effect_list[key] = null;\n        }\n    },\n\n    // 移除一个绑在单位身上的buff特效,这里会根据特效配置去判断上下层特效资源\n    removeBattleSpineEffect:function(target, effect_config){\n        if(target == null || effect_config == null) return;\n        var action_name = PlayerAction.action;\n        if (effect_config.up_action_name != \"\"){\n            action_name = effect_config.up_action_name;\n        }\n        target.delBattleEffect(effect_config.res_up, action_name);  // 移除上层特效\n\n        action_name = PlayerAction.action;\n        if (effect_config.down_action_name != \"\") {\n            action_name = effect_config.down_action_name;\n        }\n        target.delBattleEffect(effect_config.res_down, action_name);  // 移除下层特效\n    },\n\n    // 播放buff效果,以及添加bufficon等\n    playBuffEffect:function(attacker, target, buff, buff_data){\n        if(buff == null || buff_data == null) return;\n        var text_color = null;\n        var outline_color = null;\n        if (buff_data.client_desc != \"\"){\n            if (buff.action_type == 1 || buff.action_type == 4){    // 增益\n                if (buff_data.positive_or_negative == 1) {\n                    text_color = 221\n                    outline_color = 222\n                } else if (buff_data.positive_or_negative == 2) {    // 减益\n                    text_color = 223\n                    outline_color = 224\n                } else if (buff_data.positive_or_negative == 3) {    // 控制\n                    text_color = 225\n                    outline_color = 226\n                }\n                this.showbuffName(target, buff_data.client_desc, text_color, outline_color, buff.buff_bid);\n            }\n        }\n        if (attacker == null) return;\n        var hadbuff = target.hadBuff(buff.id);\n        if (!hadbuff && buff.action_type == 1 && buff_data.res != 0){  // 不存在的buff才需要处理\n            var config = Config.skill_data.data_get_effect_data[buff_data.res];\n            if(config){\n                if(config.play_type == BattleConst.Effect_Play_Type.ROLE_SCENE){\n                    var key = Utils.getNorKey(target.group, buff_data.res)\n                    if (this.scene_buff_effect_list[key] == null || Utils.next(this.scene_buff_effect_list[key]) == false){\n                        this.effectArea(attacker, [config.res_up, config.res_down], 0, null, config.play_type, config.x_fix, config.y_fix, buff_data.res, config.is_col_effect, false);\n                    }\n                }else{\n                    this.effectSpineUser(attacker, (buff_data.is_release == 1), config.x_fix * target.obj_type, config.y_fix, [config.res_up, config.res_down], target, 1, null, buff_data.bid, buff_data.res);\n                }\n            }\n        }\n        // 一次效果\n        if(buff.action_type == 3 && buff_data.efftive_effect != 0){\n            var config = Config.skill_data.data_get_effect_data[buff_data.efftive_effect];\n            if(config){\n                this.effectSpineUser(attacker, true, config.x_fix * target.obj_type, config.y_fix, [config.res_up, config.res_down], target, 1, null, buff_data.bid, buff_data.res);\n            }\n        }\n    },\n\n    // 播放buff描述文字,这里需要对这个对象做判断,如果bid的飘字存在,则不处理了...\n    showbuffName:function(target, desc, color, outline_color, bid){\n        if (target == null || bid == null) return;\n        if (target.tips_list[bid]) return;\n        target.addTips(bid);\n        var callback = function(){\n            target.removeTips(bid);\n        }.bind(this);\n        this.playFontMessage(target, desc, null, null, null, color, outline_color, callback)\n    },\n\n    /**\n     * 添加召唤列表\n     * @param {*} list \n     * @param {*} attacker \n     */\n    addRoleList:function(list, attacker){\n        if(list == null || list.length == 0) return;\n    },\n\n    /**\n     * 处理子效果\n     * @param {*} effect_play \n     * @param {*} attacker \n     */\n    handleSubEffectPlaylist:function(effect_play, attacker){\n        if (effect_play == null || effect_play.sub_effect_play_list == null || effect_play.sub_effect_play_list.length == 0) return;\n        for (let index = 0; index < effect_play.sub_effect_play_list.length; index++) {\n            const element = effect_play.sub_effect_play_list[index];\n            var sub_target = this.real_role_list[element.sub_target];\n            if (sub_target) {\n                // 播放气血变化的\n                this.battleRoleHPChange(sub_target, element.sub_hp_changed, false, 1, true);\n                if (element.extra_effect && element.extra_effect.length > 0){\n                    for (let n = 0; n < element.extra_effect.length; n++) {\n                        const extra = element.extra_effect[n];\n                        if (extra.extra_key == 2){   // 护盾吸收\n                            this.skill_act.playBuffAbsorbHurt(sub_target, extra.extra_param);\n                        }\n                    }\n                }\n                // 技能效果是否飘字\n                var effect_config = gdata('skill_data', 'data_get_effect', element.sub_effect_id);\n                if (effect_config && effect_config.effect_desc != \"\" && element.sub_is_hit != 0){\n                    this.showbuffName(sub_target, effect_config.effect_desc, 229, 230, element.sub_effect_id);\n                }\n                // 被动技能是否飘字\n                var skill_config = gdata('skill_data', 'data_get_skill', element.sub_skill_id); \n                if (skill_config && skill_config.passive_skill_show == 1) {\n                    this.showbuffName(sub_target, skill_config.name, 217, 218, element.sub_skill_id);\n                }\n                // 闪躲处理\n                if (element.sub_is_hit == 0 && effect_play.is_dead == 0){\n                    this.showbuffName(sub_target, Utils.TI18N(\"躲闪\"), 227, 228, element.sub_effect_id);\n                }\n            }\n        }\n    },\n\n    /**\n     * 副本数据特殊处理\n     * @param {*} effect_play \n     */\n    handleExtendDungeon:function(effect_play){\n        if (this.battle_data == null || this.battle_data.combat_type != BattleConst.Fight_Type.GuildDun) return;\n        if(this.form_fight_ui){\n            this.form_fight_ui.addGuildBossUI(effect_play.total_hurt)\n        }\n    },\n\n    /**\n     * 处理援护\n     * @param {*} effect_play \n     * @param {*} attacker \n     * @param {*} effect_hit 是否暴击\n     * @param {*} target\n     */\n    handleAidActor:function(effect_play, attacker, effect_hit, target){\n        if (effect_play == null || effect_play.aid_actor == 0) return;\n        var aid_target = this.real_role_list[effect_play.aid_actor];\n        if (aid_target){\n            var aid_dmg = effect_play.actor_hp_changed;     // 援护者血量变化\n            var friend_pos = target.scene_pos;              // \n            var role_width = target.model_width * target.obj_type;\n            var camp_restrain = effect_play.camp_restrain;  // 是否是阵营压制\n            aid_target.setLocalZOrder(target.getLocalZOrder() + 1);     // 层级放到上面来\n            aid_target.setScenePos(cc.v2(friend_pos.x + role_width, friend_pos.y)); // 设置援护坐标\n            this.actStart(attacker);\n            this.skill_act.aid_hurt(attacker, aid_target, \"hurt\");\n            this.battleRoleHPChange(aid_target, aid_dmg, effect_play.actor_is_dead, effect_hit, false, camp_restrain);\n            this.playHurtEffect(attacker, aid_target);\n        }\n    },\n\n    /**\n     * 播放伤害特效\n     * @param {*} attacker \n     * @param {*} target \n     */\n    playHurtEffect:function(attacker, target){\n        if(this.battle_scene == null || attacker == null || attacker.hit_effect_list == null || attacker.hit_effect_list.length == 0){\n            return;\n        }\n        const array = attacker.hit_effect_list;\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            this.effectSpineUser(attacker, true, element.x_fix * attacker.obj_type, element.y_fix, [element.res_up, element.res_down], target, element.scale * 0.001, null, element.bid);\n        }\n    },\n\n    /**\n     * 出手前动作\n     * @param {*} attacker \n     */\n    attackReady:function(attacker){\n        if(attacker == null){\n            return;\n        }\n        if(attacker.bact_effect_list == null || attacker.bact_effect_list.length == 0){\n            return;\n        }\n        // 播放出手前音效\n        if (attacker.ready_sound && attacker.ready_sound != \"\" && attacker.is_real == true ) {\n            Utils.playEffectSound(AUDIO_TYPE.BATTLE, attacker.ready_sound);\n        }\n        const array = attacker.bact_effect_list;\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            if(element && element.play_type == BattleConst.Effect_Play_Type.ROLE){\n                if(element.res_up != \"\" || element.res_down != \"\"){                   \n                    this.effectSpineUser(attacker, true, element.x_fix*attacker.obj_type, element.y_fix, [element.res_up, element.res_down], attacker, element.scale*0.001, null, element.bid);\n                }\n            }\n        }\n    },\n\n    /**\n     * 创建单位跟随特效\n     * @param {*} attacker \n     * @param {*} is_release \n     * @param {*} x_fix \n     * @param {*} height \n     * @param {*} effect_list\n     * @param {*} target 目标对象,也可能是自己,也可能是被攻击者 \n     * @param {*} scale \n     * @param {*} callback \n     * @param {*} bid \n     * @param {*} buff_bid 如果这个值不为0,即最终值\n     */\n    effectSpineUser: function (attacker, is_release, x_fix, height, effect_list, target, scale, callback, bid, buff_bid){\n        if (buff_bid && buff_bid != 0){\n            bid = buff_bid\n        }\n        var obj_type = BattleConst.Battle_Type_Conf.TYPE_ROLE;\n        if (attacker){\n            obj_type = attacker.obj_type;\n        }\n        this.skill_act.effectSpineUser(attacker, is_release, x_fix, height, effect_list, target, scale, callback, bid, obj_type);\n    },\n\n    // 群攻\n    areaHurt:function(attacker){\n        var hurt_func = (function(){\n            if(this.battle_scene){\n                var role_list = this.getAllBattleRoleList();\n                for (var key in role_list){\n                    const role = role_list[key];\n                    if (role) {\n                        role.is_hurt_play = false\n                        role.is_big_play = false\n                    }\n                }\n            }\n            this.batchPlayHurt(attacker);\n        }).bind(this);\n        this.playSceneAreaEffect(attacker, hurt_func);\n    },\n\n    // 播放范围特效\n    playSceneAreaEffect:function(attacker, callback){\n        if(attacker == null || attacker.play_order_index == null || attacker.area_effect_list == null || attacker.area_effect_list.length == 0){\n            return;\n        }\n        var array = attacker.area_effect_list;\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            if (element && (element.res_down != \"\" || element.res_up != \"\")){\n                this.effectArea(attacker, [element.res_up, element.res_down], 0, callback, element.play_type, element.x_fix, element.y_fix, element.bid, element.is_col_effect)\n            }        \n        }\n    },\n\n    /**\n     * 播放范围特效\n     * @param {*} attacker \n     * @param {*} effect_list\n     * @param {*} height \n     * @param {*} is_reverse \n     * @param {*} hit_callback \n     * @param {*} play_type \n     * @param {*} x_fix \n     * @param {*} y_fix \n     * @param {*} bid \n     * @param {*} is_col_effect\n     * @param {*} is_release 播完是否释放\n     */\n    effectArea:function(attacker, effect_list, height, hit_callback, play_type, x_fix, y_fix, bid, is_col_effect, is_release){\n        height = height || 0;\n        var reverse = attacker.obj_type;\n        var is_left = attacker.is_friend;\n        var scene_pos = null;\n        if (is_col_effect == 1){\n            var temp_list = null;\n            if(is_left){\n                temp_list = [{x:34,y:17},{x:34,y:23},{x:34,y:29}]\n            }else{\n\t\t\t    temp_list = [{x:44,y:17},{x:44,y:23},{x:44,y:29}]\n            }\n            var pos = temp_list[attacker.col]\n            if(pos){\n                var temp_pos = this.skill_act.gridPosToScreenPos(pos);\n                scene_pos = { x: temp_pos.x + x_fix, y: temp_pos.y + y_fix};\n            }\n        }else{\n            if (play_type == BattleConst.Effect_Play_Type.SCENE){           // 暂时看到是作废的\n                scene_pos = {x: SCREEN_WIDTH*0.5, y: SCREEN_HEIGHT*0.5}\n            } else if (play_type == BattleConst.Effect_Play_Type.ROLE_SCENE || play_type == BattleConst.Effect_Play_Type.ENEMY_SCENE){\n                x_fix = attacker.obj_type * x_fix;\n                if(is_left){\n                    if (play_type == BattleConst.Effect_Play_Type.ROLE_SCENE){  //  友方阵型\n                        scene_pos = {x: SCREEN_WIDTH * 22 / 100 + x_fix, y: SCREEN_HEIGHT * 1 / 4 + y_fix}\n                    }else{                                              // 敌方阵型\n                        scene_pos = {x: SCREEN_WIDTH * 78 / 100 + x_fix, y: SCREEN_HEIGHT * 1 / 4 + y_fix}\n                    } \n                }else{\n                    if (play_type == BattleConst.Effect_Play_Type.ENEMY_SCENE){\n                        scene_pos = {x: SCREEN_WIDTH * 22 / 100 + x_fix, y: SCREEN_HEIGHT * 1 / 4 + y_fix}\n                    }else{\n                        scene_pos = {x: SCREEN_WIDTH * 78 / 100 + x_fix, y: SCREEN_HEIGHT * 1 / 4 + y_fix}\n                    }\n                }\n            }else{\n                scene_pos = this.center_pos(attacker);\n            }\n        }\n        if (scene_pos){\n            scene_pos.y = scene_pos.y + height;\n            this.skill_act.effectArea(attacker, effect_list, reverse, is_release, scene_pos, hit_callback, bid)\n        }\n    },\n\n    // 获取施法者目标对象的中心位置\n    center_pos: function (attacker, height_fix){\n        height_fix = height_fix || 0;\n        var scene_pos = {x:0, y:0}\n        if (this.battle_scene && attacker && attacker.attacker_info && attacker.attacker_info.target_list && attacker.attacker_info.target_list.length > 0){\n            var array = attacker.attacker_info.target_list\n            for (let index = 0; index < array.length; index++) {\n                const element = array[index];\n                const target = this.getBattleRoleByPos(element.target)\n                if (target && target.scene_pos){\n                    scene_pos.x = target.scene_pos.x;\n                    scene_pos.y = target.scene_pos.y + target.model_height * height_fix * 0.01;   // 这个计算位置好奇葩..竟然不是直接用偏移高度去算..\n                    break;\n                }\n            }\n        }\n        return scene_pos;\n    },\n\n    // 播放攻击动作之类的\n    actHurt:function(attacker, is_big){\n        if (attacker == null || attacker.attacker_info == null || attacker.attacker_info.target_list == null) return;\n        var had_play = false;\n        for (let index = 0; index < attacker.attacker_info.target_list.length; index++) {\n            const effect_list = attacker.attacker_info.target_list[index];\n            var play_effect = false;\n            if (effect_list.hp_changed && effect_list.hp_changed < 0 && had_play == false){\n                had_play = true;\n                play_effect = true;\n            }\n            this.playMagic2(attacker, effect_list, is_big, play_effect)\n        }\n    },\n\n    // 提前播放受击特效,回播受击动作\n    playMagic2:function(attacker, effect_play, is_big, play_effect){\n        if(attacker == null || effect_play == null) return;\n        var target = this.real_role_list[effect_play.target];\n        if (target == null) return;\n\n        if (is_big == true){\n            if(!target.is_big_play){\n                target.is_big_play = true;\n                this.playHurtEffect(attacker, target);\n            }\n        }else{\n            if (attacker.pos != target.pos && attacker.group != target.group){\n                this.skill_act.hurt(attacker, target, PlayerAction.hurt, play_effect)\n            }\n        }\n    },\n\n    // 攻击上层特效处理\n    attackPoint:function(attacker){\n        if (attacker && attacker.attack_sound != \"\" && attacker.is_real == true){\n            Utils.playEffectSound(AUDIO_TYPE.BATTLE, attacker.attack_sound);\n        }\n\n        if(attacker.act_effect_list == null || attacker.act_effect_list.length == 0){\n            return;\n        }\n        var is_friend = attacker.is_friend;\n        var array = attacker.act_effect_list;\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            var anime_res_up = element.res_up;\n            if (element.spec_res_up != \"\" && is_friend == true) {\n                anime_res_up = element.spec_res_up;\n            }\n            if (anime_res_up != \"\" || element.res_down != \"\"){\n                this.effectSpineUser(attacker, true, element.x_fix * attacker.obj_type, element.y_fix, [anime_res_up, element.res_down], attacker, element.scale * 0.001, null, element.bid);\n            }\n        }\n    },\n\n    /**\n     * 处理普通伤害\n     * @param {*} attacker \n     * @param {*} role_list \n     */ \n    hurt: function (attacker, object_list){\n        if (this.battle_scene == null || attacker == null){\n            return;\n        }\n        if (attacker.area_effect_list.length == 0){\n            var hit_num = (!attacker.in_area_effect) ? attacker.hit_num : (attacker.area_hit_num || 1);\n            var split_hurt = attacker.split_hurt || 1;\n            if (hit_num == 1 || split_hurt > 1){\n\n            }else{\n                var role_list = object_list || this.getAllBattleRoleList();\n                for (var key in role_list){\n                    const role = role_list[key];\n                    if (role) {\n                        role.is_hurt_play = false;\n                        role.is_big_play = false;\n                    }\n                }\n            }\n            this.batchPlayHurt(attacker)\n        }\n    },\n\n    /**\n     * 伤害一个人的时候\n     * @param {*} attacker \n     */\n    hurtOne:function(attacker){\n        if(this.checkIsInBattle(attacker) == false){\n            return\n        }\n        var effect_play_num = attacker.attacker_info.target_list.length;\n        if (effect_play_num > 0){\n            if (attacker.is_real){\n\t\t\t    this.playMagic(attacker, attacker.attacker_info.target_list[0]);\n            }else{\n                this.hook_model.playMagic(attacker, attacker.attacker_info.target_list[0]);\n            }\n        }\n    },\n\n    // 隐藏血条\n    hideUI:function(attacker, delay_time){\n        if(attacker){\n            return this.skill_act.hideUI(attacker, delay_time);\n        }\n    },\n\n    // 无动作并行攻击\n    noActAttack:function(attacker, delay_time, hit_fun, start_fun, next_delay_time){\n        if(!this.getBattleScene()) return;\n        if(!attacker) return;\n        var start_callback = function(){\n            this.callfun(attacker, start_fun);\n        }.bind(this);\n\n        var hit_callback = function(){\n            this.callfun(attacker, hit_fun);\n        }.bind(this);\n        return this.skill_act.noActAttack(attacker, delay_time, hit_callback, start_callback, next_delay_time);\n    },\n\n    // 显示血条\n    showUI:function(attacker, delay_time){\n        if(attacker){\n            return this.skill_act.showUI(attacker, delay_time);\n        }\n    },\n\n    // 判断是否存在反击buff\n    getBuffTag:function(attacker){\n        if(attacker == null || attacker.buff_list == null || attacker.buff_list.length == null){\n            return false;\n        }\n        var array = attacker.buff_list;\n        for (let index = 0; index < array.length; index++) {\n            const element = array[index];\n            const config = Config.skill_data.data_get_buff[element.bid]\n            if (config && config.group == 3108){\n                return true;\n            }\n        }\n        return false;\n    },\n    \n    // 近战移动归位\n    moveBack:function(attacker, delay_time, move_time, grid_pos_x, action_name, is_jump, is_jump_delay, is_get_point, is_move, is_reverse){\n        if(!this.getBattleScene()) return;\n        if(!attacker) return;\n        var target_pos = attacker.scene_pos;\n        var skill_act = this.skill_act.move(attacker, target_pos, delay_time, move_time);\n        attacker.runAction(skill_act);\n    },\n\n    // 移动到指定区域\n    moveToArea:function(attacker, config){\n        if(!this.getBattleScene()) return;\n        if(!attacker) return;\n        if(!config) return;\n        var grid_pos_x = config.move_model_x * this.skill_act.gridSizeX();\n        var grid_pos_y = config.move_model_y * this.skill_act.gridSizeY();\n        var target_pos = { x: SCREEN_WIDTH * 32 / 64 + grid_pos_x * attacker.obj_type, y: SCREEN_HEIGHT * 11 / 36 + grid_pos_y };\n        var skill_act = this.skill_act.move(attacker, target_pos, config.move_delay_time, config.move_time);\n        attacker.runAction(skill_act);\n    },\n\n    // act_args={ [[moveTo]],{ 0, 10,- 7, 0, [[run]], 0, 0, 0, 1, 1}}},\n\n    // 移动到目标处\n    moveTo:function(attacker, delay_time, move_time, grid_pos_x, grid_pos_y, action_name, is_jump, is_jump_delay, is_get_point, is_move, is_reverse, is_col_act){\n        if(!this.getBattleScene()) return;\n        if(!attacker) return;\n        move_time = move_time || 30;\n        if (grid_pos_x == null){\n            grid_pos_x = 0;\n        }\n        if (grid_pos_y == null){\n            grid_pos_y = 0;\n        }\n        var direct = (is_reverse == 1) ? -1 : 1;\n        var target_pos = null;\n        var scene_pos = attacker.scene_pos;\n        if (is_col_act == 1) {\n            var is_left = attacker.is_friend;         // 是否是己方,己方就是在左边\n            var temp_list = null;\n            if (is_left) {\n                temp_list = [{ x: 34, y: 17 }, { x: 34, y: 23 }, { x: 34, y: 29 }]\n            } else {\n                temp_list = [{ x: 44, y: 17 }, { x: 44, y: 23 }, { x: 44, y: 29 }]\n            }\n            var pos = temp_list[attacker.col]\n            if (pos) {\n                var temp_pos = this.skill_act.gridPosToScreenPos(pos);\n                target_pos = { x: temp_pos.x + grid_pos_x, y: temp_pos.y + grid_pos_y };\n            }\n        } else if (grid_pos_x > 0) {\n            target_pos = { x: scene_pos.x + grid_pos_x * attacker.obj_type * direct, y: scene_pos.y + grid_pos_y };\n        } else {\n            if (is_reverse == 1 && attacker.target_pos_base) { // 反转\n                target_pos = this.skill_act.gridPosToScreenPos({ x: attacker.target_pos_base.x + grid_pos_x * attacker.obj_type * direct, y: attacker.target_pos_base.y + grid_pos_y * attacker.obj_type * direct })\n            } else {\n                target_pos = this.skill_act.gridPosToScreenPos({ x: attacker.target_pos.x + grid_pos_x * attacker.obj_type * direct, y: attacker.target_pos.y + grid_pos_y })\n            }\n        }\n        if ( is_get_point == null || is_get_point == 0){\n            var skill_act = this.skill_act.move(attacker, target_pos, delay_time, move_time);\n            attacker.runAction(skill_act);\n        }else{\n            return this.skill_act.move(attacker, target_pos, delay_time, move_time);\n        }\n    },\n\n    // 一些播报判断\n    checkIsInBattle:function(attacker){\n        if(this.battle_scene == null || attacker == null){\n            return false;\n        }\n        return true;\n    },\n\n    // -------------------------------创景单位这一块,真是战斗单位\n    createRoleList:function(){\n        var battle_data = this.battle_data;\n        var need_enter = this.needPlayEnterAction();\n        for (var key in battle_data.fight_object_list) {\n            var role_data = battle_data.fight_object_list[key];\n            this.createRole(role_data, need_enter, true, true)\n        }\n    },\n\n    // 创建具体单位\n    createRole:function(role_data, enter_run, talk_back, is_real){\n        if (this.battle_scene == null) return;\n        if (role_data == null || role_data.hp == 0) return;\n        var role_layer = this.battle_scene.getBattleRoleLayer();\n        if (role_layer == null) return;\n        if(this.real_role_list[role_data.pos] != null) return;\n\n        var role = Utils.createClass(\"battle_role\");\n        role.createRole(role_layer, role_data, enter_run, talk_back, is_real);\n        this.real_role_list[role_data.pos] = role;\n    },\n\n    // 重置战斗单位初始化信息,比如位置层级和动作状态\n    resetBattleRoleBaseInfo:function(){\n        for(var key in this.real_role_list){\n            var battle_role = this.real_role_list[key];\n            if (battle_role){\n                battle_role.resetBaseInfo();\n            }\n        }\n    },\n\n    // 清楚掉单位\n    clearRealRole: function () {\n        if (Object.keys(this.real_role_list).length == 0) { return; }\n        for (var key in this.real_role_list) {\n            // 清楚掉定时器\n            gcore.Timer.del(\"attackerActTimeout\" + key);\n\n            var battle_role = this.real_role_list[key];\n            if(battle_role){\n                battle_role.deleteRole();\n                battle_role = null;\n            }\n        }\n        this.real_role_list = {};\n    },\n\n    // 当前所有单位\n    getAllBattleRoleList:function(){\n        return this.real_role_list;\n    },\n\n    // 指定单位上的对象\n    getBattleRoleByPos: function (pos) {\n        if (this.real_role_list[pos]) {\n            return this.real_role_list[pos]\n        }\n    },\n\n    // 魅魔技能黑屏,暂时也没配置了\n    blackScreen: function (attacker) {\n\n    },\n\n    // 只显示攻击于被攻击放,暂时都没有配置\n    blackScreen2: function (attacker) {\n\n    },\n\n    // 黑屏------后续一律使用这个黑屏\n    blackScreen3: function (attacker, delay_time, time, alpha) {\n        if(time == null){\n            time = 15;\n        }\n        var begin_fun = function(){\n            if(this.battle_scene){\n                this.battle_scene.setBlack(true, alpha);\n            }\n            this.is_black = true;\n        }.bind(this);\n\n        var end_fun = function(){\n        }.bind(this);\n        return this.skill_act.blackScreen(attacker, delay_time, time, begin_fun, end_fun);\n    },\n\n    // 取消黑屏\n    cancleBlackScreen:function(){\n        this.is_black = false;\n        if(this.battle_scene){\n            this.battle_scene.setBlack(false);\n        }\n    },\n\n    // 震屏\n    playShakeScreen:function(shake_id){\n        if(shake_id == null || shake_id == 0) return;\n        if(this.battle_scene){\n            this.battle_scene.shakeScreen(shake_id);\n        }\n    },\n\n    // 隐身,暂时没有配置了\n    hide: function (attacker) {\n\n    },\n\n    // 显示,暂时也没有配置了\n    show: function (attacker) {\n\n    },\n\n    // 残影,也是没有配置了\n    shadow: function (attacker) {\n\n    },\n\n    // 返回主界面控制器\n    getMainUICtrl:function(){\n        if(this.mainui_ctrl == null){\n            this.mainui_ctrl = require(\"mainui_controller\").getInstance();\n        }\n        return this.mainui_ctrl;\n    },\n\n    // -------------------------战斗结束\n    //结算界面\n    showWin: function (data, is_replay) {\n        if(data.show_panel_type == null || data.combat_type == null) return;\n        if (data.show_panel_type == 1){     // 显示战斗结算界面,这个时候不要立即清除掉,\n            if ((data.combat_type == this.combat_type && this.battle_controller.getWatchReplayStatus()) || is_replay == true){\n\n            }\n            // 这个时候都需要显示结算界面\n            this.setBattleTimeScale(true);\n            this.showWinView(data);\n        } else {\n            if (data.combat_type == this.combat_type){  // \n                if (is_replay == true){\n                    this.clearView();\n                } else {\n                    this.clearBattleScene();\n                    gcore.GlobalEvent.fire(EventId.EXIT_FIGHT, data.combat_type);\n                }\n            }\n        }\n    },\n\n    //游戏退出结算\n    showWinView:function(data){\n        if(data == null)return\n        this.battle_controller.openFinishView(true, data.combat_type,data);\n    },\n\n    //战斗结果\n    result:function(data,is_self_exit){\n        if (data == null) return;\n        if (this.cur_fight_type == 2 && this.combat_type == data.combat_type){\n            this.clearView();\n        } \n    },\n\n    clearView:function(){\n        this.setBattleTimeScale(true);      // 还原动作速率\n        if (this.battle_controller.getWatchReplayStatus() == true){ // 如果是录像状态下,退出录像\n            this.battle_controller.setWatchReplayStatus(false)\n        }\n\n        // 派发退出战斗事件,通知各个系统处理\n        gcore.GlobalEvent.fire(EventId.EXIT_FIGHT, this.combat_type);\n\n        var MainuiController = require(\"mainui_controller\")\n        if(this.combat_type == BattleConst.Fight_Type.Darma){\n            if (MainuiController.getInstance().checkIsInDramaUIFight()) {       // 剧情副本中结束战斗,则切到假战斗\n                this.battle_controller.send20060(BattleConst.Fight_Type.Darma);\n            }\n        }else{\n            if (this.battle_controller.getWatchReplayStatus() == true || this.combat_type == BattleConst.Fight_Type.PK || this.combat_type == BattleConst.Fight_Type.HeroTestWar) {\n                if (MainuiController.getInstance().checkIsInDramaUIFight()) {       // 剧情副本中结束战斗,则切到假战斗\n                    this.battle_controller.send20060(BattleConst.Fight_Type.Darma);\n                }else{\n                    this.clearBattleScene();\n                }\n            }else{\n                this.clearBattleScene();\n            }\n        }\n    },\n\n    // 播放资产掉落的动作\n    playResourceCollect:function(x, y, pos){\n        if (this.drama_fight_ui){\n            this.drama_fight_ui.playResourceCollect(x, y, pos);\n        }\n    },\n    //获取group\n    getGroup(){\n        return this.my_group\n    },\n    getCampIconConfigByIds(id_list){\n        if(!id_list || Utils.next(id_list) == null) return;\n        if(id_list.length == 1){\n            let id = id_list[0]\n            return Config.combat_halo_data.data_halo_icon[id]\n        }else{\n            let min_id = Math.min(id_list[0], id_list[1])\n            let max_id = Math.max(id_list[0], id_list[1])\n            let id = min_id*100 + max_id\n            return Config.combat_halo_data.data_halo_icon[id]\n        }\n    },\n\n\n    getEffectRes: function(effect_id) {\n\n    },\n\n\n    // 开始准备战斗资源\n    preloadBattleRes: function(data, finish_cb) {\n        // skill_plays\n        var battle_res = {};\n        for (var skill_i in data.skill_plays) {\n            var skill_data = data.skill_plays[skill_i]\n            for (var effect_i in skill_data.effect_play) {\n                var effect_data = skill_data.effect_play[effect_i];\n                if (!effect_data.effect_bid)\n                    continue;\n                var effect_config = gdata('skill_data', 'data_get_effect', effect_data.effect_bid);\n\n                if (!effect_config) {\n                    continue;\n                }\n\n                var actor = this.real_role_list[effect_data.actor];\n                var target = this.real_role_list[effect_data.target];\n\n                // 攻击动作资源\n                if (effect_config.anime_res && actor) {\n                    var anime_res_path = actor.getResPath(effect_config.anime_res);\n                    if (anime_res_path) {\n                        battle_res[anime_res_path] = true;\n                    }\n                }\n\n                // 受击动作资源\n                if (effect_config.hit_action && target) {\n                    if (effect_config.hit_action != \"no-hurt\") {                    \n                        var hit_action_path = target.getResPath(effect_config.hit_action);\n                        if (hit_action_path) {\n                            battle_res[hit_action_path] = true;\n                        }\n                    }\n                }\n\n                // 特效资源加载\n                for (var effect_d in AniRes) {\n                    var effct_list = Utils.deepCopy(this.getCurEffectList(effect_config[AniRes[effect_d]]));\n                    for (var effect_i in effct_list) {\n                        var effect_info = effct_list[effect_i];\n                        if (effect_info.res_up) {\n                            var action_name = PlayerAction.action;\n                            // if (effect_info.up_action_name)\n                            //     action_name = effect_info.up_action_name;\n                            var res_path = \"spine/\" + effect_info.res_up + \"/\" + action_name;\n                            battle_res[res_path] = true;\n                        }\n\n                        if (effect_info.res_down) {\n                            var action_name = PlayerAction.action;\n                            // if (effect_info.down_action_name) {\n                            //     action_name = effect_info.down_action_name;\n                            // }\n                            var res_path = \"spine/\" + effect_info.res_down + \"/\" + action_name;                            \n                            battle_res[res_path] = true;                            \n                        }\n\n                    }\n                }\n\n\n            }\n        }\n\n        var total_num = 0;\n        var finish_num = 0;\n\n        for (var battle_i in battle_res) {\n            total_num ++;\n        }\n\n        for (var battle_i in battle_res) {\n            var skeleton_path = battle_i + \".atlas\";\n            BattleResPool.getInstance().preLoadRes(skeleton_path, function (skeleton_path, res_object) {\n                finish_num ++;\n                if (finish_num == total_num) {\n                    if (finish_cb)\n                        finish_cb();\n                }\n            }.bind(this, skeleton_path))         \n        }\n\n        if (total_num == 0) {\n            if (finish_cb)\n                finish_cb();\n        }\n    },\n\n});\n\nmodule.exports = BattleModel;\n"]}