Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
1759 строки
50 KiB
1759 строки
50 KiB
PetModel = PetModel or BaseClass(BaseVo, true)
|
|
local PetModel = PetModel
|
|
|
|
function PetModel:__init()
|
|
PetModel.Instance = self
|
|
self:Reset()
|
|
end
|
|
|
|
function PetModel:Reset()
|
|
self.pet_cfg = {} --宠物基础配置信息
|
|
self.pet_upgrade_cfg = {} --宠物升级配置信息
|
|
self.pet_story_cfg = {} --宠物故事配置信息
|
|
self.pet_skill_cfg = {} --宠物技能配置信息
|
|
self.pet_life_skill_cfg = {} --宠物生活技能配置
|
|
self.pet_diamond_cfg = {} --宠物宝石配置信息
|
|
self.pet_support_slot_cfg = {} --宠物声援槽位配置信息
|
|
self.pet_support_rank_cfg = {} --宠物声援排名配置信息
|
|
self.pet_cfg_rare = {} --宠物基础配置信息（根据稀有度获取）
|
|
|
|
self.pet_awake_cfg = {} --宠物觉醒配置
|
|
|
|
self.pet_diamond_compose_cfg = {} --宠物宝石合成配置
|
|
|
|
self.pet_upgrade_cfg_max_lv = {} --某稀有度下的宠物的最大等级配置
|
|
|
|
self.follow_pet = 0 --跟随宠物的id
|
|
self.pet_list = {} --自己的宠物列表
|
|
|
|
self.pet_skill_list = {} --宠物技能列表
|
|
self.pet_diamond_list = {} --宠物宝石列表
|
|
|
|
self.pet_support_list = {} --宠物声援信息
|
|
self.pet_support_list.pet_list = {}
|
|
self.pet_support_rank_list ={} --全服宠物声援信息（排行榜前十位）
|
|
|
|
self.pet_vote_data = {}
|
|
|
|
self.my_left_vote_times = 0--剩余的投票次数
|
|
self.max_vote_times = 3 --最大的投票次数
|
|
self.my_vote_data = {} --投票信息
|
|
|
|
self.select_collect_item_id = 0 --当前选中的图鉴itemid
|
|
self.select_item_id = 0 --当前选中的itemid
|
|
|
|
self.pet_rank_reward_data = {} --昨日榜领奖数据
|
|
|
|
self.upgrade_cost_cfg = {} --宠物升级消耗道具配置
|
|
|
|
self.share_cd = 0
|
|
self.share_cd2 = 0
|
|
self.pet_red_dot_info = {} --红点数据
|
|
self.single_pet_feed_red_info = {} --单个宠物的升级红点
|
|
self.single_pet_evolve_red_info = {} --单个宠物的进化红点
|
|
self.single_pet_active_red_info = {} --单个宠物的激活红点
|
|
self.single_pet_rare_active_red_info = {} --单个宠物类型的激活红点（稀有度）
|
|
self.pet_awake_red = {}--觉醒红点
|
|
self.pet_vote_red = false--投票次数红点
|
|
self.pet_vote_reward_red = false--领奖红点
|
|
|
|
self.diamond_compose_red = {}--宝石合成红点列表
|
|
|
|
self.pet_rank_data_num = 0--当前宠物声援榜单的上榜数量
|
|
|
|
self.single_pet_diamond_red_info = {} --单个宠物的宝石红点
|
|
self.single_pet_slot_diamond_red_info = {} --单个宠物槽位上的红点
|
|
|
|
|
|
self.need_update_collect_item = nil
|
|
|
|
self.pet_cfg_by_id = {}
|
|
|
|
self:SetPetCfg()
|
|
self:SetPetRaceMaterial()
|
|
self:SetPetUpgradeCfg()
|
|
self:SetPetStoryCfg()
|
|
self:SetPetSkillCfg()
|
|
self:SetPetDiamondCfg()
|
|
self:SetPetSupportSlotCfg()
|
|
self:SetPetSupportRankCfg()
|
|
self:SetPetAwakeCfg()
|
|
self:SetPetDiamondComposeCfg()
|
|
end
|
|
|
|
function PetModel.getInstance()
|
|
if PetModel.Instance == nil then
|
|
PetModel.Instance = PetModel.New()
|
|
end
|
|
return PetModel.Instance
|
|
end
|
|
|
|
|
|
----------------------------------------------配置的获取------START
|
|
--设置宠物基础配置信息
|
|
function PetModel:SetPetCfg()
|
|
--先初始化一下稀有度配置table
|
|
self.pet_cfg_rare[1] = {}
|
|
self.pet_cfg_rare[2] = {}
|
|
self.pet_cfg_rare[3] = {}
|
|
|
|
--将某id的宠物存一下
|
|
self.pet_cfg_by_id = {}
|
|
|
|
for k,v in pairs(Config.Pet) do
|
|
--设置总配置pet_cfg
|
|
local index = v.pet_id.."@"..v.pet_star
|
|
if not self.pet_cfg[index] then
|
|
self.pet_cfg[index] = {}
|
|
end
|
|
self.pet_cfg[index] = v
|
|
|
|
self.pet_cfg_by_id[v.pet_id] = self.pet_cfg_by_id[v.pet_id] or {}
|
|
self.pet_cfg_by_id[v.pet_id][#self.pet_cfg_by_id[v.pet_id]+1] = v
|
|
|
|
--设置稀有度配置pet_cfg_rare
|
|
if v.rare_degree == 1 then
|
|
if v.pet_star == 1 then
|
|
table.insert(self.pet_cfg_rare[1],v)
|
|
end
|
|
elseif v.rare_degree == 2 then
|
|
if v.pet_star == 1 then
|
|
table.insert(self.pet_cfg_rare[2],v)
|
|
end
|
|
elseif v.rare_degree == 3 then
|
|
if v.pet_star == 1 then
|
|
table.insert(self.pet_cfg_rare[3],v)
|
|
end
|
|
end
|
|
end
|
|
|
|
for k,v in pairs(self.pet_cfg_by_id) do
|
|
local function onSortFunction(v1, v2)
|
|
return v1.pet_star < v2.pet_star
|
|
end
|
|
table.sort(v, onSortFunction)
|
|
end
|
|
end
|
|
|
|
--根据宠物id拿到配置列表
|
|
function PetModel:GetPetCfgById(pet_id)
|
|
return self.pet_cfg_by_id[pet_id] and self.pet_cfg_by_id[pet_id] or {}
|
|
end
|
|
|
|
--宠物的最大星数
|
|
function PetModel:GetPetMaxStar(pet_id)
|
|
if self.pet_cfg_by_id[pet_id] then
|
|
return #self.pet_cfg_by_id[pet_id]
|
|
else
|
|
return 0
|
|
end
|
|
end
|
|
|
|
--判断宠物几星能解锁到这个阶段 1 2 3
|
|
function PetModel:GetStarCanUnlockFigure(pet_id,figure_stage)
|
|
local pet_cfg = self.pet_cfg_by_id[pet_id]
|
|
if pet_cfg then
|
|
local change_times = 0
|
|
local original_figure_id = 0
|
|
for i,v in ipairs(pet_cfg) do
|
|
if v.figure_id ~= original_figure_id then
|
|
change_times = change_times + 1
|
|
if change_times == figure_stage then
|
|
return v.pet_star
|
|
end
|
|
end
|
|
original_figure_id = v.figure_id
|
|
end
|
|
else
|
|
return 0
|
|
end
|
|
end
|
|
|
|
--用当前星数判断是否会进化到下一阶
|
|
function PetModel:CanPetGradeToNextStage(now_star)
|
|
if now_star%5 == 0 then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
--根据资源id判断是不是宠物资源
|
|
function PetModel:IsPetFigureId(figure_id)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
if v.figure_id == figure_id then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function PetModel:GetNowPetFigure( )
|
|
local follow_pet_data = self:GetPetListById(self.follow_pet)
|
|
if follow_pet_data then
|
|
local pet_cfg = self:GetPetCfg(follow_pet_data.pet_id, follow_pet_data.pet_star)
|
|
if pet_cfg then
|
|
return pet_cfg.figure_id
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--根据宠物id pet_id、 宠物星级 pet_star查找相应宠物配置
|
|
function PetModel:GetPetCfg(pet_id, pet_star)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
if v.pet_id == pet_id and v.pet_star == pet_star then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--根据稀有度获取宠物配置信息
|
|
function PetModel:GetPetRareCfg(rare_type)
|
|
local pet_all_cfg = {}
|
|
for k,v in pairs(self.pet_cfg_rare[rare_type]) do
|
|
local is_have = self:GetPetListById(v.pet_id)
|
|
v.is_have = is_have and 1 or 2
|
|
if self:CanShowPet(v.pet_id) then
|
|
table.insert(pet_all_cfg,v)
|
|
end
|
|
end
|
|
local arg = {"is_have", "pet_id"}
|
|
local condition = {Array.LOWER, Array.LOWER}
|
|
SortTools.MoreKeysSorter(pet_all_cfg, arg, condition)
|
|
return pet_all_cfg
|
|
end
|
|
|
|
--排序所有宠物(图鉴)
|
|
function PetModel:GetPetBySort( )
|
|
local pet_all_cfg = {}
|
|
for k,v in pairs(self.pet_cfg_rare) do
|
|
for kk,vv in pairs(v) do
|
|
local is_have = self:GetPetListById(vv.pet_id)
|
|
vv.is_have = is_have and 1 or 2
|
|
if self:CanShowPet(vv.pet_id) then
|
|
table.insert(pet_all_cfg,vv)
|
|
end
|
|
end
|
|
end
|
|
local arg = {"is_have", "rare_degree", "pet_id"}
|
|
local condition = {Array.LOWER, Array.UPPER, Array.LOWER}
|
|
SortTools.MoreKeysSorter(pet_all_cfg, arg, condition)
|
|
return pet_all_cfg
|
|
end
|
|
|
|
--该宠物是否符合开放时间
|
|
function PetModel:CanShowPet(pet_id)
|
|
local pet_cfg = self:GetPetCfg(pet_id,1)
|
|
if not pet_cfg then return false end
|
|
|
|
local is_pet_active = self:IsPetActived(pet_id)
|
|
--如果都已经激活了那就无视开放时间
|
|
if is_pet_active then return true end
|
|
|
|
--未达到开放天数
|
|
if pet_cfg.open_day > 0 and ServerTimeModel:getInstance():GetOpenServerDay() <= pet_cfg.open_day then return false end
|
|
|
|
--未到开放时间
|
|
if pet_cfg.open_time > 0 and TimeUtil:getServerTime() <= pet_cfg.open_time then return false end
|
|
|
|
return true
|
|
end
|
|
|
|
--根据宠物id获取该宠物的种族
|
|
function PetModel:GetPetRaceById(pet_id)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
if v.pet_id == pet_id then
|
|
return v.pet_race
|
|
end
|
|
end
|
|
return 1
|
|
end
|
|
|
|
--根据id获取宠物的品质
|
|
function PetModel:GetPetDegreeById(pet_id)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
if v.pet_id == pet_id then
|
|
return v.rare_degree
|
|
end
|
|
end
|
|
return 1
|
|
end
|
|
|
|
--判断宠物的某个故事是否解锁
|
|
function PetModel:IsStoryActived(pet_id,item_id)
|
|
local data = self:GetPetListById(pet_id)
|
|
local story_cfg = self:GetPetStoryCfg(pet_id,item_id)
|
|
--判断是否已经解锁
|
|
local is_actived = false
|
|
if data then
|
|
if data.pet_star >= story_cfg.star then
|
|
is_actived = true
|
|
else
|
|
is_actived = false
|
|
end
|
|
end
|
|
return is_actived
|
|
end
|
|
|
|
--判断宠物已经解锁到哪个故事了
|
|
function PetModel:GetTheActiveStoryId(pet_id)
|
|
local final_index = 0
|
|
for i=1,3 do
|
|
if self:IsStoryActived(pet_id,i) then
|
|
final_index = final_index + 1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
return final_index
|
|
end
|
|
|
|
--设置不同种族的宠物升级消耗材料信息
|
|
function PetModel:SetPetRaceMaterial( )
|
|
self.upgrade_cost_cfg = {}
|
|
for i,v in ipairs(Config.Petracematerial) do
|
|
self.upgrade_cost_cfg[i] = {}
|
|
self.upgrade_cost_cfg[i].race = v.race
|
|
self.upgrade_cost_cfg[i].cost_material = stringtotable(v.cost_material)
|
|
end
|
|
end
|
|
|
|
--设置宠物升级配置信息
|
|
function PetModel:SetPetUpgradeCfg()
|
|
for k,v in pairs(Config.Petupgrade) do
|
|
local index = v.pet_rare_degree.."@"..v.level
|
|
if not self.pet_upgrade_cfg[index] then
|
|
self.pet_upgrade_cfg[index] = {}
|
|
end
|
|
self.pet_upgrade_cfg[index] = v
|
|
|
|
--记录稀有度下的宠物的最大等级
|
|
if not self.pet_upgrade_cfg_max_lv[v.pet_rare_degree] then
|
|
self.pet_upgrade_cfg_max_lv[v.pet_rare_degree] = {}
|
|
self.pet_upgrade_cfg_max_lv[v.pet_rare_degree].level = 0
|
|
end
|
|
if v.level > self.pet_upgrade_cfg_max_lv[v.pet_rare_degree].level then
|
|
self.pet_upgrade_cfg_max_lv[v.pet_rare_degree].level = v.level
|
|
end
|
|
end
|
|
end
|
|
|
|
--根据稀有度 pet_rare_degree、等级level查找
|
|
function PetModel:GetPetUpgradeCfg(pet_rare_degree,level)
|
|
for k,v in pairs(self.pet_upgrade_cfg) do
|
|
if v.pet_rare_degree == pet_rare_degree and v.level == level then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--获取某稀有度宠物的最大等级
|
|
function PetModel:GetPetMaxLv(pet_rare_degree)
|
|
return self.pet_upgrade_cfg_max_lv[pet_rare_degree].level
|
|
end
|
|
|
|
--设置宠物故事配置表
|
|
function PetModel:SetPetStoryCfg()
|
|
for k,v in pairs(Config.Petstory) do
|
|
local index = v.pet_id.."@"..v.para_id
|
|
if not self.pet_story_cfg[index] then
|
|
self.pet_story_cfg[index] = {}
|
|
end
|
|
self.pet_story_cfg[index] = v
|
|
end
|
|
end
|
|
|
|
--根据宠物id和段落id查找
|
|
function PetModel:GetPetStoryCfg(pet_id,para_id)
|
|
for k,v in pairs(self.pet_story_cfg) do
|
|
if v.pet_id == pet_id and v.para_id == para_id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--设置宠物技能配置表
|
|
function PetModel:SetPetSkillCfg()
|
|
for k,v in pairs(Config.Petskill) do
|
|
local index = v.pet_id.."@"..v.skill_slot
|
|
if not self.pet_skill_cfg[index] then
|
|
self.pet_skill_cfg[index] = {}
|
|
end
|
|
self.pet_skill_cfg[index] = v
|
|
|
|
--宠物生活技能
|
|
if v.skill_talent_type == 0 then
|
|
self.pet_life_skill_cfg[v.skill_talent_id] = v
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取宠物生活配置
|
|
function PetModel:GetPetLifeSkillCfgById(skill_id)
|
|
return self.pet_life_skill_cfg[skill_id] and self.pet_life_skill_cfg[skill_id] or nil
|
|
end
|
|
|
|
--获取宠物生活配置系数
|
|
function PetModel:GetPetLifeSkillRatio(skill_id)
|
|
return self.pet_life_skill_cfg[skill_id] and self.pet_life_skill_cfg[skill_id].skill_ratio or 0
|
|
end
|
|
|
|
--根据宠物id和槽位查找
|
|
function PetModel:GetPetSkillCfg(pet_id,skill_slot,is_awaken)
|
|
local skill_data = {}
|
|
for k,v in pairs(self.pet_skill_cfg) do
|
|
if v.pet_id == pet_id and v.skill_slot == skill_slot then
|
|
skill_data = DeepCopy(v)
|
|
if is_awaken then
|
|
local awake_cfg = self:GetPetAwakeCfg(pet_id)
|
|
local awake_skill_id = awake_cfg and stringtotable(awake_cfg.skill_list)[skill_slot-1] or nil
|
|
if awake_skill_id then
|
|
skill_data.skill_talent_id = awake_skill_id
|
|
end
|
|
end
|
|
return skill_data
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--设置宠物宝石配置表
|
|
function PetModel:SetPetDiamondCfg()
|
|
for k,v in pairs(Config.Petdiamondstorage) do
|
|
local index = v.diamond_id
|
|
if not self.pet_diamond_cfg[index] then
|
|
self.pet_diamond_cfg[index] = {}
|
|
end
|
|
self.pet_diamond_cfg[index] = v
|
|
end
|
|
end
|
|
|
|
--根据宝石id查找
|
|
function PetModel:GetPetDiamondCfg(diamond_id)
|
|
for k,v in pairs(self.pet_diamond_cfg) do
|
|
if v.diamond_id == diamond_id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--设置宠物声援槽位配置信息
|
|
function PetModel:SetPetSupportSlotCfg()
|
|
for k,v in pairs(Config.Petsupportslot) do
|
|
local index = v.slot_id
|
|
if not self.pet_support_slot_cfg[index] then
|
|
self.pet_support_slot_cfg[index] = {}
|
|
end
|
|
self.pet_support_slot_cfg[index] = v
|
|
end
|
|
end
|
|
|
|
--根据槽位id查找
|
|
function PetModel:GetPetSupportSlotCfg(slot_id)
|
|
for k,v in pairs(self.pet_support_slot_cfg) do
|
|
if v.slot_id == slot_id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--设置宠物声援排名配置信息
|
|
function PetModel:SetPetSupportRankCfg()
|
|
for k,v in pairs(Config.Petsupportrank) do
|
|
local index = v.rank
|
|
if not self.pet_support_rank_cfg[index] then
|
|
self.pet_support_rank_cfg[index] = {}
|
|
end
|
|
self.pet_support_rank_cfg[index] = v
|
|
end
|
|
end
|
|
|
|
--根据排名id查找
|
|
function PetModel:GetPetSupportRankCfg(rank)
|
|
for k,v in pairs(self.pet_support_rank_cfg) do
|
|
if v.rank == rank then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--宠物觉醒配置
|
|
function PetModel:SetPetAwakeCfg( )
|
|
self.pet_awake_cfg = DeepCopy(Config.Petawaken)
|
|
end
|
|
|
|
--获取宠物觉醒配置
|
|
function PetModel:GetPetAwakeCfg(pet_id)
|
|
return self.pet_awake_cfg[pet_id]
|
|
end
|
|
|
|
--宠物宝石合成配置
|
|
function PetModel:SetPetDiamondComposeCfg( )
|
|
for k,v in pairs(Config.Petstonecompound) do
|
|
local diamond_cfg = self:GetPetDiamondCfg(v.stone_id)
|
|
if diamond_cfg then
|
|
v.need_race = diamond_cfg.need_race
|
|
v.diamond_type = diamond_cfg.diamond_type
|
|
local goods_vo = GoodsModel:getInstance():GetGoodsBasicByTypeId(v.stone_id)
|
|
v.color = goods_vo.color
|
|
self.pet_diamond_compose_cfg[v.need_race] = self.pet_diamond_compose_cfg[v.need_race] or {}
|
|
table.insert(self.pet_diamond_compose_cfg[v.need_race],v)
|
|
end
|
|
end
|
|
|
|
for k,v in pairs(self.pet_diamond_compose_cfg) do
|
|
local arg = {"diamond_type", "color", "stone_id"}
|
|
local condition = {Array.UPPER, Array.LOWER, Array.LOWER}
|
|
SortTools.MoreKeysSorter(v, arg, condition)
|
|
end
|
|
end
|
|
|
|
function PetModel:GetPetDiamondComposeCfgByRace(race)
|
|
return self.pet_diamond_compose_cfg[race] and self.pet_diamond_compose_cfg[race] or {}
|
|
end
|
|
|
|
----------------------------------------------配置的获取------END
|
|
|
|
--设置宠物列表,16301
|
|
function PetModel:SetPetList(vo)
|
|
self.follow_pet = vo.follow_pet
|
|
for k,v in pairs(vo.pet_list) do
|
|
if not self.pet_list[v.pet_id] then
|
|
self.pet_list[v.pet_id] = {}
|
|
end
|
|
self.pet_list[v.pet_id].pet_id = v.pet_id
|
|
self.pet_list[v.pet_id].pet_star = v.pet_star
|
|
------原有的stage去除，改为5星一个stage
|
|
self.pet_list[v.pet_id].pet_stage = math.ceil((v.pet_star-0.5)/5)
|
|
-------------------------------------
|
|
self.pet_list[v.pet_id].pet_lv = v.pet_lv
|
|
self.pet_list[v.pet_id].now_exp = v.now_exp
|
|
self.pet_list[v.pet_id].power = v.power
|
|
self.pet_list[v.pet_id].collect_time = v.collect_time
|
|
self.pet_list[v.pet_id].attr_list = v.attr_list
|
|
self.pet_list[v.pet_id].is_awaken = v.is_awaken
|
|
end
|
|
end
|
|
|
|
--16303协议激活宠物后先创建该id的列表
|
|
function PetModel:ActivePet(vo)
|
|
self.pet_list[vo.pet_id] = self.pet_list[vo.pet_id] or {}
|
|
self.pet_list[vo.pet_id].pet_id = vo.pet_id
|
|
self.pet_list[vo.pet_id].pet_star = vo.pet_star
|
|
------原有的stage去除，改为5星一个stage
|
|
self.pet_list[vo.pet_id].pet_stage = math.ceil((vo.pet_star-0.5)/5)
|
|
-------------------------------------
|
|
self.pet_list[vo.pet_id].power = vo.pet_power
|
|
self.pet_list[vo.pet_id].pet_lv = 1
|
|
end
|
|
|
|
--根据id获取宠物信息
|
|
function PetModel:GetPetListById(pet_id)
|
|
if self.pet_list[pet_id] then
|
|
return self.pet_list[pet_id]
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--获取排好序的宠物列表
|
|
function PetModel:GetPetListAfterSort()
|
|
local list = self.pet_list
|
|
for k,v in pairs(list) do
|
|
v.rare_degree = self:GetPetDegreeById(v.pet_id)
|
|
end
|
|
|
|
local final_list = {}
|
|
for k,v in pairs(list) do
|
|
table.insert(final_list,v)
|
|
end
|
|
|
|
|
|
local arg = {"rare_degree", "pet_star", "pet_lv"}
|
|
local condition = {Array.UPPER, Array.UPPER, Array.LOWER,}
|
|
SortTools.MoreKeysSorter(final_list, arg, condition)
|
|
|
|
return final_list
|
|
end
|
|
|
|
--根据战力给宠物列表排序（宠物副本用）
|
|
function PetModel:GetPetListAfterSortFight( )
|
|
local final_list = {}
|
|
for k,v in pairs(self.pet_list) do
|
|
v.client_power = self:GetPetFightById(v.pet_id)
|
|
table.insert(final_list,v)
|
|
end
|
|
|
|
|
|
local arg = {"client_power"}
|
|
local condition = {Array.UPPER}
|
|
SortTools.MoreKeysSorter(final_list, arg, condition)
|
|
|
|
return final_list
|
|
end
|
|
|
|
--根据品质等级给宠物列表排序
|
|
function PetModel:GetPetListAfterSortByDegreeAndLv( )
|
|
local list = self.pet_list
|
|
for k,v in pairs(list) do
|
|
v.rare_degree = self:GetPetDegreeById(v.pet_id)
|
|
end
|
|
|
|
local final_list = {}
|
|
for k,v in pairs(list) do
|
|
table.insert(final_list,v)
|
|
end
|
|
|
|
|
|
local arg = {"rare_degree", "pet_lv"}
|
|
local condition = {Array.UPPER, Array.UPPER,}
|
|
SortTools.MoreKeysSorter(final_list, arg, condition)
|
|
|
|
return final_list
|
|
end
|
|
|
|
--喂养宠物后刷新其经验和等级,16302
|
|
function PetModel:SetPetLvAfterFeed(vo)
|
|
if self.pet_list[vo.pet_id] then
|
|
self.pet_list[vo.pet_id].pet_lv = vo.pet_lv
|
|
self.pet_list[vo.pet_id].now_exp = vo.now_exp
|
|
self.pet_list[vo.pet_id].power = vo.pet_power
|
|
end
|
|
end
|
|
|
|
--宠物进阶后刷新其数据,16303
|
|
function PetModel:SetPetDataAfterUpStar(vo)
|
|
if self.pet_list[vo.pet_id] then
|
|
self.pet_list[vo.pet_id].pet_stage = vo.pet_stage
|
|
self.pet_list[vo.pet_id].pet_star = vo.pet_star
|
|
------原有的stage去除，改为5星一个stage
|
|
self.pet_list[vo.pet_id].pet_stage = math.ceil((vo.pet_star-0.5)/5)
|
|
-------------------------------------
|
|
self.pet_list[vo.pet_id].power = vo.pet_power
|
|
end
|
|
end
|
|
|
|
--设置宠物的技能栏数据,16304
|
|
function PetModel:SetPetSkillData(vo)
|
|
if not self.pet_skill_list[vo.pet_id] then
|
|
self.pet_skill_list[vo.pet_id] = {}
|
|
end
|
|
for k,v in pairs(vo.skill_list) do
|
|
if not self.pet_skill_list[vo.pet_id][v.skill_slot_id] then
|
|
self.pet_skill_list[vo.pet_id][v.skill_slot_id] = {}
|
|
end
|
|
self.pet_skill_list[vo.pet_id][v.skill_slot_id].skill_slot_id = v.skill_slot_id
|
|
self.pet_skill_list[vo.pet_id][v.skill_slot_id].talent_type = v.talent_type
|
|
self.pet_skill_list[vo.pet_id][v.skill_slot_id].talent_id = v.talent_id
|
|
end
|
|
end
|
|
|
|
--根据宠物id获取技能数据
|
|
function PetModel:GetPetSkillDataById(pet_id)
|
|
return self.pet_skill_list[pet_id] and self.pet_skill_list[pet_id] or nil
|
|
end
|
|
|
|
--判断宠物技能是否解锁
|
|
function PetModel:IsPetSkillActive(pet_star, active_star)
|
|
local is_actived = false
|
|
if pet_star >= active_star then
|
|
is_actived = true
|
|
else
|
|
is_actived = false
|
|
end
|
|
return is_actived
|
|
end
|
|
|
|
--设置宠物的宝石栏数据，16304
|
|
function PetModel:SetPetDiamondData(vo)
|
|
if not self.pet_diamond_list[vo.pet_id] then
|
|
self.pet_diamond_list[vo.pet_id] = {}
|
|
end
|
|
for k,v in pairs(vo.diamond_list) do
|
|
if not self.pet_diamond_list[vo.pet_id][v.diamond_slot] then
|
|
self.pet_diamond_list[vo.pet_id][v.diamond_slot] = {}
|
|
end
|
|
self.pet_diamond_list[vo.pet_id][v.diamond_slot].diamond_slot = v.diamond_slot
|
|
self.pet_diamond_list[vo.pet_id][v.diamond_slot].diamond_id = v.diamond_id
|
|
end
|
|
end
|
|
|
|
--根据id和槽位获取宝石栏数据(如果位置上没有宝石，直接返回nil)
|
|
function PetModel:GetPetDiamondDataByIdAndSlot(pet_id,slot_id)
|
|
if self.pet_diamond_list[pet_id] and self.pet_diamond_list[pet_id][slot_id] then
|
|
return self.pet_diamond_list[pet_id][slot_id]
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--根据宠物id获取宝石栏数据
|
|
function PetModel:GetPetDiamondDataById(pet_id)
|
|
return self.pet_diamond_list[pet_id] and self.pet_diamond_list[pet_id] or nil
|
|
end
|
|
|
|
--宝石上阵后刷新宝石栏数据,16305
|
|
function PetModel:SetPetDiamondDataAfterPut(vo)
|
|
if not self.pet_diamond_list[vo.pet_id] then
|
|
self.pet_diamond_list[vo.pet_id] = {}
|
|
end
|
|
self.pet_diamond_list[vo.pet_id][vo.diamond_slot] = self.pet_diamond_list[vo.pet_id][vo.diamond_slot] or {}
|
|
self.pet_diamond_list[vo.pet_id][vo.diamond_slot].diamond_slot = vo.diamond_slot
|
|
self.pet_diamond_list[vo.pet_id][vo.diamond_slot].diamond_id = vo.diamond_id
|
|
self.pet_list[vo.pet_id].power = vo.pet_power
|
|
end
|
|
|
|
--宠物跟随,16306
|
|
function PetModel:SetPetFollow(vo)
|
|
if vo.role_id ~= RoleManager.Instance:GetMainRoleId() then return end
|
|
if vo.is_follow == 1 then
|
|
self.follow_pet = vo.pet_id
|
|
else
|
|
self.follow_pet = 0
|
|
end
|
|
end
|
|
|
|
--获取跟随的宠物id
|
|
function PetModel:GetFollowPetId()
|
|
return self.follow_pet or 0
|
|
end
|
|
|
|
function PetModel:GetFollowPetStar( )
|
|
return self:GetPetListById(self.follow_pet).pet_star
|
|
end
|
|
|
|
--宠物声援信息,16307
|
|
function PetModel:SetPetSupportData(vo)
|
|
self.pet_support_list.pet_sum_star = vo.pet_sum_star
|
|
self.pet_support_list.pet_list = self.pet_support_list.pet_list or {}
|
|
for k,v in pairs(vo.pet_list) do
|
|
self.pet_support_list.pet_list[v.support_slot] = self.pet_support_list.pet_list[v.support_slot] or {}
|
|
self.pet_support_list.pet_list[v.support_slot].support_slot = v.support_slot
|
|
self.pet_support_list.pet_list[v.support_slot].pet_id = v.pet_id
|
|
end
|
|
end
|
|
|
|
--找到最前的空声援位
|
|
function PetModel:GetRecentSupportSlot()
|
|
local sum_stars = self:CountPetStars()
|
|
for i=1,10 do
|
|
local support_slot_cfg = self:GetPetSupportSlotCfg(i)
|
|
if sum_stars >= support_slot_cfg.open_sum_star then--已经解锁了
|
|
if self.pet_support_list and self.pet_support_list.pet_list and not self.pet_support_list.pet_list[i] then
|
|
return i
|
|
end
|
|
else
|
|
return 0
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
--根据声援位获取声援信息
|
|
function PetModel:GetPetSupportDataBySlot(slot_id)
|
|
return self.pet_support_list.pet_list and self.pet_support_list.pet_list[slot_id] and self.pet_support_list.pet_list[slot_id] or nil
|
|
end
|
|
|
|
--根据宠物id找到其声援信息
|
|
function PetModel:GetPetSupportDataByPetId(pet_id)
|
|
for k,v in pairs(self.pet_support_list.pet_list) do
|
|
if v.pet_id == pet_id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--获取总星数
|
|
function PetModel:GetPetStars()
|
|
return self.pet_support_list.pet_sum_star
|
|
end
|
|
|
|
--客户端自己计算总星数
|
|
function PetModel:CountPetStars()
|
|
local num = 0
|
|
for k,v in pairs(self.pet_list) do
|
|
num = num + v.pet_star
|
|
end
|
|
return num
|
|
end
|
|
|
|
--宠物上阵之后,16308
|
|
function PetModel:PresentPet(vo)
|
|
self.pet_support_list.pet_list = self.pet_support_list.pet_list or {}
|
|
self.pet_support_list.pet_list[vo.support_slot] = self.pet_support_list.pet_list[vo.support_slot] or {}
|
|
self.pet_support_list.pet_list[vo.support_slot].support_slot = vo.support_slot
|
|
self.pet_support_list.pet_list[vo.support_slot].pet_id = vo.pet_id
|
|
--接下来处理槽位调换的情况
|
|
if vo.old_pet_id ~= 0 and vo.old_support_slot == 0 then--未上阵宠物顶替上阵的
|
|
--啥都不用做，因为阵位数据已经替换了
|
|
return
|
|
elseif vo.old_pet_id == 0 and vo.old_support_slot == 0 then--未上阵宠物上阵空位
|
|
--啥都不用做，因为阵位数据已经替换了
|
|
return
|
|
elseif vo.old_pet_id == 0 and vo.old_support_slot ~= 0 then--上阵宠物换到空位
|
|
--把原来的位置数据置空
|
|
self.pet_support_list.pet_list[vo.old_support_slot] = nil
|
|
-- TableRemove(self.pet_support_list.pet_list,self.pet_support_list.pet_list[vo.old_support_slot])
|
|
elseif vo.old_pet_id ~= 0 and vo.old_support_slot ~= 0 then--两个阵位宠物互换
|
|
--把主动替换方的位置数据换成被动替换方
|
|
self.pet_support_list.pet_list[vo.old_support_slot].pet_id = vo.old_pet_id
|
|
self.pet_support_list.pet_list[vo.old_support_slot].support_slot = vo.old_support_slot
|
|
end
|
|
end
|
|
|
|
--全服宠物声援信息,16309
|
|
-- rank :int8 //全服排名
|
|
-- pet_id :int32 //宠物Id
|
|
-- player_id :int64 //玩家Id
|
|
-- player_name :string //玩家名称
|
|
-- player_power :int64 //玩家战力
|
|
-- support_ratio :int16 //声援率
|
|
function PetModel:SetPetSupportRankData(vo)
|
|
for k,v in pairs(vo.rank_list) do
|
|
self.pet_support_rank_list[v.rank] = v--以排名为键
|
|
end
|
|
self.pet_rank_data_num = #vo.rank_list
|
|
end
|
|
|
|
function PetModel:GetRankData()
|
|
return self.pet_support_rank_list or nil
|
|
end
|
|
|
|
--根据排名rank获取排行榜信息
|
|
function PetModel:GetRankDataByRank(rank)
|
|
return self.pet_support_rank_list[rank] or nil
|
|
end
|
|
|
|
--宠物投票信息 16312
|
|
function PetModel:SetPetVoteData(vo)
|
|
for k,v in pairs(vo.rank_list) do
|
|
self.pet_vote_data[v.rare] = v
|
|
local arg = {"ticket_num", "pet_id"}
|
|
local condition = {Array.UPPER, Array.LOWER}
|
|
SortTools.MoreKeysSorter(self.pet_vote_data[v.rare].rare_list, arg, condition)
|
|
end
|
|
|
|
for k,v in pairs(self.pet_vote_data) do
|
|
local first_ticikes = 0
|
|
for i,v in ipairs(v.rare_list) do
|
|
if i == 1 then
|
|
first_ticikes = v.ticket_num
|
|
end
|
|
if first_ticikes == 0 then
|
|
v.rank = 1
|
|
else
|
|
v.rank = i
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--我的投票信息 16313 16314
|
|
function PetModel:SetPetMyVoteData(vo)
|
|
self.my_left_vote_times = self.max_vote_times - vo.support_times
|
|
self.my_vote_data = vo.my_ticket
|
|
if vo.pet_num then
|
|
self.pet_rank_data_num = vo.pet_num
|
|
--剩余投票次数置为0，不给投票
|
|
if not self:CanVotePetRank() then
|
|
self.my_left_vote_times = 0
|
|
end
|
|
end
|
|
end
|
|
|
|
--宠物声援榜单数量低于8个时候显示空界面并且不能投票
|
|
function PetModel:CanVotePetRank( )
|
|
return self.pet_rank_data_num >= 8
|
|
end
|
|
|
|
--获取我的投票信息
|
|
function PetModel:GetPetMyVoteData( )
|
|
return self.my_vote_data
|
|
end
|
|
|
|
--获取剩余投票次数
|
|
function PetModel:GetMyLeftVoteTimes( )
|
|
return self.my_left_vote_times
|
|
end
|
|
|
|
--昨日人气榜奖励领取信息 16310
|
|
function PetModel:SetPetRankRewardData(vo)
|
|
self.pet_rank_data_num = vo.pet_num
|
|
|
|
if self:CanVotePetRank() then
|
|
for i=1,3 do
|
|
if vo.receive_list and vo.receive_list[i] then
|
|
self.pet_rank_reward_data[i] = vo.receive_list[i]
|
|
else
|
|
self.pet_rank_reward_data[i] = {pet_id = 0,is_received = 0}
|
|
end
|
|
end
|
|
else
|
|
self.pet_rank_reward_data = {}
|
|
end
|
|
|
|
--剩余投票次数置为0，不给投票
|
|
if not self:CanVotePetRank() then
|
|
self.my_left_vote_times = 0
|
|
end
|
|
end
|
|
|
|
--获取昨日榜的领奖数据
|
|
function PetModel:GetPetRankRewardData()
|
|
return self.pet_rank_reward_data
|
|
end
|
|
|
|
--更新领取奖励状态 16315
|
|
function PetModel:UpdatePetRankRewardData(vo)
|
|
local is_find = false
|
|
for k,v in pairs(self.pet_rank_reward_data) do
|
|
if v.pet_id == vo.pet_id then
|
|
v.is_received = 1
|
|
is_find = true
|
|
end
|
|
end
|
|
if not is_find then
|
|
for k,v in pairs(self.pet_rank_reward_data) do
|
|
if v.pet_id == 0 then
|
|
v.pet_id =vo.pet_id
|
|
v.is_received = 1
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--根据稀有度获取投票排行列表
|
|
function PetModel:GetPetVoteDataByRare(rare)
|
|
if self.pet_vote_data[rare] then
|
|
return self.pet_vote_data[rare].rare_list
|
|
end
|
|
|
|
return {}
|
|
end
|
|
|
|
--更新宠物觉醒状态 16316
|
|
function PetModel:UpdatePetAwakeState(vo)
|
|
if self.pet_list[vo.pet_id] then
|
|
self.pet_list[vo.pet_id].is_awaken = 1
|
|
end
|
|
end
|
|
|
|
--计算属性值 宠物当前各基础属性=宠物基础属性+（宠物当前等级-1）*属性对应成长值
|
|
function PetModel:GetPetAttrList(pet_lv,attr_list,diamond_data,awake_cfg,pet_star,pet_id)
|
|
--计算基础属性
|
|
local final_attr_list = attr_list
|
|
for k,v in pairs(final_attr_list) do
|
|
v[2] = v[2]+(pet_lv-1)*v[3]
|
|
end
|
|
|
|
local diamond_attr_data = {}--宝石总加成属性列表
|
|
if diamond_data then
|
|
for k,v in pairs(diamond_data) do
|
|
if v then
|
|
--单个槽位宝石加成属性列表
|
|
local diamond_attr_data_slot = stringtotable(self:GetPetDiamondCfg(v.diamond_id).add_attr_list)
|
|
for k,v in pairs(diamond_attr_data_slot) do
|
|
if not diamond_attr_data[v[1]] then
|
|
diamond_attr_data[v[1]] = {}
|
|
diamond_attr_data[v[1]][1] = v[1]
|
|
diamond_attr_data[v[1]][2] = 0
|
|
end
|
|
diamond_attr_data[v[1]][2] = diamond_attr_data[v[1]][2] + v[2]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
for k,v in pairs(final_attr_list) do
|
|
if diamond_attr_data[v[1]] then
|
|
v[2] = v[2] + diamond_attr_data[v[1]][2]
|
|
diamond_attr_data[v[1]].isGet = true
|
|
end
|
|
end
|
|
for k,v in pairs(diamond_attr_data) do
|
|
if not v.isGet then
|
|
table.insert(final_attr_list,v)
|
|
end
|
|
end
|
|
|
|
local awaken_attr_data = {}--觉醒加成属性
|
|
if awake_cfg then
|
|
local awake_attr_cfg = stringtotable(awake_cfg.add_attr)
|
|
for k,v in pairs(awake_attr_cfg) do
|
|
awaken_attr_data[v[1]] = v
|
|
end
|
|
end
|
|
for k,v in pairs(final_attr_list) do
|
|
if awaken_attr_data[v[1]] then
|
|
v[2] = v[2] + awaken_attr_data[v[1]][2]
|
|
awaken_attr_data[v[1]].isGet = true
|
|
end
|
|
end
|
|
for k,v in pairs(awaken_attr_data) do
|
|
if not v.isGet then
|
|
table.insert(final_attr_list,v)
|
|
end
|
|
end
|
|
|
|
local skill_attr_data = {}--技能属性加成
|
|
local sttr_list = {}
|
|
local data = self:GetPetSkillCfg(pet_id,3,awake_cfg)
|
|
if data and data.active_star <= pet_star then
|
|
local skill_id = data.skill_talent_id
|
|
sttr_list = GetSkillAttrBySkill( skill_id, 1 )
|
|
end
|
|
|
|
for k,v in pairs(sttr_list) do
|
|
skill_attr_data[v[1]] = v
|
|
end
|
|
for k,v in pairs(final_attr_list) do
|
|
if skill_attr_data[v[1]] then
|
|
v[2] = v[2] + skill_attr_data[v[1]][2]
|
|
skill_attr_data[v[1]].isGet = true
|
|
end
|
|
end
|
|
for k,v in pairs(skill_attr_data) do
|
|
if not v.isGet then
|
|
table.insert(final_attr_list,v)
|
|
end
|
|
end
|
|
|
|
local skill_attr_data_2 = {}--技能属性加成
|
|
local sttr_list_2 = {}
|
|
local data_2 = self:GetPetSkillCfg(pet_id,4,awake_cfg)
|
|
if data_2 and data_2.active_star <= pet_star then
|
|
local skill_id = data_2.skill_talent_id
|
|
sttr_list_2 = GetSkillAttrBySkill( skill_id, 1 )
|
|
end
|
|
|
|
for k,v in pairs(sttr_list_2) do
|
|
skill_attr_data_2[v[1]] = v
|
|
end
|
|
for k,v in pairs(final_attr_list) do
|
|
if skill_attr_data_2[v[1]] then
|
|
v[2] = v[2] + skill_attr_data_2[v[1]][2]
|
|
skill_attr_data_2[v[1]].isGet = true
|
|
end
|
|
end
|
|
for k,v in pairs(skill_attr_data_2) do
|
|
if not v.isGet then
|
|
table.insert(final_attr_list,v)
|
|
end
|
|
end
|
|
|
|
return final_attr_list
|
|
end
|
|
|
|
--合并属性table得出一个格式为{{属性id,当前属性值,下一级增长值},{}}的新table
|
|
function PetModel:MergeAttrList(tb_now,tb_next)
|
|
for i,v in ipairs(tb_now) do
|
|
v[3] = tb_next[i][2]-v[2]
|
|
end
|
|
return tb_now
|
|
end
|
|
|
|
--第二种合并法（当前属性和上一阶段的比较）
|
|
function PetModel:MergeAttrList2(tb_now,tb_last)
|
|
for i,v in ipairs(tb_now) do
|
|
local last_num = tb_last[i] and tb_last[i][2] or 0
|
|
v[3] = v[2] - last_num
|
|
end
|
|
return tb_now
|
|
end
|
|
|
|
--判断该宠物是否已经激活
|
|
function PetModel:IsPetActived(pet_id)
|
|
return self.pet_list[pet_id] and true or false
|
|
end
|
|
|
|
|
|
--------物品数量检测---START
|
|
-----
|
|
function PetModel:UpPetChipGoodsChange( )--刷新宠物碎片道具
|
|
self:Fire(PetConst.UPDATE_PET_GOODS_NUM,1)
|
|
end
|
|
|
|
function PetModel:UpPetFeedGoodsChange( )--刷新宠物升级道具
|
|
self:Fire(PetConst.UPDATE_PET_GOODS_NUM,2)
|
|
end
|
|
|
|
function PetModel:UpPetDiamondGoodsChange( )--刷新宠物技能宝石
|
|
self:Fire(PetConst.UPDATE_PET_GOODS_NUM,3)
|
|
end
|
|
|
|
function PetModel:UpPetAwakeMaterial( )--刷新宠物觉醒碎片
|
|
self:Fire(PetConst.UPDATE_PET_GOODS_NUM,4)
|
|
end
|
|
-----
|
|
--------物品数量检测---END
|
|
|
|
--宠物进化前保存一下当前的数据，用于进化成功界面的属性对比
|
|
function PetModel:RecordDataBeforeEvolve(data)
|
|
self.pet_old_data = self.pet_old_data or {}
|
|
self.pet_old_data[data.pet_id] = self.pet_old_data[data.pet_id] or {}
|
|
self.pet_old_data[data.pet_id] = data
|
|
end
|
|
|
|
--获取宠物进化前的数据
|
|
function PetModel:GetPetOldDataById(pet_id)
|
|
return self.pet_old_data and self.pet_old_data[pet_id] and self.pet_old_data[pet_id] or nil
|
|
end
|
|
|
|
--获取宠物id某阶段时的最大星数
|
|
function PetModel:GetMaxStarInStage(pet_id,star)
|
|
local final_max_star = self:GetPetMaxStar(pet_id)
|
|
local final_stage_max_star = math.ceil((final_max_star-0.5)/5)*5--最后阶段的理论最高星数
|
|
if final_stage_max_star-star < 5 then--判断是否在最后的阶段
|
|
return 5 - (final_stage_max_star - final_max_star)
|
|
else
|
|
return 5
|
|
end
|
|
return 5
|
|
end
|
|
|
|
--获取宠物进化后的下一星级
|
|
function PetModel:GetNextStageAndStar(pet_id,now_star)
|
|
local max_star = self:GetPetMaxStar(pet_id)
|
|
local next_star
|
|
-- if now_star == max_star then--已经满星了
|
|
-- next_star = max_star
|
|
-- else
|
|
next_star = now_star + 1
|
|
-- end
|
|
return next_star
|
|
end
|
|
|
|
--转换宠物当前显示的星数
|
|
function PetModel:GetNowShowPetStar(star)
|
|
return (star-1)%5+1
|
|
end
|
|
|
|
------------红点------START
|
|
function PetModel:IsNeedRedAll( )
|
|
for k,v in pairs(PetConst.RED_DOT_TYPE) do
|
|
self:IsNeedRed(v)
|
|
end
|
|
end
|
|
|
|
function PetModel:IsNeedRed( tab_id )
|
|
local bool = false
|
|
if GetModuleIsOpen(163) then
|
|
if tab_id == PetConst.RED_DOT_TYPE.Feed then--升级
|
|
bool = self:CheckPetFeedRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Evolve then--进化
|
|
bool = self:CheckPetEvolveRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Diamond then--宝石
|
|
bool = self:CheckPetDiamondRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Active then--激活
|
|
bool = self:CheckPetActiveRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Vote then--投票
|
|
bool = self:CheckPetVoteRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Reward then--领奖
|
|
bool = self:CheckPetRewardRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.Awake then--觉醒
|
|
bool = self:CheckPetAwakeRed()
|
|
elseif tab_id == PetConst.RED_DOT_TYPE.DiamondCompose then--宝石合成
|
|
bool = self:CheckDiamondComposeRed()
|
|
end
|
|
end
|
|
self.pet_red_dot_info[tab_id] = bool
|
|
self:Fire(PetConst.ANS_UPDATE_RED_DOT,tab_id,bool)
|
|
end
|
|
|
|
function PetModel:GetAllRedDot( )
|
|
return self.pet_red_dot_info
|
|
end
|
|
|
|
--获取宠物红点
|
|
function PetModel:GetPetRedDotByType(tab_type)
|
|
if not tab_type then return false end
|
|
return self.pet_red_dot_info[tab_type]
|
|
end
|
|
|
|
--获取单个宠物的升级红点
|
|
function PetModel:GetSingleFeedRedDot(pet_id)
|
|
return self.single_pet_feed_red_info[pet_id]
|
|
end
|
|
|
|
--获取单个宠物的进化红点
|
|
function PetModel:GetSingleEvolveRedDot(pet_id)
|
|
return self.single_pet_evolve_red_info[pet_id]
|
|
end
|
|
|
|
--获取单个宠物的激活红点
|
|
function PetModel:GetSingleActiveRedDot(pet_id)
|
|
return self.single_pet_active_red_info[pet_id]
|
|
end
|
|
|
|
--获取单个宠物稀有度类型的激活红点
|
|
function PetModel:GetSingleRareActiveRedDot(rare_type)
|
|
return self.single_pet_rare_active_red_info[rare_type]
|
|
end
|
|
|
|
--获得单个宠物的宝石红点
|
|
function PetModel:GetSingleDiamondRedDot(pet_id)
|
|
return self.single_pet_diamond_red_info[pet_id]
|
|
end
|
|
|
|
--获得单个宠物槽位的宝石红点
|
|
function PetModel:GetSingleSlotDiamondRedDot(pet_id,slot_id)
|
|
return self.single_pet_slot_diamond_red_info[pet_id][slot_id]
|
|
end
|
|
|
|
--获取单个宠物觉醒的红点
|
|
function PetModel:GetPetAwakeRedDot(pet_id)
|
|
return self.pet_awake_red[pet_id]
|
|
end
|
|
|
|
--获取宠物投票次数红点
|
|
function PetModel:GetPetVoteTimesRed( )
|
|
return self.pet_vote_red
|
|
end
|
|
|
|
--获取领奖红点
|
|
function PetModel:GetPetRewardRed( )
|
|
return self.pet_vote_reward_red
|
|
end
|
|
|
|
-------升级红点相关
|
|
function PetModel:IsFeedCostEnough(pet_race)
|
|
for k,v in pairs(self.upgrade_cost_cfg[pet_race].cost_material) do
|
|
local goods_num = GoodsModel:getInstance():GetTypeGoodsNum(v[1])
|
|
if goods_num >= 1 then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function PetModel:CheckPetFeedRed()
|
|
local bool = false
|
|
for k,v in pairs(self.pet_list) do
|
|
if self:CheckPetFeedRedById(v.pet_id) then
|
|
bool = true
|
|
self.single_pet_feed_red_info[v.pet_id] = true
|
|
else
|
|
self.single_pet_feed_red_info[v.pet_id] = false
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function PetModel:CheckPetFeedRedById(pet_id)
|
|
local data = self:GetPetListById(pet_id)
|
|
if not data then return false end
|
|
local cfg = self:GetPetCfg(data.pet_id,data.pet_star)
|
|
local max_lv = self:GetPetMaxLv(cfg.rare_degree)
|
|
if data.pet_lv < max_lv and self:IsFeedCostEnough(cfg.pet_race) then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
------------------------
|
|
|
|
-------进化红点相关
|
|
function PetModel:CheckPetEvolveRed()
|
|
local bool = false
|
|
for k,v in pairs(self.pet_list) do
|
|
if self:CheckPetEvolveRedById(v.pet_id) then
|
|
bool = true
|
|
self.single_pet_evolve_red_info[v.pet_id] = true
|
|
else
|
|
self.single_pet_evolve_red_info[v.pet_id] = false
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function PetModel:CheckPetEvolveRedById(pet_id)
|
|
local data = self:GetPetListById(pet_id)
|
|
if not data then return false end
|
|
local next_star = self:GetNextStageAndStar(data.pet_id, data.pet_star)
|
|
local cfg_data = self:GetPetCfg(data.pet_id, next_star)
|
|
if not cfg_data then return false end
|
|
|
|
local cost_data = stringtotable(cfg_data.cost)
|
|
local goods_type_id = cost_data[1][2]
|
|
local goods_num = GoodsModel:getInstance():GetTypeGoodsNum(goods_type_id)
|
|
local can_evolve = goods_num >= cost_data[1][3]
|
|
return can_evolve
|
|
end
|
|
------------------------
|
|
|
|
-------激活红点相关
|
|
function PetModel:CheckPetActiveRed()
|
|
for i=1,3 do
|
|
if self:CheckPetActiveRedByRareType(i) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function PetModel:CheckPetActiveRedByRareType(rare_type)
|
|
local data = self:GetPetRareCfg(rare_type)
|
|
self.single_pet_rare_active_red_info[rare_type] = false
|
|
local bool = false
|
|
for k,v in pairs(data) do
|
|
if self:CheckPetActiveRedById(v.pet_id) then
|
|
bool = true
|
|
self.single_pet_active_red_info[v.pet_id] = true
|
|
self.single_pet_rare_active_red_info[rare_type] = true
|
|
else
|
|
self.single_pet_active_red_info[v.pet_id] = false
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function PetModel:CheckPetActiveRedById(pet_id)
|
|
local is_actived = self:IsPetActived(pet_id)
|
|
if is_actived then return false end
|
|
if not self:CanShowPet(pet_id) then return false end
|
|
|
|
local cfg = self:GetPetCfg(pet_id, 1)
|
|
local cost_table = stringtotable(cfg.cost)[1]--需要的消耗材料
|
|
local have_num = GoodsModel:getInstance():GetGoodsNumFromType(0,cost_table[2])--拥有的碎片数量
|
|
local need_num = cost_table[3]--需要的碎片数量
|
|
local enough = have_num >= need_num--是否达到解锁条件
|
|
return enough
|
|
end
|
|
------------------------
|
|
|
|
-------宝石红点相关
|
|
function PetModel:CheckPetDiamondRed()
|
|
local bool = false
|
|
for k,v in pairs(self.pet_list) do
|
|
if self:CheckPetDiamondRedById(v.pet_id) then
|
|
bool = true
|
|
self.single_pet_diamond_red_info[v.pet_id] = true
|
|
else
|
|
self.single_pet_diamond_red_info[v.pet_id] = false
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function PetModel:CheckPetDiamondRedById(pet_id)
|
|
self.single_pet_slot_diamond_red_info[pet_id] = self.single_pet_slot_diamond_red_info[pet_id] or {}
|
|
|
|
local pet_race = self:GetPetRaceById(pet_id)
|
|
|
|
local list = DeepCopy(GoodsModel:getInstance():GetPetDiamondDicByType())
|
|
local diamond_type_data={}--保存该槽位的宝石类型
|
|
for i=1,4 do
|
|
local data = self:GetPetDiamondDataByIdAndSlot(pet_id,i)
|
|
if data then
|
|
if list[data.diamond_id] then
|
|
list[data.diamond_id] = nil
|
|
end
|
|
local diamond_type = self:GetPetDiamondCfg(data.diamond_id).diamond_type
|
|
table.insert(diamond_type_data,diamond_type)
|
|
end
|
|
end
|
|
local bool = false
|
|
for i=1,4 do
|
|
self.single_pet_slot_diamond_red_info[pet_id][i] = false
|
|
if not self:GetPetDiamondDataByIdAndSlot(pet_id,i) then
|
|
for k,v in pairs(list) do
|
|
local diamond_race = self:GetPetDiamondCfg(k).need_race
|
|
local diamond_type_2 = self:GetPetDiamondCfg(k).diamond_type
|
|
if v and diamond_race == pet_race then
|
|
local is_different_type = true
|
|
for kk,vv in pairs(diamond_type_data) do
|
|
if vv == diamond_type_2 then
|
|
is_different_type = false
|
|
end
|
|
end
|
|
self.single_pet_slot_diamond_red_info[pet_id][i] = is_different_type
|
|
bool = is_different_type
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
------------------------
|
|
|
|
--投票红点
|
|
function PetModel:CheckPetVoteRed( )
|
|
local bool = self.my_left_vote_times > 0 and self:CanVotePetRank()
|
|
self.pet_vote_red = bool
|
|
return bool
|
|
end
|
|
|
|
--领奖红点
|
|
function PetModel:CheckPetRewardRed( )
|
|
local bool = false
|
|
for k,v in pairs(self.pet_rank_reward_data) do
|
|
if v.is_received == 0 then
|
|
bool = true
|
|
break
|
|
end
|
|
end
|
|
self.pet_vote_reward_red = bool
|
|
return bool
|
|
end
|
|
|
|
--觉醒红点
|
|
function PetModel:CheckPetAwakeRed( )
|
|
if not GetModuleIsOpen(163,4) then return false end
|
|
local bool = false
|
|
for k,v in pairs(self.pet_list) do
|
|
if v.is_awaken == 0 then --未觉醒
|
|
local awake_cfg = self:GetPetAwakeCfg(v.pet_id)
|
|
local cost_data = stringtotable(awake_cfg.cost_material)
|
|
local goods_num = GoodsModel:getInstance():GetTypeGoodsNum(cost_data[1][2])
|
|
if goods_num >= cost_data[1][3] and v.pet_star >= awake_cfg.need_star then
|
|
bool = true
|
|
self.pet_awake_red[v.pet_id] = true
|
|
else
|
|
self.pet_awake_red[v.pet_id] = false
|
|
end
|
|
else
|
|
self.pet_awake_red[v.pet_id] = false
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
--宝石合成红点
|
|
function PetModel:CheckDiamondComposeRed( )
|
|
if not GetModuleIsOpen(163,1) then return false end
|
|
local bool = false
|
|
local material_data = nil
|
|
local diamond_num = 0
|
|
for k,v in pairs(self.pet_diamond_compose_cfg) do
|
|
for m,n in pairs(v) do
|
|
material_data = stringtotable(n.compound_list)
|
|
diamond_num = GoodsModel:getInstance():GetPetDiamondNumByTypeID(material_data[1][1])
|
|
if diamond_num >= 3 then
|
|
bool = true
|
|
self.diamond_compose_red[n.stone_id] = true
|
|
else
|
|
self.diamond_compose_red[n.stone_id] = false
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
function PetModel:GetPetDiamnondComposeRedById(diamond_id)
|
|
return self.diamond_compose_red[diamond_id] and self.diamond_compose_red[diamond_id] or false
|
|
end
|
|
|
|
function PetModel:GetPetDiamnondComposeRedList( )
|
|
return self.diamond_compose_red
|
|
end
|
|
|
|
------------红点------END
|
|
|
|
|
|
--计算宠物战力
|
|
function PetModel:GetPetFightById(pet_id)
|
|
local diamond_data = self:GetPetDiamondDataById(pet_id)--取出宝石所加的属性一并计算
|
|
local pet_data = self:GetPetListById(pet_id)
|
|
local pet_cfg = self:GetPetCfg(pet_id, pet_data.pet_star)
|
|
local awake_cfg = nil
|
|
if pet_data.is_awaken == 1 then
|
|
awake_cfg = self:GetPetAwakeCfg(pet_id)
|
|
end
|
|
local attr_list = self:GetPetAttrList(pet_data.pet_lv,stringtotable(pet_cfg.attr_list),diamond_data,awake_cfg,pet_data.pet_star,pet_data.pet_id)
|
|
--上面拿到的属性列表list不是Getfighting用到的参数格式，先转一下格式
|
|
local need_attr_list = {}
|
|
for k,v in pairs(attr_list) do
|
|
local data = {v[1],v[2]}
|
|
table.insert(need_attr_list,data)
|
|
end
|
|
local fight_value = GetFighting(need_attr_list,true)
|
|
|
|
--技能基础战力添加
|
|
for i=1,4 do
|
|
local skill_data = self:GetPetSkillCfg(pet_id,i,awake_cfg)
|
|
if skill_data and pet_data.pet_star >= skill_data.active_star then
|
|
local skill_id = skill_data.skill_talent_id
|
|
local conf_power = GetSkillConfPowerBySkill(skill_id, 1)
|
|
fight_value = fight_value + conf_power
|
|
end
|
|
end
|
|
|
|
return fight_value
|
|
end
|
|
|
|
--传入petdata的计算战力方式
|
|
function PetModel:GetPetFightByData(data)
|
|
local pet_data = data
|
|
local diamond_data = self:GetPetDiamondDataById(pet_data.pet_id)--取出宝石所加的属性一并计算
|
|
local pet_cfg = self:GetPetCfg(pet_data.pet_id, pet_data.pet_star)
|
|
local awake_cfg = nil
|
|
if pet_data.is_awaken == 1 then
|
|
awake_cfg = self:GetPetAwakeCfg(pet_data.pet_id)
|
|
end
|
|
local attr_list = self:GetPetAttrList(pet_data.pet_lv,stringtotable(pet_cfg.attr_list),diamond_data,awake_cfg,pet_data.pet_star,pet_data.pet_id)
|
|
--上面拿到的属性列表list不是Getfighting用到的参数格式，先转一下格式
|
|
local need_attr_list = {}
|
|
for k,v in pairs(attr_list) do
|
|
local data = {v[1],v[2]}
|
|
table.insert(need_attr_list,data)
|
|
end
|
|
local fight_value = GetFighting(need_attr_list,true)
|
|
|
|
--技能基础战力添加
|
|
for i=1,4 do
|
|
local skill_data = self:GetPetSkillCfg(pet_data.pet_id,i,awake_cfg)
|
|
if skill_data and pet_data.pet_star >= skill_data.active_star then
|
|
local skill_id = skill_data.skill_talent_id
|
|
local conf_power = GetSkillConfPowerBySkill(skill_id, 1)
|
|
fight_value = fight_value + conf_power
|
|
end
|
|
end
|
|
|
|
return fight_value
|
|
end
|
|
|
|
--计算声援加成系数之后的战力
|
|
function PetModel:GetPetAditionFightById(pet_id,adition)
|
|
local diamond_data = self:GetPetDiamondDataById(pet_id)--取出宝石所加的属性一并计算
|
|
local pet_data = self:GetPetListById(pet_id)
|
|
local pet_cfg = self:GetPetCfg(pet_id, pet_data.pet_star)
|
|
local awake_cfg = nil
|
|
if pet_data.is_awaken == 1 then
|
|
awake_cfg = self:GetPetAwakeCfg(pet_id)
|
|
end
|
|
local attr_list = self:GetPetAttrList(pet_data.pet_lv,stringtotable(pet_cfg.attr_list),diamond_data,awake_cfg,pet_data.pet_star,pet_data.pet_id)
|
|
--上面拿到的属性列表list不是Getfighting用到的参数格式，先转一下格式,并把加成系数算进去
|
|
local need_attr_list = {}
|
|
for k,v in pairs(attr_list) do
|
|
local adition_attr = v[2]*(1+adition)
|
|
local data = {v[1],adition_attr}
|
|
table.insert(need_attr_list,data)
|
|
end
|
|
local fight_value = GetFighting(need_attr_list,true)
|
|
|
|
--技能基础战力添加
|
|
for i=1,4 do
|
|
local skill_data = self:GetPetSkillCfg(pet_data.pet_id,i,awake_cfg)
|
|
if skill_data and pet_data.pet_star >= skill_data.active_star then
|
|
local skill_id = skill_data.skill_talent_id
|
|
local conf_power = GetSkillConfPowerBySkill(skill_id, 1)
|
|
fight_value = fight_value + conf_power
|
|
end
|
|
end
|
|
|
|
return fight_value
|
|
end
|
|
|
|
|
|
--获取当前出战的宠物战斗技能id列表
|
|
function PetModel:GetFollowPetFightSkillIdList()
|
|
local fight_skill_data = {}
|
|
if not self.follow_pet or self.follow_pet == 0 then
|
|
return fight_skill_data
|
|
end
|
|
|
|
local follow_pet_data = self:GetPetListById(self.follow_pet)
|
|
for i=1,4 do--遍历4个技能槽位，找到战斗技能
|
|
local fight_skill_cfg = self:GetPetSkillCfg(self.follow_pet,i,follow_pet_data.is_awaken==1)
|
|
if fight_skill_cfg.skill_talent_type == 2 then --类型2为战斗技能
|
|
if self:IsPetSkillActive(follow_pet_data.pet_star, fight_skill_cfg.active_star) then
|
|
table.insert(fight_skill_data,fight_skill_cfg.skill_talent_id)
|
|
end
|
|
end
|
|
end
|
|
|
|
return fight_skill_data
|
|
end
|
|
|
|
--获取当前助战的宠物战斗大招技能id
|
|
function PetModel:GetHelpPetFightSkillIdList( )
|
|
local skill_id_list = {}
|
|
local pet_1 = self:GetPetSupportDataBySlot(2)
|
|
local pet_2 = self:GetPetSupportDataBySlot(3)
|
|
|
|
if pet_1 then
|
|
local pet_1_data = self:GetPetListById(pet_1.pet_id)
|
|
local pet_1_skill_cfg = self:GetPetSkillCfg(pet_1_data.pet_id, 4, pet_1_data.is_awaken==1)
|
|
if self:IsPetSkillActive(pet_1_data.pet_star, pet_1_skill_cfg.active_star) then
|
|
local temp = {
|
|
pet_id = pet_1_data.pet_id,
|
|
pet_star = pet_1_data.pet_star,
|
|
pet_skill = pet_1_skill_cfg.skill_talent_id,
|
|
}
|
|
table.insert(skill_id_list,temp)
|
|
end
|
|
end
|
|
|
|
if pet_2 then
|
|
local pet_2_data = self:GetPetListById(pet_2.pet_id)
|
|
local pet_2_skill_cfg = self:GetPetSkillCfg(pet_2_data.pet_id, 4, pet_2_data.is_awaken==1)
|
|
if self:IsPetSkillActive(pet_2_data.pet_star, pet_2_skill_cfg.active_star) then
|
|
local temp = {
|
|
pet_id = pet_2_data.pet_id,
|
|
pet_star = pet_2_data.pet_star,
|
|
pet_skill = pet_2_skill_cfg.skill_talent_id,
|
|
}
|
|
table.insert(skill_id_list,temp)
|
|
end
|
|
end
|
|
|
|
return skill_id_list
|
|
end
|
|
|
|
--根据宠物id pet_id、宠物星级 pet_star查找相应宠物配置
|
|
function PetModel:GetPetBaseFightCfg(pet_id,pet_star)
|
|
print("huangcong:PetModel [start:1035] :", pet_id,pet_star)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
if v.pet_id == pet_id and v.pet_star == pet_star then
|
|
local base_attr = stringtotable(DeepCopy(v.attr_list))
|
|
base_attr = SortAttrList( base_attr )
|
|
print("huangcong:PetModel [start:1039] :", base_attr)
|
|
PrintTable(base_attr)
|
|
print("huangcong:PetModel [end]")
|
|
|
|
local new_base_attr = {}
|
|
for i,v in ipairs(base_attr) do
|
|
local attr = {}
|
|
attr[1] = v[1]
|
|
attr[2] = v[2]
|
|
new_base_attr[#new_base_attr + 1] = attr
|
|
end
|
|
print("huangcong:PetModel [start:1051] :", GetFighting(new_base_attr))
|
|
PrintTable(new_base_attr)
|
|
print("huangcong:PetModel [end]")
|
|
return GetFighting(new_base_attr)
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
function PetModel:ChangeFightPetScene(vo,do_skill_call_back)
|
|
data = {
|
|
role_id = RoleManager.Instance.mainRoleInfo.role_id,
|
|
pet_id = vo.pet_id,
|
|
is_follow = 1,
|
|
pet_star = vo.pet_star,
|
|
}
|
|
self:Fire(PetConst.UPDATE_SCENE_PET_MODEL,data,do_skill_call_back)
|
|
end
|
|
|
|
|
|
--提供一个通过碎片goods_id获取宠物基础属性列表的接口给皮皮聪
|
|
function PetModel:GetConfAttrListByGoodsId(goods_id)
|
|
local attr_list = {}
|
|
for k,v in pairs(self.pet_cfg) do
|
|
local cost = stringtotable(v.cost)
|
|
if v.pet_star == 1 and cost[1] and cost[1][2] == goods_id then
|
|
attr_list = stringtotable(v.attr_list)
|
|
break
|
|
end
|
|
end
|
|
return attr_list
|
|
end
|
|
|
|
--根据碎片goodsid获取宠物形象（最小的形象）
|
|
function PetModel:GetPetFigureByGoodsId(goods_id)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
local cost = stringtotable(v.cost)
|
|
if v.pet_star == 1 and cost[1] and cost[1][2] == goods_id then
|
|
return v.figure_id, Trim(v.pet_name)
|
|
end
|
|
end
|
|
return 1121,""
|
|
end
|
|
|
|
--根据碎片goodsid获取宠物id
|
|
function PetModel:GetPetIdByGoodsId(goods_id)
|
|
for k,v in pairs(self.pet_cfg) do
|
|
local cost = stringtotable(v.cost)
|
|
if v.pet_star == 1 and cost[1] and cost[1][2] == goods_id then
|
|
return v.pet_id
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--根据宠物的宝石列表得出宝石光环特效资源名 规则：4个宝石全穿戴，以其中最低品质为资源
|
|
function PetModel:GetPokemonDiamondEffectRes(pokemon_id)
|
|
local diamond_data = self:GetPetDiamondDataById(pokemon_id)
|
|
if not diamond_data then return nil end
|
|
--找到身上品质最高的宝石颜色
|
|
local low_color = 6
|
|
local diamond_num = 0
|
|
for k,v in pairs(diamond_data) do
|
|
diamond_num = diamond_num + 1
|
|
local color = GoodsModel:getInstance():GetGoodsColorNum(v.diamond_id)
|
|
if color < low_color then
|
|
low_color = color
|
|
end
|
|
end
|
|
--颜色3（紫色）以上才开始有资格创建光环特效
|
|
local diamond_effect_res = nil
|
|
if low_color >= 3 and diamond_num == 4 then
|
|
diamond_effect_res = "effect_pet_guanghuan_00"..(low_color-2)
|
|
end
|
|
return diamond_effect_res
|
|
end
|
|
|
|
--根据宠物id获取宠物的原生id（即宠物最初形态的形象id）
|
|
function PetModel:GetPetOriginalFigureId(pet_id)
|
|
local pet_cfg = self:GetPetCfg(pet_id,1)
|
|
return pet_cfg and pet_cfg.figure_id or nil
|
|
end
|
|
|
|
---------宠物生活技能--------->>>>>>>
|
|
function PetModel:IsLifeSkillActived(skill_id)
|
|
--后端提交前先屏蔽
|
|
-- do return false end
|
|
|
|
--判断技能是否存在或是否被屏蔽
|
|
local is_skill_have = false
|
|
for k,v in pairs(PetConst.LifeSkill) do
|
|
if v == skill_id then
|
|
is_skill_have = true
|
|
break
|
|
end
|
|
end
|
|
if not is_skill_have then return false end
|
|
|
|
local is_in_shiled_list = false
|
|
for k,v in pairs(PetConst.LifeSkillShieldList) do
|
|
if v == skill_id then
|
|
is_in_shiled_list = true
|
|
break
|
|
end
|
|
end
|
|
if is_in_shiled_list then return false end
|
|
|
|
--判断是否有生活技能配置
|
|
local life_skill_cfg = self:GetPetLifeSkillCfgById(skill_id)
|
|
if not life_skill_cfg then return false end
|
|
|
|
--判断是否激活宠物
|
|
local pet_data = self:GetPetListById(life_skill_cfg.pet_id)
|
|
if not pet_data then return false end
|
|
|
|
--判断宠物星数是否达成激活技能
|
|
return pet_data.pet_star >= life_skill_cfg.active_star
|
|
end
|
|
|
|
function PetModel:AdvicePetLifeSkillActived(pet_id)
|
|
--获取宠物的技能id
|
|
local life_skill_id = 0
|
|
local skill_cfg = self:GetPetSkillCfg(pet_id,1)
|
|
if skill_cfg then
|
|
life_skill_id = skill_cfg.skill_talent_id
|
|
end
|
|
|
|
if self:IsLifeSkillActived(life_skill_id) then
|
|
self:Fire(PetConst.PET_LIFE_SKILL_ACTIVED,life_skill_id)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
---------宠物生活技能---------<<<<<<<
|