"use strict";
|
cc._RF.push(module, 'cab3eqqKGZLUJgBvXKUXy/7', 'hero_model');
|
// Scripts/mod/hero/hero_model.js
|
|
"use strict";
|
|
// --------------------------------------------------------------------
|
// @author: xxx@syg.com(必填, 创建模块的人员)
|
// @description:
|
// 这里填写详细说明,主要填写该模块的功能简要
|
// <br/>Create: {DATE}
|
// --------------------------------------------------------------------
|
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 HeroModel = cc.Class({
|
"extends": BaseClass,
|
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.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; // 符文解锁条件信息
|
// var artifact_one = Config.partner_data.data_partner_const["artifact_one"].val;
|
// var artifact_two = Config.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; // --英雄信息界面 天赋页签的参数 6星才限时页签
|
|
this.hero_info_talent_skill_param = Config.partner_skill_data.data_partner_skill_const["skill_slot"].val; // --天赋技能升星的材料
|
|
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;
|
},
|
setHeroMaxCount: function setHeroMaxCount(max_count) {
|
if (typeof max_count == "number") {
|
this.hero_max_count = max_count;
|
}
|
},
|
// 获取英雄上上限
|
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;
|
},
|
|
/**
|
* 更新英雄列表
|
* @author zhanghuxing 2019-01-24
|
* @param {[type]} not_show_power 不显示战力变化提示
|
*/
|
updateHeroList: function updateHeroList(hero_list, is_add, not_show_power) {
|
if (!hero_list) return;
|
|
for (var hero_i in hero_list) {
|
this.updateHeroVo(hero_list[hero_i], not_show_power);
|
} // 熔炼祭坛的红点 新增需要重新算红点
|
|
|
if (is_add) {
|
HeroCalculate.getInstance().clearAllStarFuseRedpointRecord();
|
gcore.GlobalEvent.fire(HeroEvent.Hero_Data_Add, hero_list);
|
}
|
|
this.is_init = false;
|
},
|
|
/**
|
* 更新单个英雄信息，如果没有则是新增；
|
*/
|
updateHeroVo: function updateHeroVo(info, not_show_power) {
|
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 = Config.partner_data.data_partner_base[bid];
|
if (!par_cfg) return;
|
var is_add = false;
|
var hero_vo = this.hero_list[info.id];
|
|
if (!hero_vo) {
|
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];
|
} // 设置角色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 (!not_show_power && hero_vo.power < info.power) {
|
GlobalMessageMgr.getInstance().showPowerMove(info.power - hero_vo.power, null, hero_vo.power);
|
} // 处理升星、进阶
|
|
|
if (info.star && hero_vo.star < info.star) {
|
// 升星
|
open_type = 1;
|
old_vo = Utils.deepCopy(hero_vo);
|
|
if (hero_vo.star == this.hero_info_talent_skill_param[1] - 1) {
|
hero_vo.is_open_talent = true;
|
}
|
} else if (info.break_lev && hero_vo.break_lev < info.break_lev) {
|
// 进阶
|
open_type = 2;
|
old_vo = Utils.deepCopy(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);
|
}
|
|
gcore.GlobalEvent.fire(HeroEvent.Hero_Data_Update, hero_vo);
|
}
|
|
HeroCalculate.getInstance().checkHeroRedPointByRedPointType(HeroConst.RedPointType.eRPLevelUp);
|
cc.log("updateHeroVo");
|
},
|
// 获取单个伙伴数据,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;
|
cc.log("delHeroDataList");
|
|
for (var hero_i in list) {
|
var v = list[hero_i];
|
var temp_bid = this.hero_list[v.partner_id].bid;
|
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, list);
|
},
|
// --更新天赋信息
|
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() {
|
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) {
|
// hero_list.push(Utils.deepCopy(this.hero_array[hero_i]));
|
hero_list.push(this.hero_array[hero_i]);
|
}
|
}
|
|
var hero_sort = this.getHeroSortFunc();
|
return hero_list.sort(hero_sort);
|
},
|
// 根据阵容获取英雄列表
|
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(Utils.deepCopy(this.hero_array[hero_i]));
|
hero_list.push(this.hero_array[hero_i]);
|
}
|
}
|
|
var hero_sort = this.getHeroSortFunc();
|
return Utils.deepCopy(hero_list.sort(hero_sort));
|
},
|
getRestHeroListByCamp: function getRestHeroListByCamp(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 rest_hero_list = Utils.deepCopy(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;
|
}
|
}
|
|
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;
|
}
|
},
|
// 初始化图鉴数据
|
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 = Config.partner_data.data_partner_pokedex;
|
|
if (pokedex_cfg) {
|
for (var bid in pokedex_cfg) {
|
var par_cfg = Config.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 = Config.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 = Config.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 = Config.partner_data.data_partner_const.random_hero_icon.val;
|
this.dic_random_hero_head = {};
|
|
for (var val_i in val) {
|
var item_config = gdata("item_data", "data_unit5", 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];
|
},
|
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) {
|
if (hero_vo[this.hero_info_talent_skill_param[0]]) {
|
if (hero_vo[this.hero_info_talent_skill_param[0]] >= this.hero_info_talent_skill_param[1]) {
|
return true;
|
}
|
}
|
|
return false;
|
},
|
|
/************阵法相关************/
|
setFormList: function setFormList(data) {
|
var form_type = data.type >= 0 ? data.type : PartnerConst.Fun_Form.Drama;
|
|
if (this.pos_list[form_type]) {
|
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] = {};
|
|
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 nil 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; // GlobalEvent:getInstance():Fire(HeroEvent.Form_Drama_Event,data)
|
|
var calculate = HeroCalculate.getInstance();
|
RedMgr.getInstance().addCalHandler(calculate.checkAllHeroRedPoint.bind(calculate), RedIds.HeroAll); // 检测红点
|
// HeroCalculate.getInstance().checkAllHeroRedPoint();
|
|
var list = [];
|
|
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;
|
},
|
// 获取自己的队伍阵法站位
|
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 = Config.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();
|
}
|
}
|
|
return false;
|
},
|
getStarFuseList: function getStarFuseList(camp_type) {
|
camp_type = camp_type || 0;
|
var camp_fuse_list = [];
|
var fuse_cfg = Config.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 = Config.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); // Config.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 = Config.partner_data.data_partner_base[bid];
|
var attr_config = Config.partner_data.data_partner_attr[bid];
|
|
if (!base_config || !attr_config) {
|
return;
|
}
|
|
var hero_vo = Utils.deepCopy(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];
|
if (hero_vo.power < data.power) GlobalMessageMgr.getInstance().showPowerMove(data.power - hero_vo.power, null, hero_vo.power); // 判断战力变化
|
|
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;
|
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 = Config.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);
|
|
var SceneConst = require("scene_const");
|
|
require("mainscene_controller").getInstance().setBuildRedStatus(SceneConst.CenterSceneBuild.mall, this.artifact_lucky_red);
|
},
|
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) {
|
if (hero_vo.power < data.power) {
|
GlobalMessageMgr.getInstance().showPowerMove(data.power - hero_vo.power, null, hero_vo.power);
|
}
|
|
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 [];
|
},
|
//---------------------------符文锻造相关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]) {
|
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]) {
|
// 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]) {
|
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() {
|
// GlobalEvent:getInstance():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() {},
|
checkOpenStar11: function checkOpenStar11() {
|
var config = Config.partner_data.data_partner_const.staropen11_world_lev;
|
|
if (config) {
|
if (config.val[0] == "world_lev") {
|
var RoleController = require("role_controller");
|
|
var world_lev = RoleController.getInstance().getModel().getWorldLev() || 0;
|
|
if (world_lev < config.val[1]) {
|
return false;
|
}
|
}
|
}
|
|
return true;
|
},
|
//---------------------天赋技能---------------------------
|
// --设置更新天赋红点
|
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 = Config.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) {
|
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) {
|
//显示
|
var skin_config = Config.partner_skin_data.data_skin_info[show_skin_id];
|
|
if (skin_config) {
|
var setting = {};
|
setting.partner_bid = skin_config.bid;
|
setting.is_chips = 1;
|
setting.init_star = 5;
|
setting.status = 1;
|
setting.show_type = require("partnersummon_const").Gain_Show_Type.Skin_show;
|
setting.skin_id = show_skin_id;
|
|
require("partnersummon_controller").getInstance().openSummonGainShowWindow(true, [setting], null, 2);
|
}
|
}
|
}
|
|
this.hero_skin_list = {};
|
|
for (var _i in data.partner_skins) {
|
var _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 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;
|
}
|
});
|
|
cc._RF.pop();
|
