2367 lines
80 KiB
JavaScript
2367 lines
80 KiB
JavaScript
"use strict";
|
|
cc._RF.push(module, 'cab3eqqKGZLUJgBvXKUXy/7', 'hero_model');
|
|
// Scripts/mod/partner/hero_model.js
|
|
|
|
"use strict";
|
|
|
|
// --------------------------------------------------------------------
|
|
// @author: xxx@syg.com(必填, 创建模块的人员)
|
|
// @description:
|
|
// 这里填写详细说明,主要填写该模块的功能简要
|
|
// <br/>Create: {DATE}
|
|
// --------------------------------------------------------------------
|
|
var 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");
|
|
var RoleController = require("role_controller");
|
|
var FID = require("bridge.function.ids");
|
|
|
|
// const { util } = require("config");
|
|
// const { config } = require("process");
|
|
var HeroModel = cc.Class({
|
|
"extends": BridgeClass,
|
|
ctor: function ctor() {
|
|
this.ctrl = arguments[0];
|
|
},
|
|
properties: {},
|
|
initConfig: function initConfig() {
|
|
// 伙伴数据列表 (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 setHeroMaxCount(max_count) {
|
|
if (typeof max_count == "number") {
|
|
this.hero_max_count = max_count;
|
|
}
|
|
},
|
|
//--批量请求英雄的属性 装备等数据 11026
|
|
batchSendHeroInfo: function batchSendHeroInfo() {
|
|
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 getHeroMaxCount() {
|
|
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 setHeroBuyNum(buy_num) {
|
|
this.buy_num = Number(buy_num);
|
|
},
|
|
getHeroBuyNum: function getHeroBuyNum() {
|
|
return this.buy_num || 0;
|
|
},
|
|
// --根据bid 和star 获取对应的英雄信息
|
|
// --@return 英雄信息列表
|
|
getHeroInfoByBidStar: function getHeroInfoByBidStar(bid, star) {
|
|
if (!bid || !star) return;
|
|
var list = this.hero_bid_list[bid];
|
|
if (list) {
|
|
list.forEach(function (_item) {
|
|
if (_item.face_id == 0) {
|
|
_item.face_id = "null";
|
|
}
|
|
});
|
|
var return_list = [];
|
|
for (var i in list) {
|
|
var 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 updateHeroList(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);
|
|
var lists = this.getHeroReformListByCamp(0);
|
|
var count = 0;
|
|
lists.forEach(function (_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 updateHeroVo(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;
|
|
var 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);
|
|
var 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 updateSingle(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;
|
|
var 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);
|
|
var 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: function getHeroNumByBid(bid) {
|
|
if (!bid) {
|
|
return 0;
|
|
}
|
|
;
|
|
var list = this.hero_bid_list[bid] || {};
|
|
return list.length;
|
|
},
|
|
// 获取单个伙伴数据,id
|
|
// @id 是英雄唯一标识id
|
|
getHeroById: function getHeroById(partner_id) {
|
|
if (!this.hero_list) return;
|
|
if (!partner_id || typeof partner_id != "number") return;
|
|
return this.hero_list[partner_id] || {};
|
|
},
|
|
// 删除英雄
|
|
delHeroDataList: function delHeroDataList(list) {
|
|
if (!list) return;
|
|
var delParts = [];
|
|
// cc.log( "delHeroDataList" )
|
|
for (var hero_i in list) {
|
|
var v = list[hero_i];
|
|
var 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英雄列表删除该英雄记录
|
|
var bidlist = this.hero_bid_list[temp_bid];
|
|
if (bidlist) {
|
|
for (var i = 0; i < bidlist.length; ++i) {
|
|
var 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: function updateHeroVoTalent(data_list, is_not_check) {
|
|
var is_team = false;
|
|
var self = this;
|
|
for (var i = 0; i < data_list.length; ++i) {
|
|
var 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 getHeroList() {
|
|
return this.hero_list || {};
|
|
},
|
|
getAllHeroArray: function getAllHeroArray() {
|
|
this.hero_array.forEach(function (_item) {
|
|
if (_item.face_id == 0) {
|
|
_item.face_id = "null";
|
|
}
|
|
});
|
|
return this.hero_array;
|
|
},
|
|
// 根据阵容获取英雄列表
|
|
getHeroListByCamp: function getHeroListByCamp(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 getHeroListByStar(_star) {
|
|
var hero_list = [];
|
|
for (var 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 getHeroListByBid(_bid) {
|
|
var hero_list = [];
|
|
for (var 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 getHeroReformListByCamp(camp) {
|
|
var camp_type = camp || 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.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 getDeepHeroListByCamp(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 getRestHeroListByCamp(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(function (_item) {
|
|
if (_item.face_id == 0) {
|
|
_item.face_id = "null";
|
|
}
|
|
});
|
|
var hero_sort = function hero_sort(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 setHadHeroInfo(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;
|
|
}
|
|
var sfg = game.configs.source_data.data_source_data[FID.Equips];
|
|
var 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 dealPartnerSplinterRed() {
|
|
var can_merge = BackpackController.getInstance().getModel().getHeroChipRedPoint();
|
|
nx.mTip.openTip("bag.partnermerge", can_merge);
|
|
},
|
|
// 處理 改造 義肢合成--- 芯片合成紅點
|
|
dealReformEqm: function dealReformEqm() {
|
|
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);
|
|
var cfg = game.configs.partner_eqm_data.data_eqm_compose_id;
|
|
var artifacts = BackpackController.getInstance().getModel().getAllBackPackArray(BackPackConst.item_sub_type.SPECIAL);
|
|
var eqms = BackpackController.getInstance().getModel().getBagItemList(BackPackConst.Bag_Code.EQUIPS);
|
|
var count = 0;
|
|
var type = [];
|
|
var have = BackpackController.getInstance().getModel().getItemNumByBid(1);
|
|
;
|
|
for (var i in cfg) {
|
|
var eqm = cfg[i];
|
|
var need = eqm.expend[0][0];
|
|
for (var e in eqms) {
|
|
var 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 (var _i = 0; _i < type.length; _i++) {
|
|
var 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);
|
|
var acfg = game.configs.partner_artifact_data.data_artifact_data;
|
|
var samef = [];
|
|
var target_lev = 0;
|
|
for (var arttt in acfg) {
|
|
var artcfg = nx.dt.objClone(acfg[arttt]);
|
|
artcfg.quantity = 0;
|
|
artcfg.needCoins = 0;
|
|
artcfg.targetid = 0;
|
|
artcfg.target_lev = 0;
|
|
for (var art = 0; art < artifacts.length; art++) {
|
|
var 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);
|
|
}
|
|
var arthave = 0;
|
|
var lev = 0;
|
|
var needCoins = 0;
|
|
samef.forEach(function (_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 getHeroPokedexList(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 sort_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 getHeroPokedexByBid(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 getHeroMaxBreakCountByInitStar(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 getRandomHeroHeadByQuality(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 getSourceHeroCombinationByCampStar(camp, star) {
|
|
if (!this.dic_source_item_ids) {
|
|
this.dic_source_item_ids = [];
|
|
var 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]) {
|
|
var _star2 = _star2 || 0;
|
|
if (_star2 == 0) {
|
|
_star2 = 3; //--最低星就三
|
|
}
|
|
|
|
return this.dic_source_item_ids[camp][_star2];
|
|
}
|
|
},
|
|
getHadHeroInfo: function getHadHeroInfo() {
|
|
return this.dic_had_hero_info || {};
|
|
},
|
|
getHadHeroStarBybid: function getHadHeroStarBybid(bid) {
|
|
if (this.dic_had_hero_info && this.dic_had_hero_info[bid]) {
|
|
return this.dic_had_hero_info[bid];
|
|
}
|
|
return null;
|
|
},
|
|
isOpenTanlentByHerovo: function isOpenTanlentByHerovo(hero_vo) {
|
|
var 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 setFormList(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();
|
|
var list = [];
|
|
if (order) {
|
|
for (var k in this.pos_list[form_type][order]) {
|
|
var v = this.pos_list[form_type][order][k];
|
|
list.push({
|
|
partner_id: v.id
|
|
});
|
|
}
|
|
} else {
|
|
for (var _k in this.pos_list[form_type]) {
|
|
var _v = this.pos_list[form_type][_k];
|
|
list.push({
|
|
partner_id: _v.id
|
|
});
|
|
}
|
|
}
|
|
// --请求天赋的
|
|
HeroController.getInstance().sender11099(list);
|
|
}
|
|
},
|
|
// 获取最高战力的英雄战力
|
|
getMaxFight: function getMaxFight() {
|
|
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: function getTopLevHeroInfoByBid(bid) {
|
|
if (!bid) return;
|
|
var list = this.hero_bid_list[bid];
|
|
if (list) {
|
|
list.sort(Utils.tableUpperSorter(["lev", "power"]));
|
|
return list[0];
|
|
}
|
|
return null;
|
|
},
|
|
//雇佣的
|
|
getExpeditHeroData: function getExpeditHeroData() {
|
|
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: function getTeamOrderPosList(type) {
|
|
return this.pos_list[type];
|
|
},
|
|
// 获取自己的队伍阵法站位
|
|
getMyPosList: function getMyPosList() {
|
|
return this.pos_list[PartnerConst.Fun_Form.Drama] || {};
|
|
},
|
|
getHeroSortFunc: function getHeroSortFunc() {
|
|
var hero_sort = function hero_sort(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 isMaxStarHero(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 getStarFuseList(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: function getMockHeroVoByBid(bid) {
|
|
var base_config = game.configs.partner_data.data_partner_base[bid];
|
|
var attr_config = game.configs.partner_data.data_partner_attr[bid];
|
|
if (!base_config || !attr_config) {
|
|
return;
|
|
}
|
|
var hero_vo = nx.dt.objClone(base_config);
|
|
hero_vo.star = base_config.init_star; //--默认星数
|
|
hero_vo.break_lev = 0; //--默认进阶
|
|
for (var k in attr_config) {
|
|
// k,v in pairs(attr_config) do
|
|
var 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 updateHeroEquipList(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 getHeroEquipList(parener_id) {
|
|
if (this.hero_list[parener_id]) {
|
|
return this.hero_list[parener_id].eqm_list;
|
|
}
|
|
},
|
|
//----------------------------符文锻造相关------------------------
|
|
|
|
//获取符文祝福红点状态
|
|
getArtifactLuckyRedStatus: function getArtifactLuckyRedStatus() {
|
|
return this.artifact_lucky_red;
|
|
},
|
|
//符文祝福值
|
|
setArtifactLucky: function setArtifactLucky(value) {
|
|
this.artifact_lucky = value;
|
|
this.updateArtifactLuckyRed();
|
|
// RedMgr.getInstance().addCalHandler( this.updateArtifactLuckyRed.bind( this ) )
|
|
},
|
|
|
|
getArtifactLucky: function getArtifactLucky() {
|
|
return this.artifact_lucky || 0;
|
|
},
|
|
//祝福值红点
|
|
updateArtifactLuckyRed: function updateArtifactLuckyRed() {
|
|
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 updatePartnerArtifactList(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 getPartnerArtifactList(id) {
|
|
if (this.hero_list[id]) {
|
|
return this.hero_list[id].artifact_list || [];
|
|
}
|
|
return [];
|
|
},
|
|
// -- 符文重鑄次數相關數據
|
|
updateArtifactRecastCount: function updateArtifactRecastCount(data_list) {
|
|
this.artifact_recast_data = data_list;
|
|
},
|
|
// -- 根據符文品質獲取對應品質的重鑄次數
|
|
getArtifactRecastCountByQuality: function getArtifactRecastCountByQuality(quality) {
|
|
var count = 0;
|
|
var max_count = 0;
|
|
var _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 (var k in this.artifact_recast_data) {
|
|
var 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 setLockByPartnerid(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 getHeroListByMatchInfo(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 _setDicCount(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 checkLevelRedPointUpdate() {
|
|
// 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 checkUnlockFormRedPoint() {},
|
|
// 设置更新equip红点的记录
|
|
setEquipUpdateRecord: function setEquipUpdateRecord(bool) {
|
|
this.is_equip_redpoint_bag_update = bool;
|
|
this.is_equip_redpoint_hero_update = bool;
|
|
},
|
|
// 检查装备红点
|
|
checkEquipRedPointUpdate: function checkEquipRedPointUpdate() {
|
|
// 需要 背包 返回 和 英雄更新返回 才处理红点计算
|
|
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 setUpgradeStarUpdateRecord(bool) {
|
|
this.is_upgradestar_redpoint_bag_update = bool;
|
|
this.is_upgradestar_redpoint_hero_update = bool;
|
|
},
|
|
// 升星红点检查
|
|
checkUpgradeStarRedPointUpdate: function checkUpgradeStarRedPointUpdate() {
|
|
// 需要 背包 返回 和 英雄更新返回 才处理红点计算
|
|
if (this.is_upgradestar_redpoint_bag_update && this.is_upgradestar_redpoint_hero_update) {
|
|
HeroCalculate.getInstance().clearAllHeroRecordByRedPointType(HeroConst.RedPointType.eRPStar);
|
|
}
|
|
},
|
|
// 检查圣器解锁
|
|
checkUnlockHallowsRedPoint: function checkUnlockHallowsRedPoint() {},
|
|
checkHighStarCondition: function checkHighStarCondition(_star) {
|
|
var can = [];
|
|
var star = _star + 1;
|
|
// let role_vo = RoleController.getInstance();
|
|
var 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 dealStar11(_cfg) {
|
|
this.desc = [];
|
|
var role_vo = RoleController.getInstance();
|
|
var levEnough = false;
|
|
var slevEnough = true;
|
|
var worldlevEnough = true;
|
|
var results = [];
|
|
var conds = [];
|
|
for (var i = 0; i < _cfg.cond1.length; i++) {
|
|
var 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") {
|
|
var 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 dealStar13(_cfg) {
|
|
this.desc = [];
|
|
var role_vo = RoleController.getInstance();
|
|
var levEnough = false;
|
|
var slevEnough = true;
|
|
var worldlevEnough = true;
|
|
var results = [];
|
|
var conds = [];
|
|
var cond2s = [];
|
|
var cond3s = [];
|
|
for (var i = 0; i < _cfg.cond1.length; i++) {
|
|
var 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") {
|
|
var 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 (var t = 0; t < _cfg.cond3.length; t++) {
|
|
var _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") {
|
|
var _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 getDescs() {
|
|
return this.desc;
|
|
},
|
|
checkOpenStar11: function checkOpenStar11() {
|
|
this.desc = [];
|
|
var is_open = true;
|
|
var all = [];
|
|
var role_vo = RoleController.getInstance().getRoleVo();
|
|
// var RoleController = require( "role_controller" );
|
|
var config = game.configs.partner_data.data_partner_const.staropen11_world_lev;
|
|
if (config) {
|
|
if (config.val[0] == "world_lev") {
|
|
var 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 ) {
|
|
var 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]);
|
|
}
|
|
// }
|
|
|
|
// --策劃加的額外條件
|
|
var config2 = game.configs.partner_data.data_partner_const.staropen11_3rd_open_limit;
|
|
var conditions = config2.val;
|
|
var enough = false;
|
|
for (var c = 0; c < conditions.length; c++) {
|
|
var 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") {
|
|
var 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 checkOpenStar12() {
|
|
var is_open = true;
|
|
// var RoleController = require( "role_controller" );
|
|
var config = game.configs.partner_data.data_partner_const.staropen12_world_lev;
|
|
if (config) {
|
|
if (config.val[0] == "world_lev") {
|
|
var world_lev = RoleController.getInstance().getModel().getWorldLev() || 0;
|
|
if (world_lev < config.val[1]) {
|
|
is_open = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// --要麼滿足 個人等級條件
|
|
if (!is_open) {
|
|
is_open = true;
|
|
var config_lev = game.configs.partner_data.data_partner_const.staropen12_player_lev;
|
|
if (config_lev && config_lev.val[0] == "lev") {
|
|
var role_vo = RoleController.getInstance().getRoleVo();
|
|
if (role_vo && role_vo.lev < config_lev.val[1]) {
|
|
is_open = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// --策劃加的額外條件
|
|
var config2 = game.configs.partner_data.data_partner_const.staropen12_3rd_open_limit;
|
|
var is_condition_3 = this.checkExtOpenInfo(config2);
|
|
if (!is_open) {
|
|
is_open = is_condition_3 || false;
|
|
}
|
|
return is_open;
|
|
},
|
|
checkOpenStar13: function checkOpenStar13() {
|
|
var self = this;
|
|
if (self.is_star13_open) {
|
|
//如果已經計算開啟過了.就不計算了
|
|
return true;
|
|
}
|
|
// --優先判斷 等級 第一條件不滿足再判斷第二條件
|
|
var config = game.configs.partner_data.data_partner_const.staropen13_limit_lev2;
|
|
var is_open = true;
|
|
if (config) {
|
|
if (self.checkOpenByKeyValue(config.val[0], config.val[1])) {
|
|
is_open = false;
|
|
}
|
|
}
|
|
// --如果上面不滿足 再判斷第二個條件
|
|
if (!is_open) {
|
|
is_open = true;
|
|
var _config = game.configs.partner_data.data_partner_const.staropen13_limit_lev1;
|
|
if (_config) {
|
|
for (var i in _config.val) {
|
|
var v = _config.val[i];
|
|
if (self.checkOpenByKeyValue(v[0], v[1])) {
|
|
is_open = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// --條件1 個人和世界等級達到170級 或 個人等級到達180級 開啟升星
|
|
var is_condition_1 = is_open;
|
|
// --條件2 擁有2個12星英雄開啟升星
|
|
var is_condition_2 = false;
|
|
// --條件3 個人等級達到150，且擁有5個及以上的12星，13星
|
|
var is_condition_3 = false;
|
|
|
|
// --第二個硬性條件
|
|
// --13星特殊要 曾經有2個12星英雄
|
|
var config2 = game.configs.partner_data.data_partner_const.staropen13_limit_partner;
|
|
if (config2 && config2.val) {
|
|
var count = 0;
|
|
for (var k in self.dic_had_hero_info) {
|
|
var 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;
|
|
|
|
// --策劃加的額外條件
|
|
var 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: function checkExtOpenInfo(config) {
|
|
// -- 策劃要求:原來的條件沒變。只是新增一個或條件，
|
|
// -- 個人等級達到100/120/150，且擁有5個及以上的10/11/12星，開啟11/12/13星
|
|
var 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" --這個前端不需要..因為需要寫死的
|
|
var star = val[1][1] || 10;
|
|
var count = val[1][2] || 5;
|
|
if (this.dic_star_count[star] == null) {
|
|
this.dic_star_count[star] = 0;
|
|
for (var k in this.dic_had_hero_info) {
|
|
var _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: function checkOpenByKeyValue(key, value) {
|
|
if (!value) return false;
|
|
// var RoleController = require( "role_controller" );
|
|
if (key == "world_lev") {
|
|
var world_lev = RoleController.getInstance().getModel().getWorldLev() || 0;
|
|
return world_lev < value;
|
|
} else if (key == "lev") {
|
|
var role_vo = RoleController.getInstance().getRoleVo();
|
|
if (role_vo && role_vo.lev < value) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
//---------------------天赋技能---------------------------
|
|
// --设置更新天赋红点
|
|
setUpdateTalentRedpoint: function setUpdateTalentRedpoint() {
|
|
this.is_need_update_talent_redpoint = true;
|
|
},
|
|
getTalentRedpointRecord: function getTalentRedpointRecord() {
|
|
var self = this;
|
|
if (self.is_need_update_talent_redpoint) {
|
|
var dic_config = game.configs.partner_skill_data.data_partner_skill_learn;
|
|
if (dic_config) {
|
|
var is_enough;
|
|
for (var k in dic_config) {
|
|
var config = dic_config[k];
|
|
self.dic_hero_talent_skill_learn_redpoint[config.id] = null;
|
|
is_enough = true;
|
|
for (var i = 0; i < config.expend.length; ++i) {
|
|
var v = config.expend[i];
|
|
var 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: function 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: function updateHeroVoDetailedInfo(info) {
|
|
if (!info) return;
|
|
if (this.hero_list[info.partner_id]) {
|
|
cc.log(this.hero_list[info.partner_id], info);
|
|
for (var k in info) {
|
|
var 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 initHeroSkin(data) {
|
|
var lists = this.getHeroReformListByCamp(0);
|
|
var count = 0;
|
|
lists.forEach(function (_item) {
|
|
if (_item.result.is_redpoint) {
|
|
count++;
|
|
}
|
|
});
|
|
nx.mTip.openTip("tipReform.show", count > 0);
|
|
if (!data) return;
|
|
//判定是否要显示卡片展示界面
|
|
if (this.hero_skin_list) {
|
|
var show_skin_id = null;
|
|
for (var i in data.partner_skins) {
|
|
var 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 (var _i2 in data.partner_skins) {
|
|
var _v2 = data.partner_skins[_i2];
|
|
this.hero_skin_list[_v2.id] = _v2.end_time;
|
|
}
|
|
gcore.GlobalEvent.fire(HeroEvent.Hero_Skin_Info_Event, data);
|
|
},
|
|
//根据皮肤id 返回皮肤数据
|
|
//@return 皮肤有效时间点.. 如果永久返回 0 如果返回nil 表示 没有解锁该皮肤
|
|
getHeroSkinInfoBySkinID: function getHeroSkinInfoBySkinID(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 isUnlockHeroSkin(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 getCystalPreLevLimit() {
|
|
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 isResonateCystalMaxLev() {
|
|
// --340 英雄 13星升级的最大等级
|
|
if (this.resonate_cystal_lev && this.resonate_cystal_lev >= this.getCystalPreLevLimit()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
isCanShowLabelMaxLev: function isCanShowLabelMaxLev(lev) {
|
|
if (lev && lev < this.getCystalPreLevLimit()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
getDicResonateFiveHeroVo: function getDicResonateFiveHeroVo() {
|
|
return this.dic_resonate_five_hero_vo || {};
|
|
},
|
|
// --是否共鸣水晶上阵的英雄 如果 hero_vo 不确定是 hero_vo 类的 用此方法判断
|
|
isResonateCystalHero: function isResonateCystalHero(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 updateResonateCystalInfo(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 updateResonateLockInfo(data) {
|
|
this.resonate_stone_level = data.lev || 0;
|
|
this.resonate_max_partner_lev = data.max_partner_lev || 0;
|
|
// --判断是有红点
|
|
this.checkResonateRedPoint();
|
|
},
|
|
checkResonateRedPoint: function checkResonateRedPoint() {
|
|
if (!this.resonate_stone_level) {
|
|
return;
|
|
}
|
|
if (!this.resonate_max_partner_lev) {
|
|
return;
|
|
}
|
|
var resonate_stone_condition = 50;
|
|
var 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;
|
|
}
|
|
var config2 = gdata("resonate_data", "data_level_up", this.resonate_stone_level);
|
|
var 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];
|
|
var bid = v[0];
|
|
var num = v[1];
|
|
var have_num = BackpackController.getInstance().getModel().getItemNumByBid(bid);
|
|
if (num && num > have_num) {
|
|
is_redpoint = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.is_resonate_stone_redpoint = is_redpoint;
|
|
},
|
|
// 是否最高等级
|
|
isResonateMaxLevel: function isResonateMaxLevel(lev) {
|
|
if (lev) {
|
|
var config = gdata("resonate_data", "data_level_up", lev + 1);
|
|
if (config == null) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
// 共鸣是否开启
|
|
checkResonateIsOpen: function checkResonateIsOpen(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: function createStar(num2, star_con, setting, star_width) {
|
|
var num = num2 || 0;
|
|
var star_setting = setting || {};
|
|
if (star_setting.star_list == null) {
|
|
star_setting.star_list = {};
|
|
}
|
|
if (star_setting.star_list2 == null) {
|
|
star_setting.star_list2 = {};
|
|
}
|
|
for (var i in star_setting.star_list) {
|
|
var v = star_setting.star_list[i];
|
|
v.node.active = false;
|
|
}
|
|
for (var _i3 in star_setting.star_list2) {
|
|
var _v3 = star_setting.star_list2[_i3];
|
|
_v3.node.active = false;
|
|
}
|
|
if (star_setting.star10) {
|
|
star_setting.star10.node.active = false;
|
|
}
|
|
var _cStar = function _cStar(star_count, res, star_list) {
|
|
var width = star_width || 29 + 3;
|
|
var x = -star_count * width * 0.5 + width * 0.5;
|
|
for (var _i4 = 0; _i4 < star_count; _i4++) {
|
|
if (!star_list[_i4]) {
|
|
var star = Utils.createImage(star_con, res, 0, 0, cc.v2(0.5, 0.5), false, 0, false);
|
|
star.node.scale = 1;
|
|
star_list[_i4] = star;
|
|
}
|
|
star_list[_i4].node.active = true;
|
|
star_list[_i4].node.x = x + (_i4 - 1) * width;
|
|
}
|
|
};
|
|
if (num > 0 && num <= 5) {
|
|
var res = PathTool.getIconPath("common", "ico_star_3");
|
|
_cStar(num, res, star_setting.star_list);
|
|
} else if (num >= 6 && num <= 9) {
|
|
var _res = PathTool.getIconPath("common", "ico_star_2");
|
|
var count = num - 5;
|
|
_cStar(count, _res, star_setting.star_list2);
|
|
} else if (num >= 10) {
|
|
var new_num = num - 10;
|
|
var _res2 = PathTool.getIconPath("common", "ico_star_1");
|
|
if (star_setting.star10 == null) {
|
|
var star = Utils.createImage(star_con, _res2, 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) {
|
|
var 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: function sendAllHeroHolyEquipInfo() {
|
|
if (this.hero_list) {
|
|
var list = [];
|
|
for (var k in this.hero_list) {
|
|
var 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: function isOpenHolyEquipMentByHerovo(hero_vo, is_show_tips) {
|
|
if (!hero_vo) return false;
|
|
|
|
//神装开启所需英雄星级
|
|
var config = game.configs.partner_holy_eqm_data.data_const.open_star_condition;
|
|
var star = hero_vo.star || 1;
|
|
if (config && hero_vo.star < config.val) {
|
|
return false;
|
|
}
|
|
|
|
// var RoleController = require( "role_controller" );
|
|
var role_vo = RoleController.getInstance().getRoleVo();
|
|
var lev = 0;
|
|
if (role_vo) {
|
|
lev = role_vo.lev || 0;
|
|
}
|
|
|
|
//策划要求两个情况 : 1世界等级110且个人等级105开启 2个人等级120开启
|
|
// 个人等级限制 --先判断2
|
|
var 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
|
|
// 个人等级条件
|
|
var role_lv_cfg = game.configs.partner_holy_eqm_data.data_const.open_lev_condition;
|
|
if (lev < role_lv_cfg.val) {
|
|
return false;
|
|
}
|
|
// 世界等级限制
|
|
var world_lv_cfg = game.configs.partner_holy_eqm_data.data_const.open_worldlev_condition;
|
|
var world_lev = RoleController.getInstance().getModel().getWorldLev();
|
|
if (world_lev && world_lv_cfg && world_lev < world_lv_cfg.val) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
getHeroHolyEquipList: function getHeroHolyEquipList(id) {
|
|
if (this.hero_list[id]) {
|
|
return this.hero_list[id].holy_eqm_list || [];
|
|
}
|
|
return {};
|
|
},
|
|
updateHolyEquipmentInfo: function updateHolyEquipmentInfo(data) {
|
|
var self = this;
|
|
var id = data.partner_id || 0;
|
|
if (self.hero_list[id]) {
|
|
var hero_vo = self.hero_list[id];
|
|
//先清空神装记录
|
|
if (hero_vo.holy_eqm_list) {
|
|
for (var i in hero_vo.holy_eqm_list) {
|
|
var 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 (var _i5 in hero_vo.holy_eqm_list) {
|
|
var _equip_vo = hero_vo.holy_eqm_list[_i5];
|
|
for (var k in data.holy_eqm) {
|
|
var 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: function updateHeroVoHolyEquipment(data_list, is_not_check) {
|
|
var self = this;
|
|
var is_team = false;
|
|
for (var i in data_list) {
|
|
var 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 (var k in self.hero_list) {
|
|
var _v4 = this.hero_list[k];
|
|
if (_v4.holy_eqm_list) {
|
|
for (var _i6 in _v4.holy_eqm_list) {
|
|
var equip_vo = _v4.holy_eqm_list[_i6];
|
|
self.hero_holy_list[equip_vo.id] = equip_vo;
|
|
self.dic_itemid_to_partner_id[equip_vo.id] = _v4.partner_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
// -- 检查红点是要的暂时不考虑.留著
|
|
// -- if is_team && not is_not_check then
|
|
// -- --如果有剧情阵容的英雄..需要检查红点
|
|
// -- --检测红点
|
|
// -- HeroCalculate.checkAllHeroRedPoint()
|
|
// -- end
|
|
},
|
|
updateHolyEquipmentPlan: function updateHolyEquipmentPlan(data, _false) {
|
|
var 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 (var i in data.holy_eqm_set_cell) {
|
|
var cell = data.holy_eqm_set_cell[i];
|
|
if (self.holy_equip_plan[cell.id]) {
|
|
for (var k in cell) {
|
|
var v = cell[k];
|
|
self.holy_equip_plan[cell.id][k] = v;
|
|
}
|
|
} else {
|
|
self.holy_equip_plan[cell.id] = cell;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getHolyEquipmentPlanDatad: function 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 getHolyPlanCount() {
|
|
return this.holy_equip_plan_count;
|
|
},
|
|
getHolyEquipmentPlanData: function getHolyEquipmentPlanData() {
|
|
return this.holy_equip_plan;
|
|
},
|
|
// --重生次数
|
|
setResetCount: function setResetCount(data) {
|
|
if (!data) return;
|
|
this.reset_count = data.day_num;
|
|
var 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 getHolyEquipSuitDes(equip_vo_list) {
|
|
if (!equip_vo_list) {
|
|
return {};
|
|
}
|
|
var dic_suit_set = [];
|
|
var dic_eqm_set_list = [];
|
|
for (var k in equip_vo_list) {
|
|
//遍历当前装备列表
|
|
var euip_vo = equip_vo_list[k];
|
|
if (euip_vo.config) {
|
|
var 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);
|
|
}
|
|
}
|
|
}
|
|
var suit_config = [];
|
|
for (var _eqm_key in dic_suit_set) {
|
|
var count = dic_suit_set[_eqm_key];
|
|
var eqm_set_list = dic_eqm_set_list[_eqm_key];
|
|
if (count > 1) {
|
|
//2件以上说明有套装
|
|
eqm_set_list.sort(function (a, b) {
|
|
//按照星级排序
|
|
return b - a;
|
|
});
|
|
var cur_eqm_set = null;
|
|
var cur_config = null;
|
|
for (var i in eqm_set_list) {
|
|
var eqm_set = eqm_set_list[i];
|
|
var 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 (var _ in cur_config) {
|
|
var suit_info = cur_config[_];
|
|
if (suit_info.num == num) {
|
|
suit_config.push(suit_info);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var list = [];
|
|
for (var _i7 in suit_config) {
|
|
var v = suit_config[_i7];
|
|
//说明是激活的
|
|
var _eqm_set = v.id;
|
|
var id = Math.floor(_eqm_set / 100);
|
|
var config = game.configs.partner_holy_eqm_data.data_suit_res_prefix[id];
|
|
if (config) {
|
|
var 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: function checkHolyEquipmentPalnByItemID(item_id) {
|
|
if (!item_id) {
|
|
return false;
|
|
}
|
|
if (!this.holy_equip_plan) {
|
|
return false;
|
|
}
|
|
for (var i in this.holy_equip_plan) {
|
|
var cell = this.holy_equip_plan[i];
|
|
for (var j in cell.list) {
|
|
var v = cell.list[j];
|
|
if (item_id == v.item_id) {
|
|
return {
|
|
bool: true,
|
|
cell: cell
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
bool: false
|
|
};
|
|
},
|
|
//獲取所有英雄穿戴的裝備信息
|
|
//@ return
|
|
getAllHeroHolyEquipList: function getAllHeroHolyEquipList() {
|
|
return this.hero_holy_list || {};
|
|
},
|
|
getHolyEquipById: function getHolyEquipById(id) {
|
|
if (this.hero_holy_list) {
|
|
return this.hero_holy_list[id];
|
|
}
|
|
},
|
|
getHolyPreviewInfo: function getHolyPreviewInfo(_index) {
|
|
var ct = parseInt(_index) * 100 + 5;
|
|
var lst = [];
|
|
var cfgs = game.configs.item_data.data_holy_eqm_list;
|
|
for (var i in cfgs) {
|
|
if (ct >= i && i >= ct - 4) {
|
|
var cfg = cfgs[i];
|
|
for (var j in cfg) {
|
|
lst.push(cfg[j]);
|
|
}
|
|
}
|
|
}
|
|
lst.sort(function (a, b) {
|
|
return b.id - a.id;
|
|
});
|
|
return lst;
|
|
},
|
|
getResetCount: function getResetCount() {
|
|
return this.reset_count;
|
|
},
|
|
//獲取品質
|
|
//@item_id 道具id
|
|
//@ attr_key 屬性名字
|
|
//@ value 屬性值
|
|
getHolyEquipmentQualityByItemIdAttrKey: function getHolyEquipmentQualityByItemIdAttrKey(item_id, attr_key, value) {
|
|
var quality = 0;
|
|
var holy_equip_config = game.configs.partner_holy_eqm_data.data_base_info[item_id];
|
|
if (holy_equip_config) {
|
|
var key = Utils.getNorKey(holy_equip_config[2], attr_key);
|
|
var config = game.configs.partner_holy_eqm_data.data_attr_color_rule[key];
|
|
if (value > 0 && config && config.color_list[0]) {
|
|
var list = config.color_list[0]; // {0-12}
|
|
for (var 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: function getHolyEquipmentMaxAttrByItemIdAttrKey(item_id, attr_key) {
|
|
var max_count = 1;
|
|
var holy_equip_config = game.configs.partner_holy_eqm_data.data_base_info[item_id];
|
|
if (holy_equip_config) {
|
|
var config = game.configs.partner_holy_eqm_data.data_attr_max_info[holy_equip_config[3]];
|
|
if (config) {
|
|
for (var i = 0; i < config.max_attr.length; i++) {
|
|
var v = config.max_attr[i];
|
|
if (v[0] && v[0] == attr_key) {
|
|
max_count = v[1] || 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return max_count;
|
|
},
|
|
// --是否是公會pvp 陣法類型
|
|
isGuildPvpFrom: function isGuildPvpFrom(form_type) {
|
|
var self = this;
|
|
if (self.dic_guild_from_type == null) {
|
|
self.dic_guild_from_type = {};
|
|
var config_list = game.configs.combat_type_data.data_fight_list;
|
|
if (config_list) {
|
|
for (var k in config_list) {
|
|
var config = config_list[k];
|
|
if (config.is_guild_pvp == 1) {
|
|
if (config.from != null) {
|
|
for (var i in config.from[0]) {
|
|
var form = config.from[0][i];
|
|
self.dic_guild_from_type[form] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return self.dic_guild_from_type[form_type];
|
|
}
|
|
});
|
|
|
|
cc._RF.pop(); |