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




---------宠物生活技能---------<<<<<<<