// --------------------------------------------------------------------
// @author: xxx@syg.com(必填, 创建模块的人员)
// @description:
//      这里填写详细说明,主要填写该模块的功能简要
// <br/>Create: {DATE}
// --------------------------------------------------------------------
const BridgeClass = require( "bridge.class" );
var HeroConst = require( "hero_const" );
var PartnerConst = require( "partner_const" );
var HeroEvent = require( "hero_event" );
var PartnerCalculate = require( "partner_calculate" );
var HeroCalculate = require( "hero_calculate" );
var HeroController = require( "hero_controller" )
var BackpackController = require( "backpack_controller" );
var PathTool = require( "pathtool" );
var BackPackConst = require( "backpack_const" );
const RoleController = require( "role_controller" );
const FID = require( "bridge.function.ids" );


// const { util } = require("config");
// const { config } = require("process");
var HeroModel = cc.Class( {
	extends: BridgeClass,
	ctor: function() {
		this.ctrl = arguments[ 0 ];
	},

	properties: {},

	initConfig: function() {
		// 伙伴数据列表 (id :英雄唯一标识)
		// 结构 this.hero_list[id] = hero_vo
		this.hero_list = {};
		//  伙伴bid列表的  
		// 结构 this.hero_bid_list[bid] = {hero_vo1,hero_vo2}
		this.hero_bid_list = {};
		// 伙伴数据数组形式存储，便于排序
		this.hero_array = [];

		// 标志第一次初始
		this.is_init = true;

		// 英雄上限
		this.hero_max_count = 0;
		// 英雄已激活上限次数 
		this.buy_num = 0;

		//皮肤数据  结构: self.hero_skin_list[皮肤id] = 皮肤结束时间   (如果时间 == 0 表永久)
		this.hero_skin_list = null;

		// 英雄图书馆信息
		this.dic_pokedex_info = null;
		// 英雄图书馆信息 [bid] = 数据
		this.dic_pokedex_bid = {};

		// 熔炼祭坛的列表
		this.dic_fuse_info = null;

		// 已拥过有英雄id [bid] = 1
		this.dic_had_hero_info = {};

		// 布阵站位信息 this.pos_list[布阵类型][pos] = id
		this.pos_list = {};

		this.expedit_list = null;
		// 阵法类型
		this.use_formation_type = 1;
		// 使用的圣器id
		this.use_hallows_id = 0;

		// 装备红点背包已更新 记录
		this.is_equip_redpoint_bag_update = true;
		// 装备红点英雄已更新 记录
		this.is_equip_redpoint_hero_update = true;

		// 是否延迟红点更新中 例子:this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp] = true
		// 目前只有升级红点用
		this.is_delay_redpoint_update = {};

		// 进阶和升星材料消耗 只能写死 如果策划改了.跟着改吧
		this.upgrade_star_cost_id = 10001;
		this.dic_star_count = {}

		// 升星红点背包已更新 记录
		this.is_upgradestar_redpoint_bag_update = true;
		// 升星红点英雄已更新 记录
		this.is_upgradestar_redpoint_hero_update = true;

		// 阵法 红点 (一次性的)
		this.is_redpoint_form = false;
		// 圣器 红点 (一次性的)
		this.is_redpoint_hallows = false;

		// 记录登陆时候角色的等级 判断阵法是否新解锁用
		this.record_login_lev = 0;

		this.holy_equip_plans = {};
		// 符文解锁条件信息
		// var artifact_one        = game.configs.partner_data.data_partner_const["artifact_one"].val; 
		// var artifact_two        = game.configs.partner_data.data_partner_const["artifact_two"].val;
		// this.artifact_lock_list = {"1":artifact_one, "2":artifact_two};
		this.artifact_lucky = 0; // 符文祝福值
		this.artifact_lucky_red = false; // 祝福值红点

		// 英雄信息界面 升星页签的参数  6星才限时页签(后面策划要求熔炼祭坛的也加入)
		this.hero_info_upgrade_star_param = 6;

		this.hero_info_upgrade_star_param2 = 10;
		this.hero_info_upgrade_star_param3 = 11;
		this.hero_info_upgrade_star_param4 = 12;

		// --天赋技能升星的材料
		this.talent_skill_cost_id = 10450
		// --天赋技能可学习的列表 用于红点 结构 self.dic_hero_talent_skill_learn_redpoint[skill_id] = 1
		this.dic_hero_talent_skill_learn_redpoint = {}

		this.is_need_update_talent_redpoint = true


		// --共鸣水晶等级
		this.resonate_cystal_lev = 0

		// --英雄共鸣锁定信息
		this.dic_resonate_lock_info = {}
		// --共鸣石碑等级
		this.resonate_stone_level = 0
		// --共鸣历史星级
		this.resonate_max_partner_lev = null //--一定要nil 有地方判断nil来决定有木有数据
		// --共鸣精炼红点
		this.is_resonate_extract_redpoint = false

		this.dic_itemid_to_partner_id = {}

		this.data_level_up_length = 200;
		this.data_level_up_cache = {};

		//穿戴在英雄身上的神裝信息結構 self.hero_holy_list[id] = good_vo
		this.hero_holy_list = {}
	},

	setHeroMaxCount: function( max_count ) {
		if( typeof max_count == "number" ) {
			this.hero_max_count = max_count;
		}

	},

	//--批量请求英雄的属性 装备等数据 11026
	batchSendHeroInfo: function() {

		if( this.hero_list ) {
			var list = []
			for( var k in this.hero_list ) {
				var v = this.hero_list[ k ]
				list.push( [ partner_id = v.id ] )
				if( list.length > 150 ) {
					HeroController.getInstance().sender11026( list )
					list = []
				}
			}
			if( list.length > 0 ) {
				//--请求英雄详细信息
				HeroController.getInstance().sender11026( list )
			}
		}
	},

	// 获取英雄上上限
	getHeroMaxCount: function() {
		var max_count = this.hero_max_count || 0;
		var have_coutn = this.hero_array.length;
		return {
			max_count: max_count,
			have_coutn: have_coutn
		};
	},

	setHeroBuyNum: function( buy_num ) {
		this.buy_num = Number( buy_num );
	},

	getHeroBuyNum: function() {
		return this.buy_num || 0;
	},

	// --根据bid 和star 获取对应的英雄信息
	// --@return 英雄信息列表
	getHeroInfoByBidStar( bid, star ) {
		if( !bid || !star ) return
		let list = this.hero_bid_list[ bid ];

		if( list ) {
			list.forEach( _item => {
				if( _item.face_id == 0 ) {
					_item.face_id = "null";
				}
			} )
			let return_list = []
			for( let i in list ) {
				let hero_vo = list[ i ]
				if( hero_vo.star == star ) {
					return_list.push( hero_vo )
					// table_insert(return_list, hero_vo)
				}
			}
			return return_list
		}
		return null
	},

	/**
	 * 更新英雄列表
	 * @author zhanghuxing 2019-01-24
	 * @param  {[type]}  not_show_power 不显示战力变化提示
	 */
	updateHeroList: function( hero_list, is_add, not_show_power, is_detail_info ) {

		if( !hero_list ) return;
		for( var hero_i in hero_list ) {
			this.updateHeroVo( hero_list[ hero_i ], not_show_power, is_detail_info );
		}

		// console.log(  "紅點相關" + count + JSON.stringify( lists )   );
		// 熔炼祭坛的红点 新增需要重新算红点
		if( is_add ) {
			HeroCalculate.getInstance().clearAllStarFuseRedpointRecord();
			gcore.GlobalEvent.fire( HeroEvent.Hero_Data_Add, hero_list );
			let lists = this.getHeroReformListByCamp( 0 );
			let count = 0;
			lists.forEach( _item => {

				if( _item.result.is_redpoint ) {
					count++;
				}
			} );

			// console.log(  "紅點相關" + count + JSON.stringify( lists )   );

			nx.mTip.openTip( "tipReform.show", count > 0 );
		}

		// let reds = HeroCalculate.getInstance().checkAllHeroRedPoint();
		// // console.log( "所有夥伴紅點相關" + JSON.stringify( reds ) );
		this.is_init = false;
	},


	/**
	 * 更新单个英雄信息，如果没有则是新增；
	 */
	updateHeroVo: function( info, not_show_power, is_detail_info ) {

		if( !info ) return;

		info.id = info.partner_id;
		var bid = info.partner_bid || info.bid;
		if( !bid && this.hero_list[ info.id ] )
			bid = this.hero_list[ info.id ].bid;

		var par_cfg = game.configs.partner_data.data_partner_base[ bid ];
		if( !par_cfg ) return;

		var is_add = false;
		let true_star = info.star;
		// if (!this.hero_list[hero_id] ){
		// 	if (is_detail_info){
		// 		return
		// 	}
		// 	this.hero_list[hero_id] = new  HeroVo()
		// 	is_add = true
		// }
		var hero_vo = this.hero_list[ info.id ];
		if( !hero_vo ) {
			if( !is_detail_info ) {
				is_add = true;
				var HeroVo = require( "hero_vo" );
				hero_vo = this.hero_list[ info.id ] = new HeroVo();

				for( var config_k in par_cfg ) {
					if( config_k !== "skills" )
						info[ config_k ] = par_cfg[ config_k ];
					if( config_k == "star" ) {
						info[ config_k ] = true_star;
					}
				}

				// let star = info.star || config.init_star
				// if( this.dic_had_hero_info[ bid ] ) {
				// 	if( this.dic_had_hero_info[ bid ] < star ) {
				// 		this.dic_had_hero_info[ bid ] = star
				// 	}
				// } else {
				// 	this.dic_had_hero_info[ bid ] = star
				// }
			}


			// 设置角色id
			// var RoleController = require( "role_controller" );
			var role_vo = RoleController.getInstance().getRoleVo();
			if( role_vo ) {
				info.rid = role_vo.rid;
				info.srv_id = role_vo.srv_id;
			}
		}

		// 旧数据
		var old_vo = null;
		var open_type = 0
		if( !is_add ) {
			if( !is_detail_info ) {
				// 处理升星、进阶
				if( info.star && hero_vo.star < info.star ) { // 升星
					open_type = 1;
					old_vo = nx.dt.objClone( hero_vo );

					let data = game.configs.partner_skill_data.data_partner_skill_const[ "skill_slot" ].val;
					if( hero_vo.star == data[ 1 ] - 1 ) {
						hero_vo.is_open_talent = true;
					}
					if( info.star >= 10 ) {
						// --清除 星級數量記錄
						this.dic_star_count = {}
					}
				} else if( info.break_lev && hero_vo.break_lev < info.break_lev ) { // 进阶
					open_type = 2;
					old_vo = nx.dt.objClone( hero_vo );
				}
			}
		} else {

		}

		// 更新最大星级
		// var cur_star = info.star || par_cfg.init_star;
		// if( this.dic_had_hero_info[ bid ] ) {
		// 	if( this.dic_had_hero_info[ bid ] < cur_star )
		// 		this.dic_had_hero_info[ bid ] = cur_star;
		// } else {
		// 	this.dic_had_hero_info[ bid ] = cur_star;
		// }

		hero_vo.updateHeroVo( info );
		if( is_add ) {
			this.hero_array.push( hero_vo );
			if( !this.hero_bid_list[ hero_vo.bid ] ) {
				this.hero_bid_list[ hero_vo.bid ] = []
			}
			this.hero_bid_list[ hero_vo.bid ].push( hero_vo )
		} else {
			if( open_type == 1 && old_vo ) { // 打开升星成功界面
				this.ctrl.openHeroUpgradeStarExhibitionPanel( true, old_vo, hero_vo );
				HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPStar )
			} else if( open_type == 2 && old_vo ) { // 打开进阶成功界面
				this.ctrl.openBreakExhibitionWindow( true, old_vo, hero_vo );
			}
			if( is_detail_info ) {
				hero_vo.setInitAttr();
				gcore.GlobalEvent.fire( HeroEvent.Hero_Detail_Data_Update, hero_vo );
			} else {
				if( !not_show_power ) {
					if( hero_vo.partner_id == info.partner_id ) {
						// nx.bridge.vset( "ShowPartner", hero_vo );
						gcore.GlobalEvent.fire( HeroEvent.Hero_Data_Update, hero_vo );
					}
				}

			}

			// gcore.GlobalEvent.fire(HeroEvent.Hero_Data_Update, hero_vo);
		}


		HeroCalculate.getInstance().checkHeroRedPointByRedPointType( HeroConst.RedPointType.eRPLevelUp )
	},

	updateSingle: function( info, not_show_power, is_detail_info ) {

		if( !info ) return;

		info.id = info.partner_id;
		var bid = info.partner_bid || info.bid;
		if( !bid && this.hero_list[ info.id ] )
			bid = this.hero_list[ info.id ].bid;

		var par_cfg = game.configs.partner_data.data_partner_base[ bid ];
		if( !par_cfg ) return;

		var is_add = false;
		let true_star = info.star;
		// if (!this.hero_list[hero_id] ){
		// 	if (is_detail_info){
		// 		return
		// 	}
		// 	this.hero_list[hero_id] = new  HeroVo()
		// 	is_add = true
		// }
		var hero_vo = this.hero_list[ info.id ];
		if( !hero_vo ) {
			if( !is_detail_info ) {
				is_add = true;
				var HeroVo = require( "hero_vo" );
				hero_vo = this.hero_list[ info.id ] = new HeroVo();

				for( var config_k in par_cfg ) {
					if( config_k !== "skills" )
						info[ config_k ] = par_cfg[ config_k ];
					if( config_k == "star" ) {
						info[ config_k ] = true_star;
					}
				}


			}


			// 设置角色id
			// var RoleController = require( "role_controller" );
			var role_vo = RoleController.getInstance().getRoleVo();
			if( role_vo ) {
				info.rid = role_vo.rid;
				info.srv_id = role_vo.srv_id;
			}
		}

		// 旧数据
		var old_vo = null;
		var open_type = 0
		if( !is_add ) {
			if( !is_detail_info ) {
				// 处理升星、进阶
				if( info.star && hero_vo.star < info.star ) { // 升星
					open_type = 1;
					old_vo = nx.dt.objClone( hero_vo );

					let data = game.configs.partner_skill_data.data_partner_skill_const[ "skill_slot" ].val;
					if( hero_vo.star == data[ 1 ] - 1 ) {
						hero_vo.is_open_talent = true;
					}
					if( info.star >= 10 ) {
						// --清除 星級數量記錄
						this.dic_star_count = {}
					}
				} else if( info.break_lev && hero_vo.break_lev < info.break_lev ) { // 进阶
					open_type = 2;
					old_vo = nx.dt.objClone( hero_vo );
				}
			}
		} else {

		}


		hero_vo.updateHeroVo( info );
		if( is_add ) {
			this.hero_array.push( hero_vo );
			if( !this.hero_bid_list[ hero_vo.bid ] ) {
				this.hero_bid_list[ hero_vo.bid ] = []
			}
			this.hero_bid_list[ hero_vo.bid ].push( hero_vo )
		} else {
			if( open_type == 1 && old_vo ) { // 打开升星成功界面
				this.ctrl.openHeroUpgradeStarExhibitionPanel( true, old_vo, hero_vo );
				HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPStar )
			} else if( open_type == 2 && old_vo && old_vo.resonate_lev == 0 ) { // 打开进阶成功界面
				this.ctrl.openBreakExhibitionWindow( true, old_vo, hero_vo );
			}
			if( is_detail_info ) {
				hero_vo.setInitAttr()
				gcore.GlobalEvent.fire( HeroEvent.Hero_Detail_Data_Update, hero_vo )
			} else {
				// if( !not_show_power ) {
				// 	if( hero_vo.partner_id == info.partner_id ) {
				// 		nx.bridge.vset( "ShowPartner", hero_vo );
				// 		// gcore.GlobalEvent.fire( HeroEvent.Hero_Data_Update, hero_vo )
				// 	}
				// }


			}
			if( hero_vo.resonate_lev == 0 ){
				nx.bridge.vset( "ShowPartner", hero_vo );
			}
			
			gcore.GlobalEvent.fire( HeroEvent.Hero_Data_Update, hero_vo );
		}

		HeroCalculate.getInstance().checkHeroRedPointByRedPointType( HeroConst.RedPointType.eRPLevelUp );
		HeroCalculate.getInstance().checkHeroRedPointByRedPointType( HeroConst.RedPointType.eRPStar );


	},

	getHeroNumByBid( bid ) {
		if( !bid ) {
			return 0
		};
		let list = this.hero_bid_list[ bid ] || {}
		return list.length
	},

	// 获取单个伙伴数据,id
	// @id 是英雄唯一标识id 
	getHeroById: function( partner_id ) {
		if( !this.hero_list ) return;
		if( !partner_id || typeof partner_id != "number" ) return;
		return this.hero_list[ partner_id ] || {}
	},

	// 删除英雄 
	delHeroDataList: function( list ) {
		if( !list ) return;
		let delParts = [];
		// cc.log( "delHeroDataList" )
		for( var hero_i in list ) {
			let v = list[ hero_i ]
			let temp_bid = this.hero_list[ v.partner_id ].bid;
			delParts.push( this.hero_list[ list[ hero_i ].partner_id ] );
			delete this.hero_list[ list[ hero_i ].partner_id ]

			// --同时从bid英雄列表删除该英雄记录
			let bidlist = this.hero_bid_list[ temp_bid ]
			if( bidlist ) {
				for( let i = 0; i < bidlist.length; ++i ) {
					let hero_vo = bidlist[ i ]
					if( hero_vo.partner_id == v.partner_id ) {
						bidlist.splice( i, 1 )
					}
				}
			}
		}

		this.hero_array = [];
		for( var hero_i in this.hero_list ) {
			this.hero_array.push( this.hero_list[ hero_i ] );
		}

		// 消除熔炼祭坛的红点 删除也要重新算
		HeroCalculate.getInstance().clearAllStarFuseRedpointRecord();

		// 升星红点
		this.is_upgradestar_redpoint_hero_update = true
		this.checkUpgradeStarRedPointUpdate()

		gcore.GlobalEvent.fire( HeroEvent.Del_Hero_Event, delParts );
	},

	// --更新天赋信息
	updateHeroVoTalent( data_list, is_not_check ) {
		let is_team = false
		var self = this
		for( let i = 0; i < data_list.length; ++i ) {
			let v = data_list[ i ]
			if( self.hero_list[ v.partner_id ] ) {
				self.hero_list[ v.partner_id ].updateSkill( v.dower_skill )
				if( !is_team ) {
					if( self.hero_list[ v.partner_id ].isFormDrama() ) {
						is_team = true
					}
				}
			}
		}
		if( is_team && !is_not_check ) {
			// --如果有剧情阵容的英雄..需要检查红点
			// --检测红点
			// HeroCalculate.getInstance().checkAllHeroRedPoint()
		}
	},
	getHeroList: function() {

		return this.hero_list || {}
	},

	getAllHeroArray: function() {
		this.hero_array.forEach( _item => {
			if( _item.face_id == 0 ) {
				_item.face_id = "null";
			}
		} )

		return this.hero_array;
	},

	// 根据阵容获取英雄列表
	getHeroListByCamp: function( camp ) {

		if( typeof camp !== "number" ) return;
		var hero_list = [];

		for( var hero_i in this.hero_array ) {
			if( camp === HeroConst.CampType.eNone || camp === this.hero_array[ hero_i ].camp_type ) {
				// if( this.hero_array[ hero_i ]. )
				if( this.hero_array[hero_i].is_in_form > 0 ){
					this.hero_array[hero_i].sortidd = this.hero_array[hero_i].quality ;
				}else{
					this.hero_array[hero_i].sortidd = this.hero_array[hero_i].quality - 3;
				}
				if( this.hero_array[hero_i].face_id == 0 ) {
					this.hero_array[hero_i].face_id = "null";
				}
				hero_list.push( this.hero_array[ hero_i ] );
				
			}
		}
		// hero_list.forEach( _item => {
		// 	if( _item.face_id == 0 ) {
		// 		_item.face_id = "null";
		// 	}
		// } )

		var hero_sort = this.getHeroSortFunc();
		return hero_list.sort( hero_sort );
	},

	getHeroListByStar: function( _star ) {

		let hero_list = [];

		for( let hero_i in this.hero_array ) {
			if( _star == this.hero_array[ hero_i ].star ) {
				hero_list.push( this.hero_array[ hero_i ] );
			}
		}

		return hero_list;
	},

	// 获取指定BID的所有伙伴
	getHeroListByBid: function( _bid ) {

		let hero_list = [];
		for( let hero_i in this.hero_array ) {
			if( _bid == this.hero_array[ hero_i ].bid ) {
				hero_list.push( this.hero_array[ hero_i ] );
			}
		}
		return hero_list;
	},

	// 改造 根据阵容获取4星以上英雄列表
	getHeroReformListByCamp: function( camp ) {

		let camp_type = camp || 0;
		let camp_fuse_list = [];
		let fuse_cfg = game.configs.partner_data.data_partner_fuse_star;
		if( !fuse_cfg ) return;
		for( let cfg_i in fuse_cfg ) {
			let fuse_cfg_item = fuse_cfg[ cfg_i ];

			let base_config = game.configs.partner_data.data_partner_base[ cfg_i ];
			for( let item_i in fuse_cfg_item ) {
				let star = fuse_cfg_item[ item_i ].star;
				let key = cfg_i + "_" + star;
				let star_config = gdata( "partner_data", "data_partner_star", key );
				// game.configs.partner_data.data_partner_star[key];

				if( base_config && ( base_config.camp_type == camp_type || camp_type === 0 ) ) {
					if( base_config && star_config && star_config.expend1.length > 0 ) {
						let fuse_data = {};
						// fuse_data.base_config = base_config;
						// fuse_data.star_config = star_config;
						fuse_data.result = HeroCalculate.getInstance().checkSingleStarFuseRedPointByStarConfig( star_config, false, cfg_i );
						fuse_data.red = fuse_data.result.is_redpoint ? 1 : 0;
						fuse_data._flag = "partner",
						fuse_data.camp_type = base_config.camp_type;
						fuse_data.bid = cfg_i;
						fuse_data.icon = base_config.item_id;
						fuse_data.res_id = star_config.res_id;
						fuse_data.item_id = base_config.item_id;
						fuse_data.quality = base_config.quality;
						fuse_data.type = base_config.type;
						fuse_data.stars = star;
						camp_fuse_list.push( fuse_data );
					}
				}
			}
		}

		return camp_fuse_list
	},

	// 根据阵容获取英雄列表
	getDeepHeroListByCamp: function( camp ) {
		if( typeof camp !== "number" ) return;
		var hero_list = [];

		for( var hero_i in this.hero_array ) {
			if( camp === HeroConst.CampType.eNone || camp === this.hero_array[ hero_i ].camp_type ) {
				hero_list.push( this.hero_array[ hero_i ] );
			}
		}

		var hero_sort = this.getHeroSortFunc();
		return hero_list.sort( hero_sort );
	},

	getRestHeroListByCamp: function( camp, type ) {
		if( typeof camp !== "number" ) return;
		var hero_list = [];
		for( var hero_i in this.hero_array ) {
			if( camp === HeroConst.CampType.eNone || camp === this.hero_array[ hero_i ].camp_type ) {
				if( type ) {
					if( this.hero_array[ hero_i ].is_lock == 0 ) {
						hero_list.push( this.hero_array[ hero_i ] );
					}
				} else {
					hero_list.push( this.hero_array[ hero_i ] );
				}


			}
		}

		var rest_hero_list = hero_list;
		for( var hero_i in rest_hero_list ) {
			var hero_vo = rest_hero_list[ hero_i ];
			if( hero_vo.is_in_form > 0 || hero_vo.is_lock ) {
				hero_vo.is_ui_lock = true;
			}
		}

		rest_hero_list.forEach( _item => {
			if( _item.face_id == 0 ) {
				_item.face_id = "null";
			}
		} )

		var hero_sort = function( role_vo1, role_vo2 ) {
			if( ( !role_vo1.is_ui_lock && !role_vo2.is_ui_lock ) || ( role_vo1.is_ui_lock && role_vo2.is_ui_lock ) ) {
				if( role_vo1.star === role_vo2.star ) {
					if( role_vo1.power == role_vo2.power ) {
						if( role_vo1.lev == role_vo2.lev ) {
							return role_vo2.sort_order - role_vo1.sort_order;
						} else {
							return role_vo1.lev - role_vo2.lev;
						}
					} else {
						return role_vo1.power - role_vo2.power;
					}
				} else {
					return role_vo1.star - role_vo2.star;
				}
			} else {
				if( role_vo1.is_ui_lock )
					return 1;
				return -1;
			}
		}



		return rest_hero_list.sort( hero_sort );
	},

	setHadHeroInfo: function( list ) {
		if( !list ) return;
		for( var hero_i in list ) {
			this.dic_had_hero_info[ list[ hero_i ].partner_id ] = list[ hero_i ].max_star;
		}

		let sfg = game.configs.source_data.data_source_data[ FID.Equips ];
		let eqm = nx.bridge.checkConditions( sfg.lev_limit );
		if( nx.dt.objEmpty( eqm ) ) {
			this.dealReformEqm();
		}

		// this.dealPartnerSplinterRed();
		// console.log( JSON.stringify( cfg ) + "裝備相關處理紅點起始" +  JSON.stringify(  eqms )  );
	},

	// 背包中 夥伴碎片合成紅點處理 
	dealPartnerSplinterRed: function() {

		let can_merge = BackpackController.getInstance().getModel().getHeroChipRedPoint();

		nx.mTip.openTip( "bag.partnermerge", can_merge );

	},

	// 處理 改造 義肢合成--- 芯片合成紅點
	dealReformEqm: function() {

		nx.mTip.openTip( "tipReform.equip.arm", false );
		nx.mTip.openTip( "tipReform.equip.foot", false );
		nx.mTip.openTip( "tipReform.equip.clothes", false );
		nx.mTip.openTip( "tipReform.equip.head", false );
		let cfg = game.configs.partner_eqm_data.data_eqm_compose_id;
		let artifacts = BackpackController.getInstance().getModel().getAllBackPackArray( BackPackConst.item_sub_type.SPECIAL );

		let eqms = BackpackController.getInstance().getModel().getBagItemList( BackPackConst.Bag_Code.EQUIPS );
		let count = 0;
		let type = [];
		let have = BackpackController.getInstance().getModel().getItemNumByBid( 1 );;
		for( let i in cfg ) {
			let eqm = cfg[ i ];
			let need = eqm.expend[ 0 ][ 0 ];
			for( let e in eqms ) {
				let eqmBag = eqms[ e ];
				if( eqmBag.base_id == need ) {
					if( eqmBag.quantity >= eqm.expend[ 0 ][ 1 ] && have >= eqm.expend[ 1 ][ 1 ] ) {
						count++;
						if( !nx.dt.arrMember( type, eqm.type ) ) {
							type.push( eqm.type );
						}
						// break;
					}
				}
			}
		}

		if( nx.dt.arrNEmpty( type ) ) {
			for( let i = 0; i < type.length; i++ ) {
				let item = type[ i ];
				if( item == 1 ) {
					nx.mTip.openTip( "tipReform.equip.arm", true );
				}
				else if( item == 2 ) {

					nx.mTip.openTip( "tipReform.equip.foot", true );

				}
				else if( item == 3 ) {

					nx.mTip.openTip( "tipReform.equip.clothes", true );

				}
				else if( item == 4 ) {

					nx.mTip.openTip( "tipReform.equip.head", true );

				}
			}
		}
		nx.mTip.openTip( "tipReform.equip", count > 0 );


		let acfg = game.configs.partner_artifact_data.data_artifact_data;
		let samef = [];
		let target_lev = 0;

		for( let arttt in acfg ) {
			let artcfg = nx.dt.objClone( acfg[ arttt ] );
			artcfg.quantity = 0;
			artcfg.needCoins = 0;
			artcfg.targetid = 0;
			artcfg.target_lev = 0;
			for( let art = 0; art < artifacts.length; art++ ) {

				let bag = artifacts[ art ];
				if( bag.base_id == artcfg.id ) {
					artcfg.quantity++;
					artcfg.targetid = artcfg.com_artifact;
					// artcfg.needCoins += 
				}

				if( artcfg.quantity >= 5 && acfg[ artcfg.targetid ] ) {
					artcfg.target_lev = acfg[ artcfg.targetid ].limit_lv;
				}

			}
			samef.push( artcfg );
		}
		let arthave = 0;
		let lev = 0;
		let needCoins = 0;
		samef.forEach( _art => {
			if( _art.quantity >= 5 ) {
				arthave = _art.quantity;
				lev = _art.target_lev;
				needCoins = _art.ref_expend[ 1 ][ 1 ];
			}
		} )

		nx.mTip.openTip( "tipReform.artifact", arthave >= 5 && RoleController.getInstance().getRoleVo().lev >= lev && have >= needCoins );
	},

	// 初始化图鉴数据
	getHeroPokedexList: function( camp ) {
		if( !this.dic_pokedex_info ) {
			this.dic_pokedex_info = {};
			for( var camp_i in HeroConst.CampType ) {
				if( camp_i !== "eNone" )
					this.dic_pokedex_info[ HeroConst.CampType[ camp_i ] ] = [];
			}
			var pokedex_cfg = game.configs.partner_data.data_partner_pokedex;
			if( pokedex_cfg ) {
				for( var bid in pokedex_cfg ) {
					var par_cfg = game.configs.partner_data.data_partner_base[ bid ];
					for( var star_i in pokedex_cfg[ bid ] ) {
						var star = pokedex_cfg[ bid ][ star_i ].star;
						var key = bid + "_" + star;
						var info = this.getHeroPokedexByBid( key );
						if( info ) {
							this.dic_pokedex_info[ info.camp_type ].push( info );
						}
					}
				}
			}

			var sort_function = function( dic_pokedex_1, dic_pokedex_2 ) {
				if( dic_pokedex_1.star === dic_pokedex_2.star ) {
					return dic_pokedex_1.bid - dic_pokedex_2.bid;
				} else {
					return dic_pokedex_1.star - dic_pokedex_2.star;
				}
			}
			// 排序
			for( var dic_pokedex_i in this.dic_pokedex_info ) {
				this.dic_pokedex_info[ dic_pokedex_i ].sort( sort_function );
			}
		}

		return this.dic_pokedex_info[ camp ]
	},

	getHeroPokedexByBid: function( key ) {
		if( this.dic_pokedex_bid[ key ] ) return this.dic_pokedex_bid[ key ];

		var par_show_cfg = gdata( "partner_data", "data_partner_show", key );
		if( !par_show_cfg ) {
			return null
		}

		var par_base_cfg = game.configs.partner_data.data_partner_base[ par_show_cfg.bid ];
		if( par_base_cfg ) {
			var break_lev = this.getHeroMaxBreakCountByInitStar( par_show_cfg.star );
			par_show_cfg.hp_max = par_show_cfg.hp // 为了计算战力用的 
			par_show_cfg.power = PartnerCalculate.calculatePower( par_show_cfg );
			par_show_cfg.camp_type = par_base_cfg.camp_type;
			par_show_cfg.name = par_base_cfg.name;
			par_show_cfg.init_star = par_base_cfg.init_star;
			par_show_cfg.type = par_base_cfg.type;
			par_show_cfg.break_id = par_base_cfg.break_id;
			par_show_cfg.break_lev = break_lev;
			par_show_cfg.partner_id = par_show_cfg.bid * 10 + par_show_cfg.star; // 定义一个唯一id	  
			par_show_cfg.is_pokedex = true; // 是不是图鉴  	
			this.dic_pokedex_bid[ key ] = par_show_cfg;
			return this.dic_pokedex_bid[ key ];
		}
		return null
	},

	// 根据初始星级 或者对应英雄最大进阶次数
	getHeroMaxBreakCountByInitStar: function( init_star ) {
		if( !this.dic_max_break ) {
			var val = game.configs.partner_data.data_partner_const.advanced_limit.val
			this.dic_max_break = {}
			for( var val_i in val ) {
				this.dic_max_break[ val[ val_i ][ 0 ] ] = val[ val_i ][ 1 ];
			}
		}
		return this.dic_max_break[ init_star ] || 0
	},

	// 根据品质获取默认头像
	getRandomHeroHeadByQuality: function( quality ) {
		if( !this.dic_random_hero_head ) {
			var val = game.configs.partner_data.data_partner_const.random_hero_icon.val;
			this.dic_random_hero_head = {}
			for( var val_i in val ) {
				var item_config = gitemdata( val[ val_i ][ 1 ] );
				if( item_config )
					this.dic_random_hero_head[ val[ val_i ][ 0 ] ] = item_config.icon;
			}
		}

		var quality = quality || 0;
		if( quality > 5 )
			quality = 5;
		return this.dic_random_hero_head[ quality ]
	},


	// --根据阵营和星级.得到对应来源的道具id
	// --self.dic_source_item_ids[camp][star] = item_id
	getSourceHeroCombinationByCampStar: function( camp, star ) {
		if( !this.dic_source_item_ids ) {
			this.dic_source_item_ids = []
			let val = game.configs.partner_data.data_partner_const.source_hero_combination.val
			for( var i in val ) {
				var val_i = val[ i ]
				if( this.dic_source_item_ids[ val_i[ 0 ] ] == null ) {
					this.dic_source_item_ids[ val_i[ 0 ] ] = []
				}
				this.dic_source_item_ids[ val_i[ 0 ] ][ val_i[ 1 ] ] = [ val_i[ 3 ] ]
			}
		}
		if( this.dic_source_item_ids[ camp ] ) {
			let star = star || 0
			if( star == 0 ) {
				star = 3 //--最低星就三
			}
			return this.dic_source_item_ids[ camp ][ star ]
		}
	},

	getHadHeroInfo: function() {
		return this.dic_had_hero_info || {}
	},

	getHadHeroStarBybid: function( bid ) {
		if( this.dic_had_hero_info && this.dic_had_hero_info[ bid ] ) {
			return this.dic_had_hero_info[ bid ]
		}
		return null
	},


	isOpenTanlentByHerovo( hero_vo ) {

		let data = game.configs.partner_skill_data.data_partner_skill_const[ "skill_slot" ].val;
		if( hero_vo[ data[ 0 ] ] ) {
			if( hero_vo[ data[ 0 ] ] >= data[ 1 ] ) {
				return true
			}
		}
		return false
	},
	/************阵法相关************/
	//order 参数用于同一类型玩法的多个组别
	setFormList: function( data, order ) {
		var form_type = data.type >= 0 ? data.type : PartnerConst.Fun_Form.Drama;
		if( this.pos_list[ form_type ] ) {
			if( order ) {
				for( var form_i in this.pos_list[ form_type ][ order ] ) {
					var vo = this.getHeroById( this.pos_list[ form_type ][ order ][ form_i ].id )
					if( vo && vo.updateFormPos ) {
						vo.updateFormPos( 0, form_type )
					}
				}
			} else {
				for( var form_i in this.pos_list[ form_type ] ) {
					var vo = this.getHeroById( this.pos_list[ form_type ][ form_i ].id )
					if( vo && vo.updateFormPos ) {
						vo.updateFormPos( 0, form_type )
					}
				}
			}
		}

		this.pos_list[ form_type ] = {}
		if( order ) {
			this.pos_list[ form_type ][ order ] = {};
			for( var pos_i in data.pos_info ) {
				this.pos_list[ form_type ][ order ][ data.pos_info[ pos_i ].pos ] = data.pos_info[ pos_i ];
				var vo = this.getHeroById( data.pos_info[ pos_i ].id )
				// 容错处理  bugly出现说  updateFormPos 这个是 (a null value)
				if( vo && vo.updateFormPos )
					vo.updateFormPos( data.pos_info[ pos_i ].pos, form_type );
			}
		} else {
			for( var pos_i in data.pos_info ) {
				this.pos_list[ form_type ][ data.pos_info[ pos_i ].pos ] = data.pos_info[ pos_i ];
				var vo = this.getHeroById( data.pos_info[ pos_i ].id )
				// 容错处理  bugly出现说  updateFormPos 这个是 (a null value)
				if( vo && vo.updateFormPos )
					vo.updateFormPos( data.pos_info[ pos_i ].pos, form_type );
			}
		}

		// 剧情阵法逻辑
		if( form_type == PartnerConst.Fun_Form.Drama ) {
			this.form_power = data.power || 0;
			// 阵法类型
			this.use_formation_type = data.formation_type;
			// 使用的圣器id
			this.use_hallows_id = data.hallows_id;

			// gcore.GlobalEvent.fire(HeroEvent.Form_Drama_Event,data)
			// var calculate = HeroCalculate.getInstance();
			// RedMgr.getInstance().addCalHandler( calculate.checkAllHeroRedPoint.bind( calculate ), RedIds.HeroAll );

			// 检测红点
			// HeroCalculate.getInstance().checkAllHeroRedPoint();
			let list = []
			if( order ) {
				for( let k in this.pos_list[ form_type ][ order ] ) {
					let v = this.pos_list[ form_type ][ order ][ k ]
					list.push( {
						partner_id: v.id
					} )
				}
			} else {
				for( let k in this.pos_list[ form_type ] ) {
					let v = this.pos_list[ form_type ][ k ]
					list.push( {
						partner_id: v.id
					} )
				}
			}
			// --请求天赋的
			HeroController.getInstance().sender11099( list )
		}
	},

	// 获取最高战力的英雄战力
	getMaxFight: function() {
		if( this.hero_array ) {
			this.hero_array.sort( Utils.tableUpperSorter( [ "power" ] ) );
			var hero_vo = this.hero_array[ 0 ];
			if( hero_vo ) {
				return hero_vo.power
			}
		}
		return 0
	},
	//通过bid获取等级最高的英雄信息
	getTopLevHeroInfoByBid( bid ) {
		if( !bid ) return;
		let list = this.hero_bid_list[ bid ]
		if( list ) {
			list.sort( Utils.tableUpperSorter( [ "lev", "power" ] ) )
			return list[ 0 ]
		}
		return null
	},
	//雇佣的
	getExpeditHeroData: function() {
		var hero_list = this.getAllHeroArray();
		var list = [];
		for( var i = 0; i < hero_list.length; i++ ) {
			var tab = {}
			tab.power = hero_list[ i ].power;
			tab.name = hero_list[ i ].name;
			tab.bid = hero_list[ i ].bid;
			tab.index = i;

			tab.rid = hero_list[ i ].rid;
			tab.srv_id = hero_list[ i ].srv_id;
			tab.id = hero_list[ i ].id;
			tab.star = hero_list[ i ].star;
			tab.lev = hero_list[ i ].lev;
			tab.use_skin = hero_list[ i ].use_skin;

			list.push( tab );
		}
		list.sort( function( a, b ) {
			return b.power < a.power;
		} );
		return list
	},

	getTeamOrderPosList( type ) {
		return this.pos_list[ type ]
	},

	// 获取自己的队伍阵法站位
	getMyPosList: function() {
		return this.pos_list[ PartnerConst.Fun_Form.Drama ] || {}
	},

	getHeroSortFunc: function() {
		var hero_sort = function( role_vo1, role_vo2 ) {

			if( role_vo1.star === role_vo2.star ) {
				if( role_vo1.power == role_vo2.power ) {
					if( role_vo1.lev == role_vo2.lev ) {
						return role_vo1.sort_order - role_vo2.sort_order;
					} else {
						return role_vo2.lev - role_vo1.lev
					}
				} else {
					return role_vo2.power - role_vo1.power
				}
			} else {
				return role_vo2.star - role_vo1.star
			}
		}
		return hero_sort
	},

	isMaxStarHero: function( bid, star ) {
		if( !bid || !star ) return false;
		var max_star = game.configs.partner_data.data_partner_max_star[ bid ];
		if( max_star && star >= max_star ) {
			return true
		}
		if( star >= this.hero_info_upgrade_star_param ) {
			if( star == this.hero_info_upgrade_star_param2 ) {
				// --10级升11有世界等级要求
				return !this.checkOpenStar11()
			} else if( star == this.hero_info_upgrade_star_param3 ) {
				return !this.checkOpenStar12()
			} else if( star == this.hero_info_upgrade_star_param4 ) {
				return !this.checkOpenStar13()
			}
		}
		return false;
	},

	// checkSingleStarFuseRedPointByStarConfig
	getStarFuseList: function( camp_type ) {
		camp_type = camp_type || 0;
		var camp_fuse_list = [];
		var fuse_cfg = game.configs.partner_data.data_partner_fuse_star;
		if( !fuse_cfg ) return
		for( var cfg_i in fuse_cfg ) {
			var fuse_cfg_item = fuse_cfg[ cfg_i ];
			var base_config = game.configs.partner_data.data_partner_base[ cfg_i ];
			for( var item_i in fuse_cfg_item ) {
				var star = fuse_cfg_item[ item_i ].star;
				var key = cfg_i + "_" + star;
				var star_config = gdata( "partner_data", "data_partner_star", key );
				// game.configs.partner_data.data_partner_star[key];

				if( base_config && ( base_config.camp_type == camp_type || camp_type === 0 ) ) {
					if( base_config && star_config && star_config.expend1.length > 0 ) {
						var fuse_data = {};
						fuse_data.base_config = base_config;
						fuse_data.star_config = star_config;
						fuse_data.camp_type = base_config.camp_type;
						fuse_data.bid = cfg_i;
						fuse_data.star = star;
						camp_fuse_list.push( fuse_data );
					}
				}
			}
		}

		return camp_fuse_list
	},

	// --根据bid 获取一个模拟herovo对象..属性都是1级的
	getMockHeroVoByBid( bid ) {
		let base_config = game.configs.partner_data.data_partner_base[ bid ]
		let attr_config = game.configs.partner_data.data_partner_attr[ bid ]
		if( !base_config || !attr_config ) {
			return
		}

		let hero_vo = nx.dt.objClone( base_config )
		hero_vo.star = base_config.init_star //--默认星数
		hero_vo.break_lev = 0 //--默认进阶
		for( let k in attr_config ) { // k,v in pairs(attr_config) do
			let v = attr_config[ k ]
			if( !hero_vo[ k ] ) {
				hero_vo[ k ] = v
			}
		}
		hero_vo.hp = attr_config.hp_max //--血量等于最大血量
		hero_vo.power = PartnerCalculate.calculatePower( hero_vo )
		return hero_vo
	},
	/****************装备相关******************/
	updateHeroEquipList: function( data ) {
		var partner_id = data.partner_id;
		if( partner_id && this.hero_list[ partner_id ] ) {
			var hero_vo = this.hero_list[ partner_id ];
			// 判断战力变化
			this.hero_list[ partner_id ].updateHeroVo( data );
		}
	},

	getHeroEquipList: function( parener_id ) {
		if( this.hero_list[ parener_id ] ) {
			return this.hero_list[ parener_id ].eqm_list;
		}
	},


	//----------------------------符文锻造相关------------------------


	//获取符文祝福红点状态
	getArtifactLuckyRedStatus: function() {
		return this.artifact_lucky_red
	},

	//符文祝福值
	setArtifactLucky: function( value ) {
		this.artifact_lucky = value;
		this.updateArtifactLuckyRed();
		// RedMgr.getInstance().addCalHandler( this.updateArtifactLuckyRed.bind( this ) )
	},

	getArtifactLucky: function() {
		return this.artifact_lucky || 0
	},

	//祝福值红点
	updateArtifactLuckyRed: function() {
		var max_lucky = 0;
		var lucky_cfg = game.configs.partner_artifact_data.data_artifact_const[ "change_condition" ];
		if( lucky_cfg && lucky_cfg.val != null ) {
			max_lucky = lucky_cfg.val;
		}
		if( this.artifact_lucky >= max_lucky ) {
			this.artifact_lucky_red = true;
		} else {
			this.artifact_lucky_red = false;
		}
		gcore.GlobalEvent.fire( HeroEvent.Artifact_Lucky_Red_Event );
	},

	updatePartnerArtifactList: function( data ) {
		var id = data.partner_id || 0;
		if( this.hero_list[ id ] ) {
			var hero_vo = this.hero_list[ id ];
			if( hero_vo ) {
				this.hero_list[ id ].updateHeroVo( data );
				gcore.GlobalEvent.fire( HeroEvent.Artifact_Update_Event, hero_vo );
				// let is_artifact =  PartnerCalculate.getIsCanClothArtifact(hero_vo.bid);				
				// hero_vo.updateRedPoint(PartnerConst.Vo_Red_Type.Artifact,false)
			}
		}
	},

	getPartnerArtifactList: function( id ) {
		if( this.hero_list[ id ] ) {
			return this.hero_list[ id ].artifact_list || []
		}
		return []
	},

	// -- 符文重鑄次數相關數據
	updateArtifactRecastCount( data_list ) {
		this.artifact_recast_data = data_list;
	},

	// -- 根據符文品質獲取對應品質的重鑄次數
	getArtifactRecastCountByQuality( quality ) {
		let count = 0
		let max_count = 0
		let _type = 0
		if( quality == BackPackConst.quality.orange ) { // 彩虹符文
			_type = 1
		} else if( quality == BackPackConst.quality.red ) { // 閃爍符文
			_type = 2
		}
		if( this.artifact_recast_data && _type > 0 ) {
			for( let k in this.artifact_recast_data ) {
				let v = this.artifact_recast_data[ k ]
				if( v.type == _type ) {
					count = v.current
					max_count = v.limit
					break
				}
			}
		}
		return {
			count: count,
			max_count: max_count
		};
	},
	//---------------------------符文锻造相关end-------------------------

	setLockByPartnerid: function( partner_id, is_lock ) {
		if( this.hero_list[ partner_id ] ) {
			this.hero_list[ partner_id ].is_lock = is_lock || 0;
		}
	},

	// 活动英雄列表 根据匹配信息 熔炼祭坛用
	// @dic_the_conditions 指定匹配 dic_the_conditions[bid][star] = 数量
	// @dic_random_conditions 随机阵容匹配 dic_the_conditions[camp][star] = 数量
	// @dic_hero_id 标志已用
	// return
	// @ count 拥有不重复英雄总数量
	getHeroListByMatchInfo: function( dic_the_conditions, dic_random_conditions, dic_hero_id ) {
		// 找不重复的数量
		var count = 0;
		var dic_hero_id = dic_hero_id || {};
		var dic_count = {};

		var _setDicCount = function( partner_id, str, max ) {

			// 判断是否重复
			if( !dic_hero_id[ partner_id ] ) {
				if( !dic_count[ str ] )
					dic_count[ str ] = 0;
				if( dic_count[ str ] < max ) {
					dic_count[ str ] = dic_count[ str ] + 1;
					count = count + 1;
					dic_hero_id[ partner_id ] = 1;
				}
			}
		}
		for( var hero_i in this.hero_list ) {
			var hero = this.hero_list[ hero_i ];
			if( dic_the_conditions && dic_the_conditions[ hero.bid ] && dic_the_conditions[ hero.bid ][ hero.star ] &&
				hero.is_in_form == 0 && hero.is_lock == 0 && nx.dt.objEmpty( hero.dic_locks ) ) {
				var str = cc.js.formatStr( "%s%s", hero.bid, hero.star );
				_setDicCount( hero.partner_id, str, dic_the_conditions[ hero.bid ][ hero.star ] );
			}

			if( dic_random_conditions ) {
				// 0表示所有阵营的合适
				if( dic_random_conditions[ 0 ] && dic_random_conditions[ 0 ][ hero.star ] && hero.is_in_form == 0 && hero.is_lock == 0 ) {
					// if (dic_random_conditions[0][hero.star]) {
					var str = cc.js.formatStr( "_%s%s", 0, hero.star )
					_setDicCount( hero.partner_id, str, dic_random_conditions[ 0 ][ hero.star ] );
					// }
				} else {
					if( dic_random_conditions[ hero.camp_type ] && dic_random_conditions[ hero.camp_type ][ hero.star ] && hero.is_in_form == 0 && hero.is_lock == 0 ) {
						var str = cc.js.formatStr( "_%s%s", hero.camp_type, hero.star );
						_setDicCount( hero.partner_id, str, dic_random_conditions[ hero.camp_type ][ hero.star ] );
					}
				}
			}
		}

		return count;
	},

	/***********************************红点检查********************************/



	// 检测升级红点更新
	checkLevelRedPointUpdate: function() {
		// gcore.GlobalEvent.fire(HeroEvent.Level_RedPoint_Event) 

		// if (this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp])
		//     return

		// this.is_delay_redpoint_update[HeroConst.RedPointType.eRPLevelUp] = true;
		// 清除升级红点记录
		HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPLevelUp, true )
	},

	// 检查阵法解锁 
	checkUnlockFormRedPoint: function() {

	},

	// 设置更新equip红点的记录
	setEquipUpdateRecord: function( bool ) {
		this.is_equip_redpoint_bag_update = bool;
		this.is_equip_redpoint_hero_update = bool;
	},

	// 检查装备红点 
	checkEquipRedPointUpdate: function() {
		// 需要 背包 返回 和 英雄更新返回 才处理红点计算
		if( this.is_equip_redpoint_bag_update && this.is_equip_redpoint_hero_update ) {
			//清除装备红点记录
			HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPEquip );
			gcore.GlobalEvent.fire( HeroEvent.Equip_RedPoint_Event );
		}
	},

	// 设置更新升星红点的记录
	setUpgradeStarUpdateRecord: function( bool ) {
		this.is_upgradestar_redpoint_bag_update = bool;
		this.is_upgradestar_redpoint_hero_update = bool;
	},

	// 升星红点检查
	checkUpgradeStarRedPointUpdate: function() {
		// 需要 背包 返回 和 英雄更新返回 才处理红点计算
		if( this.is_upgradestar_redpoint_bag_update && this.is_upgradestar_redpoint_hero_update ) {
			HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPStar );
		}
	},

	// 检查圣器解锁
	checkUnlockHallowsRedPoint: function() {

	},

	checkHighStarCondition: function( _star ) {



		let can = [];
		let star = _star + 1;
		// let role_vo = RoleController.getInstance();
		let cfg = game.configs.partner_data.data_get_star_cond[ star ];

		switch( _star ) {
			case 10: { can = this.dealStar11( cfg ); }; break;
			case 11: { can = this.dealStar11( cfg ); }; break;
			case 12: { can = this.dealStar13( cfg ); }; break;
		}
		return can;
	},


	// 升星 11、12 条件是否达成判断
	dealStar11: function( _cfg ) {

		this.desc = [];
		let role_vo = RoleController.getInstance();
		let levEnough = false;
		let slevEnough = true;
		let worldlevEnough = true;
		let results = [];
		let conds = [];
		for( let i = 0; i < _cfg.cond1.length; i++ ) {
			let cond = _cfg.cond1[ i ];

			if( cond[ 0 ] == "lev" ) {
				if( role_vo.getRoleVo().lev >= cond[ 1 ] ) {
					levEnough = true;
				} else {
					this.desc.push( _cfg.desc1 + nx.text.getKey( "UpStarsNeedTip" ) );
					conds.push( role_vo.getRoleVo().lev >= cond[ 1 ] );
					break;
				}

			}

			if( cond[ 0 ] == "hero_star" ) {
				let have = 0;
				have = this.getHeroListByStar( cond[ 1 ] ).length;
				if( have < cond[ 2 ] && !levEnough ) {
					this.desc.push( _cfg.desc1 + nx.text.getKey( "UpStarsNeedTip" ) );
					conds.push( have < cond[ 2 ] );

				}

			}

		}

		results.push( ( conds.length == 0 ) );

		
		if( role_vo.getRoleVo().lev < _cfg.cond3[ 1 ] ) {
			slevEnough = false;
		}
		results.push( slevEnough );
		this.desc.push( _cfg.desc3 + nx.text.getKey( "UpStarsNeedTip" ) );

		return results;

	},

	// 升星 11、12 条件是否达成判断
	dealStar13: function( _cfg ) {

		this.desc = [];
		let role_vo = RoleController.getInstance();
		let levEnough = false;
		let slevEnough = true;
		let worldlevEnough = true;
		let results = [];
		let conds = [];
		let cond2s = [];
		let cond3s = [];
		for( let i = 0; i < _cfg.cond1.length; i++ ) {
			let cond = _cfg.cond1[ i ];

			if( cond[ 0 ] == "lev" ) {
				if( role_vo.getRoleVo().lev >= cond[ 1 ] ) {
					levEnough = true;
				} else {
					this.desc.push( _cfg.desc1 + nx.text.getKey( "UpStarsNeedTip" ) );
					conds.push( role_vo.getRoleVo().lev >= cond[ 1 ] );
					break;
				}

			}

			if( cond[ 0 ] == "hero_star" ) {
				let have = 0;
				have = this.getHeroListByStar( cond[ 1 ] ).length;
				if( have < cond[ 2 ] && !levEnough ) {
					this.desc.push( _cfg.desc1 + nx.text.getKey( "UpStarsNeedTip" ) );
					conds.push( have < cond[ 2 ] );

				}

			}

		}

		results.push( ( conds.length == 0 ) );

		
		for( let t = 0; t < _cfg.cond3.length; t++ ) {
			let cond = _cfg.cond3[ t ];

			if( role_vo.getRoleVo().lev < cond[ 1 ] ) {
				slevEnough = false;
				this.desc.push( _cfg.desc3 + nx.text.getKey( "UpStarsNeedTip" ) );
				cond3s.push( role_vo.getRoleVo().lev >= cond[ 1 ] );
				break;
			}

			if( cond[ 0 ] == "hero_star" ) {
				let have = 0;
				have = this.getHeroListByStar( cond[ 1 ] ).length;
				if( have < cond[ 2 ] && !slevEnough ) {
					this.desc.push( _cfg.desc3 + nx.text.getKey( "UpStarsNeedTip" ) );
					cond3s.push( have < cond[ 2 ] );

				}

			}

		}


		results.push( ( cond3s.length == 0 ) );

		return results;

	},



	getDescs: function() {

		return this.desc;

	},


	checkOpenStar11: function() {

		this.desc = [];
		let is_open = true;
		let all = [];
		let role_vo = RoleController.getInstance().getRoleVo()
		// var RoleController = require( "role_controller" );
		let config = game.configs.partner_data.data_partner_const.staropen11_world_lev;
		if( config ) {
			if( config.val[ 0 ] == "world_lev" ) {
				let world_lev = RoleController.getInstance().getModel().getWorldLev() || 0
				if( world_lev < config.val[ 1 ] ) {
					is_open = false;
					all.push( world_lev < config.val[ 1 ] );

				}
			}
			this.desc.push( ( config.desc + config.val[ 1 ] ) );
		}

		// --要麼滿足 個人等級條件
		// if( !is_open ) {
		let config_lev = game.configs.partner_data.data_partner_const.staropen11_player_lev
		if( config_lev && config_lev.val[ 0 ] == "lev" ) {

			if( role_vo && role_vo.lev < config_lev.val[ 1 ] ) {
				is_open = false
				all.push( role_vo.lev < config_lev.val[ 1 ] );

			}
			this.desc.push( ( config_lev.desc + config_lev.val[ 1 ] ) );
		}
		// }

		// --策劃加的額外條件
		let config2 = game.configs.partner_data.data_partner_const.staropen11_3rd_open_limit;
		let conditions = config2.val;
		let enough = false;
		for( let c = 0; c < conditions.length; c++ ) {
			let item = conditions[ c ];
			if( item[ 0 ] = "lev" ) {
				if( role_vo.lev < item[ 1 ] ) {
					all.push( role_vo.lev < item[ 1 ] );
				}

			}
			if( item[ 0 ] = "hero_star" ) {
				let have = 0;
				have = this.getHeroListByStar( item[ 1 ] ).length;
				if( have < item[ 2 ] ) {
					all.push( have < item[ 2 ] );

				}
				// have = this.gethero
			}

		}
		this.desc.push( ( config2.desc ) );
		// let is_condition_3 = this.checkExtOpenInfo( config2 );
		// if( !is_condition_3 ){
		// 	all.push( is_condition_3 );
		// }

		// // if( !is_open ) {
		// 	is_open = is_condition_3 || false
		// // }

		return all.length == 0;
	},

	checkOpenStar12: function() {
		let is_open = true;
		// var RoleController = require( "role_controller" );
		let config = game.configs.partner_data.data_partner_const.staropen12_world_lev
		if( config ) {
			if( config.val[ 0 ] == "world_lev" ) {
				let world_lev = RoleController.getInstance().getModel().getWorldLev() || 0
				if( world_lev < config.val[ 1 ] ) {
					is_open = false;
				}
			}
		}

		// --要麼滿足 個人等級條件
		if( !is_open ) {
			is_open = true
			let config_lev = game.configs.partner_data.data_partner_const.staropen12_player_lev
			if( config_lev && config_lev.val[ 0 ] == "lev" ) {
				let role_vo = RoleController.getInstance().getRoleVo()
				if( role_vo && role_vo.lev < config_lev.val[ 1 ] ) {
					is_open = false
				}
			}
		}

		// --策劃加的額外條件
		let config2 = game.configs.partner_data.data_partner_const.staropen12_3rd_open_limit
		let is_condition_3 = this.checkExtOpenInfo( config2 )
		if( !is_open ) {
			is_open = is_condition_3 || false
		}

		return is_open;
	},

	checkOpenStar13: function() {
		let self = this;
		if( self.is_star13_open ) { //如果已經計算開啟過了.就不計算了
			return true
		}
		// --優先判斷 等級 第一條件不滿足再判斷第二條件
		let config = game.configs.partner_data.data_partner_const.staropen13_limit_lev2
		let is_open = true
		if( config ) {
			if( self.checkOpenByKeyValue( config.val[ 0 ], config.val[ 1 ] ) ) {
				is_open = false
			}
		}
		// --如果上面不滿足 再判斷第二個條件
		if( !is_open ) {
			is_open = true
			let config = game.configs.partner_data.data_partner_const.staropen13_limit_lev1
			if( config ) {
				for( let i in config.val ) {
					let v = config.val[ i ]
					if( self.checkOpenByKeyValue( v[ 0 ], v[ 1 ] ) ) {
						is_open = false
						break
					}
				}
			}
		}
		// --條件1 個人和世界等級達到170級 或 個人等級到達180級 開啟升星
		let is_condition_1 = is_open
		// --條件2 擁有2個12星英雄開啟升星
		let is_condition_2 = false
		// --條件3 個人等級達到150，且擁有5個及以上的12星，13星
		let is_condition_3 = false

		// --第二個硬性條件
		// --13星特殊要 曾經有2個12星英雄
		let config2 = game.configs.partner_data.data_partner_const.staropen13_limit_partner
		if( config2 && config2.val ) {
			let count = 0
			for( let k in self.dic_had_hero_info ) {
				let star = self.dic_had_hero_info[ k ]
				if( star >= config2.val[ 0 ] ) {
					count = count + 1
					if( count >= config2.val[ 1 ] ) {
						break
					}
				}
			}
			if( count < config2.val[ 1 ] ) {
				is_open = false
				is_condition_2 = false
			} else {
				is_condition_2 = true
			}
		}
		is_condition_2 = is_open

		// --策劃加的額外條件
		let config3 = game.configs.partner_data.data_partner_const.staropen13_3rd_open_limit
		is_condition_3 = self.checkExtOpenInfo( config3 )
		if( !is_open ) {
			is_open = is_condition_3
		}

		// local tips_str = nil
		// if is_show_tips and not is_open then
		// 	-- if not is_condition_1 and not is_condition_2 and not is_condition_3 then
		// 	--     --三個條件都不滿足
		// 	--     tips_str = TI18N("滿足以下任意條件開啟：1.擁有2個12星英雄 並且個人和世界等級達到170級 \n2. 擁有2個12星英雄 並且個人等級到達180級 \n3.擁有5個12星英雄 並且個人等級達到150級")
		// 	-- end

		// 	-- if not is_condition_1 and not is_condition_2 then
		// 	--     --兩個都不滿足
		// 	--     tips_str = TI18N("滿足以下條件開啟：1.擁有2個12星英雄\n2.個人和世界等級達到170級 或 個人等級到達180級")
		// 	-- elseif not is_condition_1 and is_condition_2 then
		// 	--     tips_str = TI18N("個人和世界等級達到170級 或 個人等級到達180級 開啟升星")
		// 	-- else
		// 	--     tips_str = TI18N("擁有2個12星英雄開啟升星")
		// 	-- end
		// 	tips_str = self:getTipsStr(13)
		// end
		if( is_open ) {
			// --如果已經開啟 那麼記錄
			self.is_star13_open = true
		}
		return is_open;
	},

	checkExtOpenInfo( config ) {
		// -- 策劃要求:原來的條件沒變。只是新增一個或條件，
		// -- 個人等級達到100/120/150，且擁有5個及以上的10/11/12星，開啟11/12/13星
		let val = config.val
		if( val == null ) return false;

		if( this.checkOpenByKeyValue( val[ 0 ][ 0 ], val[ 0 ][ 1 ] ) ) {
			return false
		}
		if( val[ 1 ] == null ) return false;
		// -- local hero_star = val[2][1] or "hero_star" --這個前端不需要..因為需要寫死的
		let star = val[ 1 ][ 1 ] || 10
		let count = val[ 1 ][ 2 ] || 5


		if( this.dic_star_count[ star ] == null ) {
			this.dic_star_count[ star ] = 0
			for( let k in this.dic_had_hero_info ) {
				let _star = this.dic_had_hero_info[ k ];
				if( _star >= star ) {
					this.dic_star_count[ star ] = this.dic_star_count[ star ] + 1
					if( this.dic_star_count[ star ] >= count ) {
						break
					}
				}
			}
			if( this.dic_star_count[ star ] >= count ) {
				return true
			}
		} else {
			if( this.dic_star_count[ star ] >= count ) {
				return true
			}
		}
		return false
	},

	// --return true 表示不滿足  false 表示滿足
	checkOpenByKeyValue( key, value ) {
		if( !value ) return false;
		// var RoleController = require( "role_controller" );
		if( key == "world_lev" ) {
			let world_lev = RoleController.getInstance().getModel().getWorldLev() || 0
			return world_lev < value
		} else if( key == "lev" ) {
			let role_vo = RoleController.getInstance().getRoleVo()
			if( role_vo && role_vo.lev < value ) {
				return true
			}
		}
		return false
	},
	//---------------------天赋技能---------------------------
	// --设置更新天赋红点
	setUpdateTalentRedpoint() {
		this.is_need_update_talent_redpoint = true
	},
	getTalentRedpointRecord() {
		var self = this
		if( self.is_need_update_talent_redpoint ) {
			let dic_config = game.configs.partner_skill_data.data_partner_skill_learn
			if( dic_config ) {
				let is_enough
				for( let k in dic_config ) {
					let config = dic_config[ k ]
					self.dic_hero_talent_skill_learn_redpoint[ config.id ] = null
					is_enough = true
					for( let i = 0; i < config.expend.length; ++i ) {
						let v = config.expend[ i ]
						let count = BackpackController.getInstance().getModel().getItemNumByBid( v[ 0 ] )
						if( count < v[ 1 ] ) {
							is_enough = false
							break
						}
					}
					if( is_enough ) {
						self.dic_hero_talent_skill_learn_redpoint[ config.id ] = config.id
					}
				}
			}
		}
		self.is_need_update_talent_redpoint = false
		if( !Utils.next( self.dic_hero_talent_skill_learn_redpoint ) ) {
			self.dic_hero_talent_skill_learn_redpoint = {}
		}
		return self.dic_hero_talent_skill_learn_redpoint
	},
	// --检测天赋红点更新
	checkTalentRedPointUpdate() {
		if( this.is_delay_redpoint_update[ HeroConst.RedPointType.eRPTalent ] ) {
			return
		}
		this.is_delay_redpoint_update[ HeroConst.RedPointType.eRPTalent ] = true
		// --清除天赋红点记录
		HeroCalculate.getInstance().clearAllHeroRecordByRedPointType( HeroConst.RedPointType.eRPTalent, true )

	},
	// --增加详细信息
	updateHeroVoDetailedInfo( info ) {
		if( !info ) return
		if( this.hero_list[ info.partner_id ] ) {
			cc.log( this.hero_list[ info.partner_id ], info )
			for( let k in info ) {
				let v = info[ k ]
				this.hero_list[ info.partner_id ][ k ] = v
			}
			this.hero_list[ info.partner_id ].is_had_detailed = true
			gcore.GlobalEvent.fire( HeroEvent.Hero_Vo_Detailed_info, this.hero_list[ info.partner_id ] )
		}
	},


	//初始化皮肤 信息英雄皮肤 
	initHeroSkin: function( data ) {

		let lists = this.getHeroReformListByCamp( 0 );
		let count = 0;
		lists.forEach( _item => {

			if( _item.result.is_redpoint ) {
				count++;
			}
		} );
		nx.mTip.openTip( "tipReform.show", count > 0 );

		if( !data ) return
		//判定是否要显示卡片展示界面
		if( this.hero_skin_list ) {
			let show_skin_id = null;
			for( let i in data.partner_skins ) {
				let v = data.partner_skins[ i ];
				if( this.hero_skin_list[ v.id ] == null ) {
					show_skin_id = v.id;
					break
				}
			}
			if( show_skin_id ) {
				nx.bridge.createPanel( "WndPartnerSkinReward", { skin_id: show_skin_id } );
			}
		}

		this.hero_skin_list = {};

		for( let i in data.partner_skins ) {
			let v = data.partner_skins[ i ];
			this.hero_skin_list[ v.id ] = v.end_time;
		}

		gcore.GlobalEvent.fire( HeroEvent.Hero_Skin_Info_Event, data );
	},

	//根据皮肤id 返回皮肤数据  
	//@return 皮肤有效时间点..  如果永久返回 0 如果返回nil 表示 没有解锁该皮肤
	getHeroSkinInfoBySkinID: function( skin_id ) {
		if( this.hero_skin_list && this.hero_skin_list[ skin_id ] != null ) {
			return this.hero_skin_list[ skin_id ]
		}
	},

	//--是否解锁该皮肤
	//is_check_time:判断是否过期
	isUnlockHeroSkin: function( skin_id, is_check_time ) {
		if( this.hero_skin_list && this.hero_skin_list[ skin_id ] != null ) {
			if( is_check_time ) {
				if( this.hero_skin_list[ skin_id ] > 0 ) {
					return false
				}
			}
			return true
		}
		return false
	},

	//共鸣水晶

	getCystalPreLevLimit: function() {
		if( this.cystal_pre_lev_limit == null ) {
			this.cystal_pre_lev_limit = 340;
			var config = game.configs.resonate_data.data_const.cystal_pre_lev_limit;
			if( config ) {
				this.cystal_pre_lev_limit = config.val;
			}
		}
		return this.cystal_pre_lev_limit || 340;
	},
	// --是否共鸣水晶最大等级 注意: 还有一个突破上限等级  后端传过来的
	isResonateCystalMaxLev: function() {
		// --340 英雄 13星升级的最大等级 
		if( this.resonate_cystal_lev && this.resonate_cystal_lev >= this.getCystalPreLevLimit() ) {
			return true;
		}
		return false;
	},
	isCanShowLabelMaxLev: function( lev ) {
		if( lev && lev < this.getCystalPreLevLimit() ) {
			return false;
		}
		return true;
	},
	getDicResonateFiveHeroVo: function() {
		return this.dic_resonate_five_hero_vo || {}
	},
	// --是否共鸣水晶上阵的英雄 如果 hero_vo 不确定是 hero_vo 类的 用此方法判断
	isResonateCystalHero: function( hero_vo ) {
		if( hero_vo.isResonateCrystalHero ) {
			if( hero_vo.isResonateCrystalHero() ) {
				return true
			}
		} else if( hero_vo.resonate_lev && hero_vo.resonate_lev > 0 ) {
			return true
		}
		return false
	},

	// 更新共鸣锁定信息
	updateResonateCystalInfo: function( data ) {
		if( !data ) {
			return
		}
		this.resonate_cystal_lev = data.lev
		this.dic_resonate_five_hero_vo = {}

		var star = 0;
		for( var i in data.con_list ) {
			var v = data.con_list[ i ]
			if( v.id != 0 ) {
				var hero_vo = this.getHeroById( v.id )
				if( hero_vo && Utils.next( hero_vo ) != null ) {
					this.dic_resonate_five_hero_vo[ hero_vo.id ] = hero_vo
				}
				if( hero_vo.star ) {
					star = star + hero_vo.star;
				}
			}
		}
		for( var i in this.dic_resonate_lock_info ) {
			var hero_vo = this.dic_resonate_lock_info[ i ]
			if( hero_vo.updateLock ) {
				var _data = [ {
					lock_type: HeroConst.LockType.eHeroResonateLock,
					is_lock: 0
				} ]

				hero_vo.updateLock( _data )
			}
		}
		this.dic_resonate_lock_info = {};
		for( var i in data.res_list ) {
			var v = data.res_list[ i ]
			if( v.id != 0 ) {
				var hero_vo = this.getHeroById( v.id )
				if( hero_vo && hero_vo.updateLock ) {
					this.dic_resonate_lock_info[ v.id ] = hero_vo
					var _data2 = [ {
						lock_type: HeroConst.LockType.eHeroResonateLock,
						is_lock: 1
					} ]
					hero_vo.updateLock( _data2 );
				}
			}
		}
		if( this.resonate_max_partner_lev == null ) {
			// -- 说明26400没有返回了
			this.resonate_max_partner_lev = star
		}
	},
	updateResonateLockInfo: function( data ) {
		this.resonate_stone_level = data.lev || 0
		this.resonate_max_partner_lev = data.max_partner_lev || 0
		// --判断是有红点
		this.checkResonateRedPoint();
	},
	checkResonateRedPoint: function() {
		if( !this.resonate_stone_level ) {
			return
		}
		if( !this.resonate_max_partner_lev ) {
			return
		}

		let resonate_stone_condition = 50
		let config = game.configs.resonate_data.data_const.amp_all_start_limit;
		if( config ) {
			resonate_stone_condition = config.val
		}
		// --不满足开启不计算显示了
		if( this.resonate_max_partner_lev < resonate_stone_condition ) {
			return
		}

		let config2 = gdata( "resonate_data", "data_level_up", this.resonate_stone_level );
		let is_redpoint = false
		if( config2 ) {
			if( config2.expend && Utils.next( config2.expend ) != null ) {
				is_redpoint = true
				for( var i in config2.expend ) {
					var v = config2.expend[ i ]
					let bid = v[ 0 ]
					let num = v[ 1 ]
					let have_num = BackpackController.getInstance().getModel().getItemNumByBid( bid );
					if( num && num > have_num ) {
						is_redpoint = false
					}
				}
			}
		}
		this.is_resonate_stone_redpoint = is_redpoint

	},
	// 是否最高等级
	isResonateMaxLevel: function( lev ) {
		if( lev ) {
			let config = gdata( "resonate_data", "data_level_up", lev + 1 )
			if( config == null ) {
				return true
			}
		}
		return false
	},
	// 共鸣是否开启
	checkResonateIsOpen: function( not_tips ) {
		// var RoleController = require( "role_controller" );
		var role_vo = RoleController.getInstance().getRoleVo();
		var limit_lv_cfg = game.configs.resonate_data.data_const[ "open_lev" ];
		if( limit_lv_cfg && role_vo && limit_lv_cfg.val <= role_vo.lev ) {
			return true
		}
		if( !not_tips && limit_lv_cfg ) {
			message( limit_lv_cfg.desc )
		}
		return false
	},

	createStar( num2, star_con, setting, star_width ) {
		let num = num2 || 0
		let star_setting = setting || {}
		if( star_setting.star_list == null ) {
			star_setting.star_list = {}
		}

		if( star_setting.star_list2 == null ) {
			star_setting.star_list2 = {}
		}

		for( let i in star_setting.star_list ) {
			let v = star_setting.star_list[ i ];
			v.node.active = false
		}
		for( let i in star_setting.star_list2 ) {
			let v = star_setting.star_list2[ i ];
			v.node.active = false
		}
		if( star_setting.star10 ) {
			star_setting.star10.node.active = false;
		}

		let _cStar = ( star_count, res, star_list ) => {
			let width = star_width || ( 29 + 3 )
			let x = -star_count * width * 0.5 + width * 0.5
			for( let i = 0; i < star_count; i++ ) {
				if( !star_list[ i ] ) {
					let star = Utils.createImage( star_con, res, 0, 0, cc.v2( 0.5, 0.5 ), false, 0, false )
					star.node.scale = 1;
					star_list[ i ] = star
				}
				star_list[ i ].node.active = true
				star_list[ i ].node.x = ( x + ( i - 1 ) * width )
			}
		}

		if( num > 0 && num <= 5 ) {
			let res = PathTool.getIconPath( "common", "ico_star_3" )
			_cStar( num, res, star_setting.star_list )
		} else if( num >= 6 && num <= 9 ) {
			let res = PathTool.getIconPath( "common", "ico_star_2" )
			let count = num - 5
			_cStar( count, res, star_setting.star_list2 )
		} else if( num >= 10 ) {
			let new_num = num - 10
			let res = PathTool.getIconPath( "common", "ico_star_1" )
			if( star_setting.star10 == null ) {
				let star = Utils.createImage( star_con, res, 0, 0, cc.v2( 0.5, 0.5 ), false, 0, false )
				star.node.scale = 1.2;
				star_setting.star10 = star
			} else {
				star_setting.star10.node.active = true;
			}

			if( new_num > 0 ) {
				if( star_setting.star_label == null ) {
					let size = star_setting.star10.node.getContentSize()
					star_setting.star_label = Utils.createLabel( 12, game.configs.color_data.data_color16[ 1 ], game.configs.color_data.data_color16[ 9 ], size.width * 0.5 - 2, size.height * 0.5, "10", star_setting.star10.node, 1, cc.v2( 0.5, 0.5 ) )
				} else {
					star_setting.star_label.node.active = true;
				}
				star_setting.star_label.string = new_num;
			} else {
				if( star_setting.star_label ) {
					star_setting.star_label.node.active = false;
				}
			}
		}
		return star_setting
	},

	//获取所有英雄的神装信息
	sendAllHeroHolyEquipInfo() {
		if( this.hero_list ) {
			let list = []
			for( let k in this.hero_list ) {
				let v = this.hero_list[ k ];
				if( !v.ishaveHolyEquipmentData() ) {
					list.push( {
						partner_id: v.id
					} );
				}
			}
			if( list.length > 0 ) {
				//所有英雄的神装信息
				HeroController.getInstance().sender11092( list )
			}
		}
	},

	//是否神装开启
	//@is_show_tips 是否显示提示 --暂时没用
	isOpenHolyEquipMentByHerovo( hero_vo, is_show_tips ) {
		if( !hero_vo ) return false;

		//神装开启所需英雄星级
		let config = game.configs.partner_holy_eqm_data.data_const.open_star_condition
		let star = hero_vo.star || 1
		if( config && hero_vo.star < config.val ) {
			return false
		}

		// var RoleController = require( "role_controller" );
		let role_vo = RoleController.getInstance().getRoleVo()
		let lev = 0
		if( role_vo ) {
			lev = role_vo.lev || 0
		}

		//策划要求两个情况 : 1世界等级110且个人等级105开启 2个人等级120开启
		// 个人等级限制 --先判断2
		let role_second_lv_cfg = game.configs.partner_holy_eqm_data.data_const.open_lev_second_condition
		if( role_second_lv_cfg && lev < role_second_lv_cfg.val ) {
			//不满足2 再判断1
			// 个人等级条件
			let role_lv_cfg = game.configs.partner_holy_eqm_data.data_const.open_lev_condition
			if( lev < role_lv_cfg.val ) {
				return false
			}
			// 世界等级限制
			let world_lv_cfg = game.configs.partner_holy_eqm_data.data_const.open_worldlev_condition
			let world_lev = RoleController.getInstance().getModel().getWorldLev()
			if( world_lev && world_lv_cfg && world_lev < world_lv_cfg.val ) {
				return false
			}
		}

		return true
	},

	getHeroHolyEquipList( id ) {
		if( this.hero_list[ id ] ) {
			return this.hero_list[ id ].holy_eqm_list || []
		}
		return {}
	},

	updateHolyEquipmentInfo( data ) {
		let self = this;
		let id = data.partner_id || 0
		if( self.hero_list[ id ] ) {
			let hero_vo = self.hero_list[ id ]
			//先清空神装记录
			if( hero_vo.holy_eqm_list ) {
				for( let i in hero_vo.holy_eqm_list ) {
					let equip_vo = hero_vo.holy_eqm_list[ i ];
					self.hero_holy_list[ equip_vo.id ] = null
					self.dic_itemid_to_partner_id[ equip_vo.id ] = null
				}
			}
			this.updateHeroVo( data )
			//在重新记录新的记录
			if( hero_vo.holy_eqm_list ) {
				for( let i in hero_vo.holy_eqm_list ) {
					let equip_vo = hero_vo.holy_eqm_list[ i ];
					for( const k in data.holy_eqm ) {
						const element = data.holy_eqm[ k ];
						if( equip_vo.type == element.type ) {
							self.hero_holy_list[ equip_vo.id ] = equip_vo
							self.dic_itemid_to_partner_id[ equip_vo.id ] = hero_vo.partner_id
							break
						}
					}
				}
			}
			gcore.GlobalEvent.fire( HeroEvent.Holy_Equipment_Update_Event, hero_vo )
		}
	},

	//更新神装信息
	updateHeroVoHolyEquipment( data_list, is_not_check ) {
		let self = this;
		let is_team = false
		for( let i in data_list ) {
			let v = data_list[ i ];
			if( self.hero_list[ v.partner_id ] ) {
				self.hero_list[ v.partner_id ].updateHolyEqmList( v.holy_eqm )
				if( !is_team ) {
					if( self.hero_list[ v.partner_id ].isFormDrama() ) {
						is_team = true
					}
				}
			}
		}
		self.hero_holy_list = {}
		for( let k in self.hero_list ) {
			let v = this.hero_list[ k ];
			if( v.holy_eqm_list ) {
				for( let i in v.holy_eqm_list ) {
					let equip_vo = v.holy_eqm_list[ i ];
					self.hero_holy_list[ equip_vo.id ] = equip_vo
					self.dic_itemid_to_partner_id[ equip_vo.id ] = v.partner_id
				}
			}
		}

		// -- 检查红点是要的暂时不考虑.留著
		// -- if is_team && not is_not_check then
		// --     --如果有剧情阵容的英雄..需要检查红点
		// --     --检测红点
		// --     HeroCalculate.checkAllHeroRedPoint()    
		// -- end
	},

	updateHolyEquipmentPlan( data, _false ) {
		let self = this;
		if( data.num && _false == true ) {
			// console.log( JSON.stringify( this.holy_equip_plans ) + "当前的神装" );

			this.holy_equip_plans.num = data.num;
		}
		if( data.holy_eqm_set_cell ) {
			this.holy_equip_plans.holy_eqm_set_cell = data.holy_eqm_set_cell;
		}

		if( data.num ) { //格子上限
			self.holy_equip_plan_count = data.num
		}
		if( !self.holy_equip_plan ) {
			self.holy_equip_plan = {}
		}
		if( data.holy_eqm_set_cell ) {
			for( let i in data.holy_eqm_set_cell ) {
				let cell = data.holy_eqm_set_cell[ i ];
				if( self.holy_equip_plan[ cell.id ] ) {
					for( let k in cell ) {
						let v = cell[ k ];
						self.holy_equip_plan[ cell.id ][ k ] = v
					}
				} else {
					self.holy_equip_plan[ cell.id ] = cell
				}
			}
		}
	},

	getHolyEquipmentPlanDatad() {

		if( this.holy_equip_plans && this.holy_equip_plans.holy_eqm_set_cell ) {
			this.holy_equip_plans.holy_eqm_set_cell.sort( Utils.tableLowerSorter( [ "id" ] ) );
		}


		return this.holy_equip_plans;
	},

	getHolyPlanCount: function() {
		return this.holy_equip_plan_count;
	},

	getHolyEquipmentPlanData() {
		return this.holy_equip_plan
	},

	// --重生次数
	setResetCount( data ) {
		if( !data ) return
		this.reset_count = data.day_num
		let hero_vo = this.getHeroById( data.partner_id )
		if( hero_vo ) {
			hero_vo.initResetTime( data.end_time )
		}
	},

	//获取神装套装描述
	//@equip_vo_list 装备列表 结构{goods_vo,goods_vo,...}  
	//return 描述list
	// 返回结构 {}
	getHolyEquipSuitDes: function( equip_vo_list ) {
		if( !equip_vo_list ) {
			return {}
		}
		let dic_suit_set = []
		let dic_eqm_set_list = []
		for( const k in equip_vo_list ) { //遍历当前装备列表
			const euip_vo = equip_vo_list[ k ];
			if( euip_vo.config ) {
				let eqm_key = Math.floor( euip_vo.config.eqm_set / 100 ) //判断当前是那一套套装
				if( dic_suit_set[ eqm_key ] == null ) {
					dic_eqm_set_list[ eqm_key ] = []
					dic_suit_set[ eqm_key ] = 1
					dic_eqm_set_list[ eqm_key ].push( euip_vo.config.eqm_set )
				} else {
					dic_suit_set[ eqm_key ] = dic_suit_set[ eqm_key ] + 1 //列表中有几件装备
					dic_eqm_set_list[ eqm_key ].push( euip_vo.config.eqm_set )
				}
			}
		}
		let suit_config = []
		for( const eqm_key in dic_suit_set ) {
			const count = dic_suit_set[ eqm_key ];
			let eqm_set_list = dic_eqm_set_list[ eqm_key ]
			if( count > 1 ) { //2件以上说明有套装
				eqm_set_list.sort( function( a, b ) { //按照星级排序
					return b - a;
				} );

				let cur_eqm_set = null
				let cur_config = null
				for( const i in eqm_set_list ) {
					const eqm_set = eqm_set_list[ i ];
					let num = Number( i ) + 1
					if( cur_eqm_set == null ) {
						cur_eqm_set = eqm_set;
						cur_config = game.configs.partner_holy_eqm_data.data_suit_info[ eqm_set ]
						cur_config.sort( function( a, b ) {
							return a.num < b.num
						} );
					} else {
						if( cur_eqm_set != eqm_set ) {
							cur_config = game.configs.partner_holy_eqm_data.data_suit_info[ eqm_set ]
							cur_config.sort( function( a, b ) {
								return a.num < b.num
							} );
						}
						for( const _ in cur_config ) {
							const suit_info = cur_config[ _ ];
							if( suit_info.num == num ) {
								suit_config.push( suit_info )
								break
							}
						}
					}
				}
			}
		}
		let list = []
		for( const i in suit_config ) {
			const v = suit_config[ i ];
			//说明是激活的
			let eqm_set = v.id

			let id = Math.floor( eqm_set / 100 )
			let config = game.configs.partner_holy_eqm_data.data_suit_res_prefix[ id ]
			if( config ) {
				let data = {}
				data.num = v.num
				data.icon_res = config.prefix // PathTool.getSuitRes(config.prefix)
				data.name = cc.js.formatStr( "%s(%s)", v.name, v.num )
				data.id = eqm_set
				list.push( data )
			}
		}
		list.sort( Utils.tableLowerSorter( [ "id", "num" ] ) )
		return list
	},

	//檢查道具是否在神裝管理裡面
	//@item_id 物品唯一id
	checkHolyEquipmentPalnByItemID( item_id ) {
		if( !item_id ) {
			return false
		}
		if( !this.holy_equip_plan ) {
			return false
		}
		for( const i in this.holy_equip_plan ) {
			const cell = this.holy_equip_plan[ i ];
			for( const j in cell.list ) {
				const v = cell.list[ j ];
				if( item_id == v.item_id ) {
					return {
						bool: true,
						cell: cell
					}
				}
			}
		}
		return {
			bool: false
		}
	},

	//獲取所有英雄穿戴的裝備信息
	//@ return 
	getAllHeroHolyEquipList() {
		return this.hero_holy_list || {}
	},

	getHolyEquipById( id ) {
		if( this.hero_holy_list ) {
			return this.hero_holy_list[ id ]
		}
	},


	getHolyPreviewInfo: function( _index ) {

		let ct = parseInt( _index ) * 100 + 5;
		let lst = [];
		let cfgs = game.configs.item_data.data_holy_eqm_list;
		for( let i in cfgs ) {
			if( ct >= i && i >= ( ct - 4 ) ) {
				let cfg = cfgs[ i ];
				for( let j in cfg ) {

					lst.push( cfg[ j ] );
				}
			}

		}
		lst.sort( ( a, b ) => {
			return b.id - a.id;
		} );
		return lst;
	},


	getResetCount() {
		return this.reset_count
	},

	//獲取品質
	//@item_id 道具id
	//@ attr_key  屬性名字 
	//@ value 屬性值
	getHolyEquipmentQualityByItemIdAttrKey: function( item_id, attr_key, value ) {
		let quality = 0
		let holy_equip_config = game.configs.partner_holy_eqm_data.data_base_info[ ( item_id ) ]
		if( holy_equip_config ) {
			let key = Utils.getNorKey( holy_equip_config[ 2 ], attr_key )
			let config = game.configs.partner_holy_eqm_data.data_attr_color_rule[ ( key ) ]
			if( value > 0 && config && config.color_list[ 0 ] ) {
				let list = config.color_list[ 0 ] // {0-12}
				for( let i = 0; i < list.length; i++ ) {
					if( list[ i + 1 ] ) {
						if( value >= list[ i ] && value < list[ i + 1 ] ) {
							quality = i
						}
					} else {
						if( value >= list[ i ] ) {
							quality = i
						}
					}
				}
			}
		}
		return quality
	},

	//獲取某個屬性最大值
	getHolyEquipmentMaxAttrByItemIdAttrKey( item_id, attr_key ) {
		let max_count = 1
		let holy_equip_config = game.configs.partner_holy_eqm_data.data_base_info[ ( item_id ) ]
		if( holy_equip_config ) {
			let config = game.configs.partner_holy_eqm_data.data_attr_max_info[ holy_equip_config[ 3 ] ]
			if( config ) {
				for( let i = 0; i < config.max_attr.length; i++ ) {
					const v = config.max_attr[ i ];
					if( v[ 0 ] && v[ 0 ] == attr_key ) {
						max_count = v[ 1 ] || 1
						break
					}
				}
			}
		}

		return max_count
	},

	// --是否是公會pvp 陣法類型 
	isGuildPvpFrom( form_type ) {
		let self = this;
		if( self.dic_guild_from_type == null ) {
			self.dic_guild_from_type = {}
			let config_list = game.configs.combat_type_data.data_fight_list;
			if( config_list ) {
				for( let k in config_list ) {
					let config = config_list[ k ];
					if( config.is_guild_pvp == 1 ) {
						if( config.from != null ) {
							for( let i in config.from[ 0 ] ) {
								let form = config.from[ 0 ][ i ];
								self.dic_guild_from_type[ form ] = true;
							}
						}
					}
				}
			}
		}
		return self.dic_guild_from_type[ form_type ]
	},
} );