// --------------------------------------------------------------------
// @author: shiraho@syg.com(必填, 创建模块的人员)
// @description:
//      战斗单位实例对象
// <br/>Create: new Date().toISOString()
// --------------------------------------------------------------------

var BattleRolePool = require("battle_role_pool");
var BattleResPool = require("battle_res_pool");
var LoaderManager = require("loadermanager");
var PathTool = require("pathtool")
var BattleConst = require("battle_const");
var BattleEffect = require("battle_effect");

var BattleRole = cc.Class({
    extends: BaseClass,

    properties: {
        skelon_cache: {
            default: {}
        }
    },

    ctor:function(){
        // 假战斗才需要,当前这一排是否有其他单位,确定初始位置
        if (arguments && arguments.length > 0){
            this.is_next_offset = arguments[0];
        }else{
            this.is_next_offset = false;
        }         
        this.initConfig();
    },
    
    initConfig:function(){
        this.role = null;
        this.parent = null;
        this.prefabPath = PathTool.getPrefabPath("battle", "battle_real_role");
        this.role_data = null;

        this.top_off_y = 45;                    // 血条向上的偏移量

        this.is_real = false;                   // 是否是真战斗单位
        this.play_enter = false;                // 是否需要播放进场动画
        this.talk_back = false;                 // 是否需要通知播放完成

        this.grid_pos = null;                   // 格子坐标,
        this.scene_pos = null;                  // 场景坐标
        this.is_friend = false;                 // 是否是友方
        this.obj_type = 0;                      // 是己方还是敌方
        // this.skeletonData_list = {}             // 动作列表
        this.model_height = 120;                // 模型的高度
        this.model_width = 60;                 // 模型的宽度,暂时先这样,后面加接口计算

        this.pos = 0;                           // 当前站位
        this.group = 0;                         // 当前分组

        this.spine_name = "";                   // 单位资源名字 ,H10000这种
        this.play_action_name = "";             // 当前动作名字,

        this.is_round = false;                  // 当前技能播报是否播放完成
        this.effect_list = {};                  // 挂在身上的特效列表

        this.hp_show_status = true;             // 是否显示或者隐藏血条

        this.is_die = false;                    // 该单位是否是死亡 == role_data.hp == 0
        this.role_cur_zorder = 0;               // 当前单位深度值

        this.in_hurt_act = false;               // 是否在播放受击效果中
        this.need_play_die = false;             // 需要播放死亡动作

        var BattleController = require("battle_controller");
        this.model = BattleController.getInstance().getModel();
        this.hook_model = BattleController.getInstance().getHookModel();
        this.skill_act = require("skill_act");

        this.wait_action_name = null;
        this.wait_res_name = null;
        this.wait_is_loop = null;

        this.tips_list = {};                    // 当前飘字记录
        this.buff_list = {};                    // 当前buff列表信息,以唯一id作为key
        this.buff_list_data = {};               // 当前buff信息,以buff_config.icon作为key
        this.buff_list_item = {};               // 当前buff的实例化显示对象,以buff_config.icon作为key

        this.action_call_list = {};             // 制动动作回调

        this.wait_add_effect_list = {};         // 待添加特效
        this.resources_list = {};            // 下载资源

        this.dmg_index = 0;                     // 当前伤害数字的个数
    },

    /**
     * 创建战斗单位
     * @param {*} parent 所在父节点
     * @param {*} battle_role_data 对象基础数据,BattleRoleData
     * @param {*} play_enter 是否需要播放进场动画
     * @param {*} talk_back 是否需要通知进场完成
     * @param {*} is_real 是否是真实战斗
     * @param {*} finish_cb 创建完成之后的回调
     */
    createRole:function(parent, battle_role_data, play_enter, talk_back, is_real, finish_cb){
        this.parent = parent;
        this.role_data = battle_role_data;
        // this.play_enter = play_enter || false;
        this.play_enter = false;        
        this.finish_cb = finish_cb;
        if (!is_real)
            this.play_enter = false;

        this.talk_back = talk_back || false;
        this.is_real = is_real || false;
        this.pos = battle_role_data.pos;
        this.group = battle_role_data.group;

        let pools = BattleRolePool.getInstance().getRealPools()
        let role = null;
        if (pools.size() > 0){
            role = pools.get();
            this.createRootWnd(role);
        }else{
            LoaderManager.getInstance().loadRes(this.prefabPath, (function(res_object){
                role = res_object;
                this.createRootWnd(role);
            }).bind(this))
        }
    },
    // 初始化状态
    resetInitStatus: function () {
        if (this.skeleton) {
            this.skeleton.setToSetupPose();
            this.skeleton.clearTracks();
        }
    },

    // 初始化创建对象
    createRootWnd: function (role) {
        let valid  = this.parent && this.parent.isValid && role && role.isValid ? true : false;
        if(!valid)return;
        this.role = role;
        if (this.parent) {
            this.parent.addChild(this.role);
        }
        this.role_node = this.role.getChildByName("role_node");                         // 模型节点
        this.container = this.role_node.getChildByName("container");                    // spine节点
        this.top_container = this.role_node.getChildByName("top_container");            // 血条部分
        this.shadow = this.role_node.getChildByName("shadow");                          // 脚底阴影

        this.progress = this.top_container.getChildByName("hp").getComponent(cc.ProgressBar);
        this.level = this.top_container.getChildByName("level").getComponent(cc.Label);
        this.camp = this.top_container.getChildByName("camp").getComponent(cc.Sprite);
        this.buff_container = this.top_container.getChildByName("buff_container");      // buff的主节点

        this.hallow_node = this.role.getChildByName("hallow_node");             // 神器节点
        this.round_progress = this.hallow_node.getChildByName("progress").getComponent(cc.ProgressBar); // 回合进度条

        // 神器和模型区分
        if (this.role_data.object_type == BattleConst.Unit_Type.Hallows){
            this.spine = this.hallow_node.getChildByName("spine");
            this.skeleton = this.spine.getComponent(sp.Skeleton);
            this.role_node.active = false;
            this.hallow_node.active = true;
            // 更新神器
            this.setHallowsRound(this.role_data.hallows_val, this.role_data.hallows_max);
        }else{
            this.spine = this.container.getChildByName("spine");
            this.skeleton = this.spine.getComponent(sp.Skeleton);
            this.effect = this.container.getChildByName("effect");          // 10星光环特效

            this.hallow_node.active = false;
            this.role_node.active = true;
            // this.setActive(true);
            // 真实战斗才需要显示这些东西
            if (this.is_real) {
                this.level.string = this.role_data.lev;
            } else {
                this.role.active = false;
            }
        }
        this.spine_zorder = this.spine.zIndex;

        // 设置当前的模型速率
        if (this.skeleton_time_scale){
            this.skeleton.timeScale = this.skeleton_time_scale;
            this.setEffectScale(this.skeleton_time_scale);
            this.skeleton_time_scale = null;
        }else{
            var timeScale = this.model.getTimeScale();
            this.skeleton.timeScale = timeScale;
            this.setEffectScale(timeScale);
        }

        // 监听事件
        this.registerEvent();
        // 初始化
        this.resetInitStatus();
        // 设置当前位置
        this.setGridPos();
        // 实例化模型
        this.instantModelRole();
        // 设置气血
        this.setHP(0);
        // 看看有没有待添加的特效
        this.checkEffectNeedAdd();
    },

    // 设置10星特效的播放速率
    setEffectScale:function(time_scale){
        if (this.effect_skeleton){
            // this.effect_skeleton.timeScale = time_scale;
        }
    },

    registerEvent:function(){
        this.skeleton.setCompleteListener((function (trackEntry, loopCount) {
            var animationName = trackEntry.animation ? trackEntry.animation.name : "";
            var action_object = this.action_call_list[animationName];
            if (action_object && action_object.over){
                action_object.over(animationName);
                this.action_call_list[animationName] = null;
            }
        }).bind(this))

        this.skeleton.setEventListener((function (trackEntry, event) {
            var animationName = trackEntry.animation ? trackEntry.animation.name : "";
            var action_object = this.action_call_list[animationName];
            if (action_object && action_object.event){
                action_object.event(event.data.name);
            }
        }).bind(this))
    },

    // 设置角色格子位置,这个是要确定站位是在左边还是在右边
    setGridPos:function(){
        var is_friend = false;
        if (this.role_data == null){ return; }
        if (this.role == null){ return; }
        // 站位要区分真假战斗
        if (this.is_real == true){
            is_friend = this.model.isFriend(this.role_data.group);
        }else{
            is_friend = (this.role_data.group == 1);
        }
        if(is_friend){
            this.obj_type = BattleConst.Battle_Type_Conf.TYPE_ROLE
        }else{
            this.obj_type = BattleConst.Battle_Type_Conf.TYPE_ENEMY
        }
        this.is_friend = is_friend;

        // 非己方的需要反转处理
        if (this.is_friend == false){
            this.spine.scaleX = -1;
        }else{
            this.spine.scaleX = 1;
        }
        // 获取当前格子站位
        this.grid_pos = this.skill_act.newPos2Gird(this.role_data.pos, is_friend, this.role_data.group, this.is_real);
        this.scene_pos = this.skill_act.gridPosToScreenPos(this.grid_pos);
        this.role.setPosition(this.scene_pos);
        this.resetZOrder();
    },

    // 设置坐标
    setScenePos:function(pos){
        this.role.setPosition(pos);
    },

    // 是否需要反转劫色,因为可能存在背刺技能
    reverse:function(rev){
        rev = rev || -1;
        if (this.rev_value == rev) return;
        this.rev_value = rev;
        
        if (this.spine){
            this.spine.scaleX = rev;
        }
    },

    // 实例化角色模型数据
    instantModelRole: function () {
        if (this.role_data == null){ return; }
        // 去配置表数据
        var camp_type = 0;          // 当前阵营
        var spine_name = "";
        var encircle_effect = "";   // 10星英雄特效
        var fashion = 0;            // 时装数据
        if (this.role_data.object_type == BattleConst.Unit_Type.Hero){
            var key = Utils.getNorKey(this.role_data.object_bid, this.role_data.star);
            var config_data = gdata("partner_data", "data_partner_star", key);
            if (config_data){
                spine_name = config_data.res_id;
                encircle_effect = config_data.fight_effect;
            }
            var base_config = Config.partner_data.data_partner_base[this.role_data.object_bid];
            if(base_config){
                camp_type = base_config.camp_type;
            }
        }else if(this.role_data.object_type == BattleConst.Unit_Type.Hallows){
            var config_data = Config.hallows_data.data_base[this.role_data.object_bid]
            if (config_data){
                spine_name = config_data.c_res_id;
            }
        }else{
            var config_data = Utils.getUnitConfig(this.role_data.object_bid);
            if(config_data){
                spine_name = config_data.body_id;
                camp_type = config_data.camp_type;
                encircle_effect = config_data.fight_effect;
            }
        }
        // 真是战斗就从服务端那边去,否则从battleloop2里面去数值
        if(this.is_real == true){
            fashion = this.getBattleRoleExtendData(5); // 时装数据
        }else{
            fashion = this.role_data.fashion;
        }
        this.role_data.face_id = this.role_data.object_bid;
        if(fashion != 0){
            let skin_config = Config.partner_skin_data.data_skin_info[fashion];
            if(skin_config){
                spine_name = skin_config.res_id;
                this.role_data.face_id = skin_config.head_id;
                if(skin_config.fight_effect != "" && encircle_effect != ""){
                    encircle_effect = skin_config.fight_effect;
                }
            }
        }

        if (spine_name == ""){return;}
        this.spine_name = spine_name;

        // 设置阵营
        if (this.is_real && this.role_data.object_type != BattleConst.Unit_Type.Hallows){
            this.setCampIcon(camp_type);
        }

        // 设置10星光环特效
        if (encircle_effect != ""){
            this.createEncircleEffect(encircle_effect);
        }

        // 设置模型的高度
        var config_model = Config.skill_data.data_get_model_data[spine_name];
        if (config_model){
            this.model_height = config_model.model_height ; // 模型的高度再上浮20个像素
        }
        this.top_container.y = this.model_height + this.top_off_y;
        //是否需要播放进场动作
        if (this.play_enter) {
            this.showEnterAction();
        } else {
            if (this.is_real){
                this.doStand(function() {
                    this.role.active = true;
                    this.setActive(true);                    
                }.bind(this));
            }else{
                this.doRun(function() {
                    if (!this.is_real) {
                        this.role.active = true;
                        if (this.finish_cb)
                            this.finish_cb();
                    }
                    this.setActive(true);
                    if (this.role_data.group == BattleConst.Group_Type.Enemgy){
                        this.playUnrealEnterAction();
                    }
                }.bind(this))
            }
        }
    },

    // 获取指定类型的额外数据
    getBattleRoleExtendData:function(key){
        if (this.role_data == null) return 0;
        for (let index = 0; index < this.role_data.extra_data.length; index++) {
            const element = this.role_data.extra_data[index];
            if (element.extra_key == key){
                return element.extra_value;
            }
        }
        return 0;
    },

    // 设置神器回合进度条
    setHallowsRound:function(val, max){
        if(this.role_data == null || this.role_data.object_type != BattleConst.Unit_Type.Hallows) return;
        if(val == 0 || val == null){
            this.round_progress.progress = 0;
        }else{
            if (max == 0 || max == null){
                max = 3;
            }
            var per = Math.min(1, Math.max(val / max))
            this.round_progress.progress = per;
        }
    },

    // 是否需要播放进场动作
    showEnterAction:function(){
        if(this.role_data && this.role_data.object_type == BattleConst.Unit_Type.Hallows){  // 神器不需要走任何处理
            this.doStand();
            return;
        }

        var time = 0.5;
        var start_x = this.scene_pos.x
        var offset_x = SCREEN_WIDTH * 0.25
        var move_by = null
        if (this.is_friend == true){
            start_x = start_x - offset_x
            move_by = cc.moveTo(time, this.scene_pos.x, this.scene_pos.y)
        } else {
            start_x = start_x + offset_x
            move_by = cc.moveTo(time, this.scene_pos.x, this.scene_pos.y)
        }

        this.doRun();
        this.role.x = start_x;
        this.role.runAction(cc.sequence(move_by, cc.callFunc(function () {
            this.doStand();
        }.bind(this))))
    },

    // 设置阵营
    setCampIcon:function(camp_type){
        var camp_icon = PathTool.getBattleCampIconByType(camp_type);
        this.loadRes(camp_icon, function (icon, res_object) {
            icon.spriteFrame = res_object;
        }.bind(this), this.camp)
    },

    // 假战斗地方的进场效果
    playUnrealEnterAction:function(){
        if (this.role == null) return;
        this.clearNextActTimer();
        this.clearNextCallTimer();

        var start_point_x = SCREEN_WIDTH * 1.1;
        if (this.is_next_offset){
            start_point_x = SCREEN_WIDTH * 1.2;
        }
        // var time = 2;
        // var final_point_x = this.skill_act.gridPosToScreenPos(NormalPosGridRight[0]).x;
        // var offset_x = final_point_x - start_point_x;
        this.role.x = start_point_x;

        // 下一波怪
        var next_time = 280
        var call_back = function(){
            // this.hook_model.updateNextRoundData();
            // this.clearNextCallTimer();
        }.bind(this);
        if (this.next_call_mon_timer == null){
            this.next_call_mon_timer = gcore.Timer.set(function(){
                call_back();
            }.bind(this), next_time, 1)
        }

        // 开始播放攻击动作
        // var wait_time = 1590 - this.hook_model.getFinalMoveTime();
        // var atk_back = function(){
        //     var skill_plays_data = BattleLoop.play(this.pos);
        //     if (skill_plays_data){
        //         var skill_plays_list = this.hook_model.getSkillPlayData(skill_plays_data.actor);
        //         if (skill_plays_list == null || skill_plays_list.length == 0){
        //             this.hook_model.handleSkillPlayData(skill_plays_data, function() {

        //             }.bind(this));
        //         }
        //         this.hook_model.updateActorPlaysList(skill_plays_data);
        //     }
        //     this.clearNextActTimer();
        // }.bind(this);
        // if (this.next_ack_mon_timer == null) {
        //     this.next_ack_mon_timer = gcore.Timer.set(function () {
        //         atk_back();
        //     }.bind(this), wait_time, 1)
        // }

        // // 移动
        // var move_by = cc.moveBy(time, offset_x, 0);
        // this.role.runAction(move_by);


        var skill_plays_data = BattleLoop.play(this.pos);
        if (skill_plays_data) {
            cc.log("开始准备假战斗");
            var skill_plays_list = this.hook_model.getSkillPlayData(skill_plays_data.actor);
            if (skill_plays_list == null || skill_plays_list.length == 0) {
                this.hook_model.handleSkillPlayData(skill_plays_data, function(start_cb) {
                    cc.log("开始进行假战斗0");
                    var wait_time = 1590 - this.hook_model.getFinalMoveTime();
                    if (!this.next_ack_mon_timer) {                    
                        this.next_ack_mon_timer = gcore.Timer.set(function () {
                            cc.log("准备攻击1");
                            if (start_cb)
                                start_cb();
                            this.clearNextActTimer();
                        }.bind(this), wait_time, 1)
                    }

                    var time = 2;
                    var final_point_x = this.skill_act.gridPosToScreenPos(NormalPosGridRight[0]).x;
                    var offset_x = final_point_x - start_point_x;

                    this.role.stopAllActions();
                    var move_by = cc.moveBy(time, offset_x, 0);

                    if (!this.is_real && this.role_data.group == BattleConst.Group_Type.Enemgy){                    
                        this.role.runAction(move_by);
                    }
                }.bind(this));
            }
            this.hook_model.updateActorPlaysList(skill_plays_data);
        }
    },

    // 清楚下一个攻击的定时器
    clearNextActTimer:function(){
        if (this.next_ack_mon_timer){
            gcore.Timer.del(this.next_ack_mon_timer);
            this.next_ack_mon_timer = null;
        }
    },

    // 清除下一波怪物刷新定时器
    clearNextCallTimer:function(){
        if (this.next_call_mon_timer) {
            gcore.Timer.del(this.next_call_mon_timer);
            this.next_call_mon_timer = null;
        }
    },

    doRun:function(cb){
        this.playActionOnce(PlayerAction.run, null, null, null, cb)
    },

    doStand:function(finish_cb){
        this.playActionOnce(PlayerAction.battle_stand, null, null, null, finish_cb);
        if (this.talk_back == true){
            this.talk_back = false;
            this.model.addReadySum();
        }
    },

    // 设置动作伴随事件和动作结束事件回调
    setAnimationActionFunc:function(event_func, over_func, action_name){
        if (action_name == null) return;
        if(this.action_call_list[action_name] == null){
            this.action_call_list[action_name] = {over:null, event:null};
        }
        this.action_call_list[action_name].over = over_func;
        this.action_call_list[action_name].event = event_func;
    },

    /**
     * 切换动作,由于处于待机的时候,可能马上切换到其他动作,所以这里要看看要不要处理成待机播放完成之后
     * @param {*} action_name 目标动作名字
     * @param {*} res_name 目标资源名字
     */
    playActionOnce:function(action_name, res_name, is_loop, force, load_fini){
        res_name = res_name || action_name;
        
        if(is_loop == null){
            is_loop = true
        }
        if (this.play_action_res == res_name){
            if (this.play_action_name != action_name){
                this.play_action_name = action_name;
                this.skeleton.setToSetupPose();
                this.skeleton.setAnimation(0, action_name, is_loop);
            }
            return;
        }
        this.play_action_res = res_name;
        var skeleton_path = PathTool.getSpinePath(this.spine_name, res_name);
        if (!this.skelon_cache[skeleton_path]) {
            BattleResPool.getInstance().getRes(skeleton_path, function (load_fini, res_object) {
                this.play_action_name = action_name;
                this.skeleton.skeletonData = res_object;
                this.skeleton.setAnimation(0, action_name, is_loop);
                if (!this.skelon_cache[skeleton_path]) {
                    this.skelon_cache[skeleton_path] = res_object;
                }
                if (load_fini)
                    load_fini();
            }.bind(this, load_fini))

            // LoaderManager.getInstance().loadRes(skeleton_path, function (load_fini, res_object) {
            //     this.play_action_name = action_name;
            //     this.skeleton.skeletonData = res_object;
            //     this.skeleton.setAnimation(0, action_name, is_loop);
            //     if (!this.skelon_cache[skeleton_path]) {
            //         this.skelon_cache[skeleton_path] = res_object;
            //     }
            //     if (load_fini)
            //         load_fini();
            // }.bind(this, load_fini))
        } else {
            this.play_action_name = action_name;
            this.skeleton.skeletonData = this.skelon_cache[skeleton_path];
            this.skeleton.setToSetupPose();
            this.skeleton.setAnimation(0, action_name, is_loop);
            if (load_fini)
                load_fini();         
        }
    },

    // 重设基础数据,包含切换到战力动作等
    resetBaseInfo:function(){
        this.playActionOnce(PlayerAction.battle_stand);
        this.role.setPosition(this.scene_pos);
        this.resetZOrder();
        this.reverse(this.obj_type);
    },

    // 设置深度值
    resetZOrder: function () {
        if (this.role_data == null) { return; }
        if (this.role == null) { return; }
        if (this.role_base_zorder){
            if(this.role_cur_zorder != this.role_base_zorder){
                this.role_cur_zorder = this.role_base_zorder;
                this.role.zIndex = this.role_base_zorder;
            }
            return;
        }

        var zorder = 0
        var group = this.role_data.group - 1;
        var pos = this.role_data.pos - 1;
        if (this.role_data.group == BattleConst.Group_Type.Enemgy){
            zorder = BattleRoleZorder[group][pos-GIRD_POS_OFFSET];
        }else{
            zorder = BattleRoleZorder[group][pos]
        }
        this.role_base_zorder = zorder;
        this.role_cur_zorder = zorder;
        this.role.zIndex = zorder;
    },

    // 设置深度
    setLocalZOrder:function(zIndex){
        if(this.role_cur_zorder == zIndex){ return; }
        this.role_cur_zorder = zIndex;
        if(this.role){
            this.role.zIndex = zIndex;
        }
    },

    // 当前深度值
    getLocalZOrder:function(){
        return this.role_cur_zorder || 0;
    },

    // 战斗动作播报
    runAction:function(action){
        if(this.role){
            // this.role.stopAllActions();
            if (action) {
                this.role.runAction(action);
            }
        }
    },

    // 添加一个战斗特效,可能是buff, index:0 为上层特效 1:为下层特效
    addBattleEfffect:function(fix, fiy, effect_id, action_name, index, obj_type){
        if (this.container == null){
            if (this.wait_add_effect_list[effect_id] == null){
                this.wait_add_effect_list[effect_id] = {};
            }
            if (this.wait_add_effect_list[effect_id][action_name] == null) {
                this.wait_add_effect_list[effect_id][action_name] = { fix: fix, fiy: fiy, effect_id: effect_id, action_name: action_name, index: index };
            }
            return
        }
        // 这个确定是否要反转特效
        if (obj_type == null){
            obj_type = this.obj_type;
        }        
        if(this.effect_list[effect_id] == null){
            this.effect_list[effect_id] = {}
        }
        if (this.effect_list[effect_id][action_name] == null){
            this.effect_list[effect_id][action_name] = {num:1, object:null}
        }
        var effect_object = this.effect_list[effect_id][action_name];
        if (effect_object.object == null){
            effect_object.object = new BattleEffect();
            effect_object.object.createEffect(this.container, cc.v2(fix, fiy), obj_type, effect_id);
        }else{
            effect_object.num += 1;
            if(effect_object.num > 0){
                effect_object.object.setActiveEffect(true);
            }
        }
        // 设置特效的深度值
        var zorder = this.spine_zorder + 1;
        if (index == 1){
            zorder = this.spine_zorder - 1;
        }
        effect_object.object.setLocalZOrder(zorder);

        return effect_object;
    },

    // 监测是否有待添加特效
    checkEffectNeedAdd:function(){
        for(var effect_id in this.wait_add_effect_list){
            for (var action_name in this.wait_add_effect_list[effect_id]){
                var object = this.wait_add_effect_list[effect_id][action_name];
                if (object && object.effect_id){
                    this.addBattleEfffect(object.fix, object.fiy, object.effect_id, object.action_name, object.index);
                }
            }
        }
        this.wait_add_effect_list = {};
    },

    // 移除一个特效,并不是强制移除,只是把计数器-1,如果计数器为0,才是彻底移除
    delBattleEffect:function(effect_id, action_name, force){
        if (this.wait_add_effect_list[effect_id]){
            if (this.wait_add_effect_list[effect_id][action_name] != null) {
                this.wait_add_effect_list[effect_id][action_name] = null;
            }
        }

        if(this.effect_list[effect_id] == null){
            return;
        }
        var effect_object = this.effect_list[effect_id][action_name];
        if(effect_object == null){
            return;
        }
        effect_object.num -= 1;
        if (effect_object.num <= 0) {
            effect_object.object.setActiveEffect(false)
        }
    },

    // 显示或者隐藏掉血条
    showHpRoot:function(status){
        if (this.is_real == false ) return;         // 假战斗不需要管这个
        if(this.hp_show_status == status){ return; }
        this.hp_show_status = status;
        if(this.top_container){
            this.top_container.active = status
        }
    },

    /**
     * 血量变化的值
     * @param {*} dmg 正数是治疗,负数是扣血 
     * @param {*} is_die 是否死亡
     * @param {*} without 是否提出掉非死亡状态
     * @param {*} is_must_die 如果为0,就标识可以移除了.否则就算死了也不移除.因为可能在连击中
     */
    updateHP:function(dmg, is_die, without, is_must_die){
        if(this.role_data == null) { return; }
        if(this.top_container == null) { return; }
        if(this.role_data && this.role_data.object_type == BattleConst.Unit_Type.Hallows) return;

        this.setHP(dmg);
        if (without == null){
            without = false
        }
        if (is_die == 1 && is_must_die == 0){
            if (this.is_die == false){
                this.died()
            }
        }else{
            if(this.is_die == true && without == false){
                this.relive()
            }
        }
    },

    // 处理角色复活
    relive: function () {
        if (this.is_die == false) { return };
        this.is_die = false;
        this.resetBaseInfo();
        this.showHpRoot(true);
        this.setActive(true)
        var cur_hp = this.role_data.hp;
        var per = Math.min(1, Math.max(cur_hp / this.role_data.hp_max))
        this.progress.progress = per;
    },

    // 立刻移除对象
    doDied:function(){
        if(this.is_die == true) {
            return;
        }
        this.is_die = true;
        this.showHpRoot(false);
        this.setActive(false)
        this.clearAllEffect();
    },

    // 处理角色死亡
    died: function () {
        // console.trace("1111111111111");

        if(this.in_hurt_act == true){
            this.need_play_die = true;
            return;
        }
        if(this.role == null) {
            return;
        }
        if(this.is_die == true) {
            return;
        }
        this.is_die = true;
        var delay_time = 0.25;
        var blink = cc.blink(0.25,2);
        var fadeOut = cc.fadeOut(0.25);
        var callFunc_1 = cc.callFunc((function(){
            this.showHpRoot(false);
            this.is_act_die = true;
            this.setActive(false);
            if(this.is_real == false){  //假战斗怪物死掉了的话,需要通知要创建了
                this.assetJumpTo();
                this.hook_model.playEnd(this.pos);
                this.hook_model.updateNextRoundData();
            }
        }).bind(this))
        var act = cc.sequence(cc.delayTime(delay_time), blink, fadeOut, callFunc_1);
        this.runAction(act);
        // 清除所有的特效
        this.clearAllEffect(false);
        // 回收掉所有buff图标
        this.removeBuffItemRes();
        this.removeBuffList();
    },

    // 设置是否激活
    setActive:function(status){
        if (this.is_real == true){
            this.top_container.active = status;
        }else{
            this.top_container.active = false;
        }
        this.role.opacity = 255;
        this.shadow.active = status;
        this.skeleton.markForRender(status);
        if (this.effect){
            this.effect.active = status;
        }
    },

    // 受击动作播放完成之后的处理
    checkIsDied:function(){
        if (this.need_play_die == true){
            this.need_play_die = false;
            this.died();
        }else{
            this.doStand()
        }
    },

    // 设置气血
    setHP:function(dmg){
        if(this.role_data == null) { return; }
        var cur_hp = 0
        if(dmg <= 0){       // 伤害
            cur_hp = Math.max(0, dmg + this.role_data.hp);
        }else{              // 恢复
            cur_hp = Math.min(this.role_data.hp_max, dmg + this.role_data.hp)
        }
        this.role_data.hp = cur_hp;
        var per = Math.min(1, Math.max(cur_hp / this.role_data.hp_max))
        this.progress.progress = per;
    },

    // 下一波怪如果是己方需要清掉所有的buff之类的
    updataNextBattleRole:function(data){
        if (this.role_data){
            this.role_data.updateData(data);
            this.clearAllEffect(false);
            if(this.role_data.hp <= 0){
                this.died();
            }else{
                var per = Math.min(1, Math.max(this.role_data.hp / this.role_data.hp_max))
                this.progress.progress = per;
            }
        }
    },

    // 变身操作
    changeSpine:function(status, spine_res, action_name){

    },

    // 通知播放假战斗资源掉落
    assetJumpTo:function(){
        var node_root_pos = this.role.convertToWorldSpace(cc.v2(0, 0));     // 转到世界坐标
        this.model.playResourceCollect(node_root_pos.x, node_root_pos.y + this.model_height * 0.5, this.pos);         // 
    },

    // 隐身
    setOpacity:function(status, value){

    },

    // 更新buff,包含更新buff列表
    updateBuffList:function(buff, buff_cfg){
        if(buff == null || buff_cfg == null){
            return;
        }
        this.buff_list[buff.id] = null;
        this.buff_list[buff.id] = {buff:buff, config:buff_cfg, res_id: buff_cfg.icon};

        var temp_group_list = {};
        var res_id = buff_cfg.icon;
        if(res_id != 0){
            var buff_data = this.buff_list_data[res_id];
            if (buff_data == null){
                buff_data = {res_id: res_id, num: 0, list: []};
                this.buff_list_data[res_id] = buff_data;
            }

            if (buff_data.num == 0 || (buff_cfg.join_type && buff_cfg.join_type != 3)) {
                buff_data.num += 1;
                if (buff_cfg.group) {
                    temp_group_list[buff_cfg.group] = true;
                }
            } else if (buff_cfg.join_type && buff_cfg.join_type == 3 && buff_cfg.group && !temp_group_list[buff_cfg.group]) {
                temp_group_list[buff_cfg.group] = true;
                buff_data.num += 1;
            }
            buff_data.list.push(buff.id);

            var temp_ary = []
            for(var key in this.buff_list_data){
                var data = this.buff_list_data[key];
                if(data){
                    temp_ary.push(data);
                }
            }
            if (temp_ary.length > 0){
                temp_ary.sort(Utils.tableLowerSorter(["res_id"]));
                var length = Math.min(3, temp_ary.length);  // 最多值创建4个
                for (let index = 0; index < length; index++) {
                    var data = temp_ary[index];
                    var buff_object = this.buff_list_item[data.res_id];
                    if (buff_object == null){
                        buff_object = this.createBuffItem();
                        this.buff_list_item[data.res_id] = buff_object;
                    }
                    buff_object.label.string = data.num;
                    buff_object.node.x = 22 * index;
                    var buff_path = PathTool.getBuffRes(data.res_id);
                    if(buff_object.path != buff_path){
                        buff_object.path = buff_path;
                        this.loadRes(buff_path, function(icon, res_object){
                            icon.spriteFrame = res_object;
                        }.bind(this), buff_object.icon)
                    }
                }
            }
        }
    },

    // 移除buff没如果没有传参数,就是移除全部
    removeBuffList:function(buff_id){
        if(buff_id == null){
            this.buff_list = {};
            this.buff_list_data = {};
            for (var key in this.buff_list_item){
                var buff_object = this.buff_list_item[key];
                if(buff_object && buff_object.node){
                    BattleRolePool.getInstance().pushBackBuffPools(buff_object.node);
                }
            }
            this.buff_list_item = {};
        }else{
            var data = this.buff_list[buff_id];         // {buff:buff, config:buff_data, res_id: buff_data.icon};
            if(data){
                var buff_object = this.buff_list_item[data.res_id];
                if (buff_object){
                    var buff_data = this.buff_list_data[data.res_id];   // 取出具体数字
                    if (buff_data){
                        buff_data.num -= 1;
                        // 将该buff从列表中删除
                        for (let index = 0; index < buff_data.list.length; index++) {
                            const element = buff_data.list[index];
                            if (element == buff_id){
                                buff_data.list.splice(index, 1);
                                break;
                            }
                        }
                        // 当前没有可用于显示的buff了,把buff节点丢到对象池里面去
                        if (buff_data.num <= 0){
                            buff_object.icon.spriteFrame = null;        // 回收对象的时候,优先清掉旧的纹理信息
                            BattleRolePool.getInstance().pushBackBuffPools(buff_object.node);
                            this.buff_list_item[data.res_id] = null;
                            this.buff_list_data[data.res_id] = null;
                            this.resetBuffPostion();
                        }else{
                            buff_object.label.string = buff_data.num;
                        }
                    }
                }

            }
            this.buff_list[buff_id] = null;
        }
    },

    // 回收buff图标的时候,优先清理掉缓存的纹理信息
    removeBuffItemRes:function(){
        for (var key in this.buff_list_item) {
            var buff_object = this.buff_list_item[key];
            if (buff_object && buff_object.icon) {
                buff_object.icon.spriteFrame = null;        // 回收对象的时候,优先清掉旧的纹理信息
            }
        }
    },

    // 创建10星环绕特效
    createEncircleEffect:function(effect_res){
        if (this.encircle_effect == effect_res) return;
        if(this.effect_skeleton == null){
            this.effect_skeleton = this.effect.addComponent(sp.Skeleton);
        }

        this.encircle_effect = effect_res;
        var skeleton_path = PathTool.getSpinePath(effect_res);
        this.loadRes(skeleton_path, function (skeleton, res_object) {
            skeleton.skeletonData = res_object;
            skeleton.setAnimation(0, PlayerAction.action, true);
            skeleton.enabled = true;
        }.bind(this), this.effect_skeleton)
    },

    // 创建buff,手动创建,但是对象池获取,包含 node, label, path icon
    createBuffItem:function(){
        var pools = BattleRolePool.getInstance().getBuffPools();
        var buff_object = {node:null, label:null, icon:null, path:""};
        var node = null;
        var label = null;
        var icon = null;
        if (pools.size() > 0) {
            node = pools.get();
            label = node.getChildByName("font_label").getComponent(cc.Label);
            icon = node.getChildByName("icon_sprite").getComponent(cc.Sprite);
        } else {
            node = new cc.Node();
            node.setAnchorPoint(0, 0.5);
            node.width = 20;
            node.height = 20;

            var icon_node = new cc.Node();
            icon_node.setAnchorPoint(0, 0.5);
            icon_node.name = "icon_sprite";
            node.addChild(icon_node);
            icon = icon_node.addComponent(cc.Sprite);

            var font_node = new cc.Node();
            font_node.color = new cc.Color(cc.Color.WHITE);
            font_node.setAnchorPoint(1, 0.5);
            font_node.x = 20;
            font_node.y = -3;
            font_node.name = "font_label";
            node.addChild(font_node);

            label = font_node.addComponent(cc.Label);
            label.lineHeight = 14;
            label.fontSize = 14;
            label.horizontalAlign = cc.macro.TextAlignment.RIGHT;

            var outline_label = font_node.addComponent(cc.LabelOutline);
            outline_label.color = new cc.Color(cc.Color.BLACK);
        }
        this.buff_container.addChild(node);

        buff_object.node = node;
        buff_object.label = label;
        buff_object.icon = icon;
        return buff_object;
    },

    // 重新设置buff的位置
    resetBuffPostion:function(){
        if (this.buff_list_item){
            var temp_ary = []
            for (var res_id in this.buff_list_item) {
                if (this.buff_list_item[res_id]) {
                    temp_ary.push({ res_id: res_id, object: this.buff_list_item[res_id] });
                }
            }
            if (temp_ary.length > 0){
                temp_ary.sort(Utils.tableLowerSorter(["res_id"]));
                for (let index = 0; index < temp_ary.length; index++) {
                    const element = temp_ary[index];
                    if (element && element.object && element.object.node) {
                        element.object.node.x = 22 * index;
                    }
                }
            }
        }
    },

    // 判断是否拥有当前id的buff
    hadBuff:function(buff_id){
        return (this.buff_list && this.buff_list[buff_id] != null)
    },

    getRoleData:function(){
        return this.role_data;
    },

    addTips:function(bid){
        this.tips_list[bid] = true;
    },

    removeTips:function(bid){
        this.tips_list[bid] = false;
    },

    loadRes: function (res, callback, node) {
        if (res == null || res == "") return;
        if (callback == null) return;
        var temp_object = this.resources_list[res];
        if (temp_object){
            callback(node, temp_object);
        }else{
            LoaderManager.getInstance().loadRes(res, (function (object, res_object) {
                if (this.resources_list[res] == null) {
                    this.resources_list[res] = res_object;
                }
                callback(object, res_object);
            }).bind(this, node));
        }
    },

    // 设置当前模型和绑在模型上面的特效播放速率
    setTimeScale:function(speed){
        if (this.skeleton == null || this.skeleton.skeletonData == null){
            this.skeleton_time_scale = speed;
        }else{
            if (this.skeleton_timeScale == speed) return;
            this.skeleton_timeScale = speed
            this.skeleton.timeScale = speed;
            this.setEffectScale(speed);
            // 设置特效
            for (var effect_id in this.effect_list) {
                var effect_object = this.effect_list[effect_id]
                for (var action_name in effect_object) {
                    var effect = effect_object[action_name]
                    if (effect && effect.object) {
                        effect.object.setTimeScale(speed);
                    }
                }
            }
        }
    },

    // 显示聊天气泡
    showTalkBubble:function(msg){

    },

    // 清空所有特效
    clearAllEffect:function(is_force){
        for (var effect_id in this.effect_list) {
            var effect_object = this.effect_list[effect_id]
            for (var action_name in effect_object) {
                var effect = effect_object[action_name]
                if (effect && effect.object) {
                    effect.object.deleEffect();
                }
            }
        }
        if (is_force == true) {
            this.effect_list = null;
            this.wait_add_effect_list = null;
        }else{
            this.effect_list = {};
            this.wait_add_effect_list = {};
        }
    },

    /**
     * 从场景中移除这个单位,回收掉所有的创建节点和预制,并且删除掉所有的资源纹理信息
     */
    deleteRole: function () {
        if(this.role){
            this.role.stopAllActions();
        }
        this.clearAllEffect(true);
        this.clearNextActTimer();
        this.clearNextCallTimer();
        this.removeBuffItemRes();                       // 优先清掉buff缓存的纹理信息
        // this.skeleton.skeletonData = null;              // 释放之前先把节点对象的资源清除
        if (this.effect_skeleton){
            this.effect_skeleton.enabled = false;
            // this.effect.removeComponent(sp.Skeleton);
            // this.effect_skeleton = null;       // 10星光环特效
        }
        if(this.camp){
            this.camp.spriteFrame = null;                   // 先释放掉节点对象资源引用对象
        }
        this.action_call_list = {};
        this.tips_list = {};

        for (var skeletonIndex in this.skelon_cache) {
            BattleResPool.getInstance().delRes(skeletonIndex);
        }
        // 这两处释放res 资源有问题
        for (var key in this.resources_list) {
            LoaderManager.getInstance().releaseRes(key);
        }

        this.skelon_cache = {};
        // 移除掉所有的buff节点,并且丢到对象池中
        this.removeBuffList();
        // 把当前节点对象,重新放到缓存池中区
        BattleRolePool.getInstance().pushBackRole(this.role);
    },

    getResPath: function(action_name) {
        return "spine/" + this.spine_name + "/" + action_name;
    },

});