2620 lines
73 KiB
JavaScript
2620 lines
73 KiB
JavaScript
// --------------------------------------------------------------------
|
|
// @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 ]
|
|
},
|
|
} ); |