yzyCli/u3d/Lua/game/rank/RankModel.lua

RankModel = RankModel or BaseClass(BaseVo, true)
local RankModel = RankModel

RankModel.REQUEST_CCMD_EVENT = "RankModel.REQUEST_CCMD_EVENT"
RankModel.CLICK_SUB_TYPE_ITEM = "RankModel.CLICK_SUB_TYPE_ITEM" -- 点击子类型按钮
RankModel.UPDATE_RANK_CONTENT = "RankModel.UPDATE_RANK_CONTENT" -- 刷新榜单列表界面
RankModel.RANK_LIST_UPDATE_NEXT = "RankModel.RANK_LIST_UPDATE_NEXT" -- 滚动框继续滚动时动态请求榜单数据
RankModel.UPDATE_LIKE_CON = "RankModel.UPDATE_LIKE_CON" -- 刷新点赞栏的状态
RankModel.UPDATE_LIKE_NUM = "RankModel.UPDATE_LIKE_NUM" -- 刷新当前选中角色的点赞数
RankModel.REQUEST_EQUIP_CCMD_EVENT = "RankModel.REQUEST_EQUIP_CCMD_EVENT" -- 查看玩家装备信息
RankModel.UPDATE_EQUIP_INFO = "RankModel.UPDATE_EQUIP_INFO" -- 刷新玩家装备信息
RankModel.UPDATE_WARSOUL_INFO = "RankModel.UPDATE_WARSOUL_INFO" -- 刷新玩家战魂信息

RankModel.CHANGE_RANK_MIAN_TYPE = "RankModel.CHANGE_RANK_MIAN_TYPE" -- 切换跨服排行和本服排行
RankModel.OPEN_RANK_TARGET_VIEW = "RankModel.OPEN_RANK_TARGET_VIEW" -- 打开排行目标奖励界面
RankModel.OPEN_RANK_PROGRESS_VIEW = "RankModel.OPEN_RANK_PROGRESS_VIEW" -- 打开排行前五进度界面
RankModel.UPDATE_CS_ROLE_SHOW = "RankModel.UPDATE_CS_ROLE_SHOW" -- 跨服排行榜请求figure后刷新展示
RankModel.UPDATE_RANK_TARGET_VIEW = "RankModel.UPDATE_RANK_TARGET_VIEW"
RankModel.ANS_UPDATE_RED_DOT = "RankModel.ANS_UPDATE_RED_DOT"
RankModel.UPDATE_RED_DOT = "RankModel.UPDATE_RED_DOT"
RankModel.UPDATE_RANK_PROGRESS_VIEW = "RankModel.UPDATE_RANK_PROGRESS_VIEW"
RankModel.SHOW_CS_OPERATION_VIEW = "RankModel.SHOW_CS_OPERATION_VIEW"
RankModel.UPDATE_MAIN_UI_BTN_RED = "RankModel.UPDATE_MAIN_UI_BTN_RED" -- 主界面入口按钮红点

RankModel.TabId = {
	KfRush_1 = 1, --开服冲榜
	KfRush_2 = 2, --开服冲榜
	KfRush_3 = 3, --开服冲榜
	Power = 4, -- 战力
	Level = 5, -- 等级
	Equip = 6, -- 装备	
	WarSoul = 7, -- 战魂
	Advance = 8, -- 进阶
	AIGirl = 9, -- AI娘
	Fashion = 10, -- 收集	
	Charm = 11, -- 魅力
}

RankModel.CSTabId = {
	Power = 1, -- 战力
	Level = 2, -- 等级
}


RankModel.PageSize = 40
RankModel.PageReqOffSize = 15	--请求数据的相对名次。例如 15 - 5 = 10，显示第10条，就请求 16 到 30条的数据
RankModel.PageSizeMax = 200	--排行榜中最多100条数据

function RankModel:__init()
	RankModel.Instance = self
	self.rank_chat_list = {}--保存聊天item栏需用到的排行列表
	self.rank_equip_list = {}

	self.rank_like_list = {}	--点赞状态

	self.rank_target_data = {}

	self.rank_target_cfg = {}  --排行目标奖励配置

	self.rank_target_red_info = {} --排行目标奖励红点

	self.rank_progress_data = {} --榜单进度数据

	self.rank_warSoul_list = {}


	self:InitRankTargetCfg()

	self:Reset()
end

function RankModel:getInstance()
	if RankModel.Instance == nil then
		RankModel.Instance = RankModel.New()
	end
	return RankModel.Instance
end

--这里是关掉排行榜就要清空的数据
function RankModel:Reset()
	self.is_cs_rank = false --当前是否为跨服排行榜
	self.start = 1 			--列表的开始排名
	self.selectId = 0 		--排行榜类型id(对应Config.ConfigRank.RankTab的id字段)
	self.rank_info = nil	--排行榜信息
	self.curPage = 1		--当前页
	self.maxPage = 0		--最大页数
	self.rank_req_idx = 0 	--当前请求的序号，当刷新这个数据的时候，就开始请求之后的数据
	self.rank_list_sum = 0  --当前排行榜的成员总数
	self.now_equip_suit_id = 6 --当前装备榜选中的套数 ，点击其他玩家查看时需要继承该套数

end

function RankModel:GetAllRedDot(  )
	return self.rank_target_red_info
end

function RankModel:IsNeedRedAll(  )
	for k,v in pairs(Config.ConfigRank.RankTab) do
		self:IsNeedRed(v.id)
	end
end


function RankModel:IsNeedRed(tab_id)
	local bool = false
	local rank_type_list = self:GetRankTargetTabListByTabId(tab_id)
	for k,v in pairs(rank_type_list) do
		if self:IsRankTypeNeedRed(v.rank_type) then
			bool = true
			break
		end
	end
	self.rank_target_red_info[tab_id] = bool
	self:Fire(RankModel.ANS_UPDATE_RED_DOT,tab_id)
end

function RankModel:IsRankTypeNeedRed(rank_type)
	local bool = false
	local rank_cfg = self:GetRankTabDataByType(rank_type)
	if not rank_cfg then return false end
	if not GetModuleIsOpen(rank_cfg.module_id, rank_cfg.sub_id) then return false end
	if self.rank_target_data[rank_type] then
		for i,v in ipairs(self.rank_target_data[rank_type].top_list) do
			if v.award_state == 1 then
				bool = true
				break
			end
		end
	end
	return bool
end

--根据榜单类型获取榜单配置
function RankModel:GetRankTabDataByType(type)
	for k,v in pairs(Config.ConfigRank.RankTab) do
		for kk,vv in pairs(v.sub_tab) do
			if vv.id == type and v.id > 3 then
				return vv
			end
		end
	end
	return nil
end

--初始化排行目标奖励配置
function RankModel:InitRankTargetCfg(  )
	for k,v in pairs(Config.Commonranktargetreward) do
		self.rank_target_cfg[v.type] = self.rank_target_cfg[v.type] or {}
		v.sort_rank = 2
		table.insert(self.rank_target_cfg[v.type],v)
	end
	for k,v in pairs(self.rank_target_cfg) do
		local function onSortFunction(v1, v2)
			return v1.index < v2.index
		end
		table.sort(v, onSortFunction)
	end
end

--根据榜单类型获取目标配置
function RankModel:GetRankTargetCfgByType(type)
	if self.rank_target_cfg[type] then
		return self.rank_target_cfg[type]
	else
		return nil
	end
end

--判断该榜单类型是否开放展示
function RankModel:IsRankTypeOpen(type)
	local tab_id = self:GetTabIdByRankType(type)
	if tab_id ~= 0 then
		return true
	end
	return false
end

--判断该榜单类型属于哪个榜单大类
function RankModel:GetTabIdByRankType(type)
	local tab_id = 0
	for k,v in pairs(Config.ConfigRank.RankTab) do
		for kk,vv in pairs(v.sub_tab) do
			if type == vv.id and v.id > 3 then
				tab_id = v.id
				return tab_id
			end
		end
	end
	return tab_id
end

--根据榜单大类tab_id获取其拥有首度目标的榜单子类型列表
function RankModel:GetRankTargetTabListByTabId(tab_id)
	local list = {}
	local rank_tab_data = nil
	for k,v in pairs(Config.ConfigRank.RankTab) do
		if v.id == tab_id and tab_id > 3 then --前3个页签是冲榜用的，不要检测红点
			rank_tab_data = v
			break
		end
	end
	if rank_tab_data then
		for k,v in pairs(rank_tab_data.sub_tab) do
			if self:GetRankTargetCfgByType(v.id) then
				local temp = {rank_type = v.id, is_history = false}
				table.insert(list,temp)
				--插入一个历史记录栏
				local need_history = false
				for m,n in pairs(Config.ConfigRank.RankTargetNeedHistory) do
					if v.id == n then
						need_history = true
						break
					end
				end
				if need_history then
					local history_temp = {rank_type = v.id*1000, is_history = true}
					table.insert(list,history_temp)--将ranktype乘一千作为历史记录的标签
				end
			end
		end
	end
	return list
end

--根据页签id判断是否有目标奖励配置
function RankModel:IsTabRankTargetCfg(tab_id)
	--前三个tab是给开服冲榜位置预留的，不要显示目标奖励
	if tab_id >= 1 and tab_id <= 3 then return false end
	local rank_tab_data = nil
	for k,v in pairs(Config.ConfigRank.RankTab) do
		if v.id == tab_id then
			rank_tab_data = v
			break
		end
	end
	if not rank_tab_data then return false end
	for k,v in pairs(rank_tab_data.sub_tab) do
		if self:GetRankTargetCfgByType(v.id) then
			return true
		end
	end
	return false
end

--保存首度目标达成信息 22106
-- rank_type               :int32
-- top_list:array{
--     target              :int64
--     award_state         :int8            // 领奖状态 1|可领取 2|已领完
--     score               :int64           // 对应target（等级榜发等级战力榜发战力进阶榜发阶数……）
--     figure              :rec_picture     // 形象信息
-- }
function RankModel:SetRankTargetData(vo)
	local function onSortFunction(v1, v2)
		return v1.target < v2.target
	end
	table.sort(vo.top_list, onSortFunction)
	self.rank_target_data[vo.rank_type] = vo
end

--根据榜单类型获取首度目标达成信息
function RankModel:GetRankTargetData(rank_type)
	return self.rank_target_data[rank_type] and self.rank_target_data[rank_type] or nil
end

--保存榜单进度数据
function RankModel:SetRankProgressData(vo)
	local function onSortFunction(v1, v2)
		return v1.rank < v2.rank
	end
	table.sort(vo.rank_list, onSortFunction)
	self.rank_progress_data[vo.rank_type] = vo.rank_list
end

--获取榜单进度数据
function RankModel:GetRankProgressData(rank_type)
	return self.rank_progress_data[rank_type] and self.rank_progress_data[rank_type] or {}
end


--根据排行榜类型获取基础的排行榜配置
function RankModel:GetRankingCfg(type_id)
	local cfg = Config.Ranking
	return cfg[type_id] or nil
end

function RankModel:GetRankInfo( )
	return self.rank_info or {}
end

function RankModel:SetRankInfo(vo)
	local bool = false
	if self.rank_info == nil  or self.rank_info.rank_type ~= vo.rank_type then		
		self.rank_list_sum = vo.sum	
		local list_size = TableSize(vo.rank_list)		
		self.start = list_size + 1			
		for i= list_size + 1 , self.rank_list_sum do				
			local list = 
			{
				player_id = 0,
				name = "",
				guild_name = "",
				grade_id = 0,
				praise_num = 0,
				sel_combat = 0,
				first_value = 0,
				second_value = 0,
				third_value = 0,
				rank = i,
				turn = 0,
				extra_values = "",
				have_data = true,
			}
			table.insert(vo.rank_list, list)
		end
		self.rank_info = vo		
		bool = true		
	else
		local list_size = TableSize(vo.rank_list)		
		if list_size > 0 then			
			self.rank_info.rank_list = self.rank_info.rank_list or {}
			for i=1, list_size do	
				self.rank_info.rank_list[self.start + i - 1] = vo.rank_list[i]		
			end
			self.start = self.start + list_size
			self.start = self.start < self.rank_list_sum and self.start or self.rank_list_sum			
		end
	end	
	return bool
end

function RankModel:SetCSRankInfo(vo)
	for i,v in ipairs(vo.rank_list) do
		v.vip_flag = v.vip
		v.sup_vip_type = v.sup_vip
	end

	local function onSortFunction(v1, v2)
		return v1.rank < v2.rank
	end
	table.sort(vo.rank_list, onSortFunction)
	table.sort(vo.top_three, onSortFunction)

	local bool = false
	if self.rank_info == nil  or self.rank_info.rank_type ~= vo.rank_type then
		self.rank_list_sum = vo.sum	
		local list_size = TableSize(vo.rank_list)		
		self.start = list_size + 1			
		for i= list_size + 1 , self.rank_list_sum do				
			local list = 
			{
				player_id = 0,
				name = "",
				guild_name = "",
				grade_id = 0,
				praise_num = 0,
				sel_combat = 0,
				first_value = 0,
				second_value = 0,
				third_value = 0,
				rank = i,
				turn = 0,
				extra_values = "",
				have_data = true,
			}
			table.insert(vo.rank_list, list)
		end
		self.rank_info = vo		
		bool = true		
	else
		local list_size = TableSize(vo.rank_list)		
		if list_size > 0 then			
			self.rank_info.rank_list = self.rank_info.rank_list or {}
			for i=1, list_size do	
				self.rank_info.rank_list[self.start + i - 1] = vo.rank_list[i]		
			end
			self.start = self.start + list_size
			self.start = self.start < self.rank_list_sum and self.start or self.rank_list_sum			
		end
	end
	return bool
end

function RankModel:GetRankItemInfo(rank_type, index)
	local t = nil
	if self.rank_info and self.rank_info.rank_list and rank_type == self.rank_info.rank_type then
		t = self.rank_info.rank_list[index]
	end
	return t
end

--获取榜单子类型列表
function RankModel:GetRankSubTypeData(is_cs_rank)
	local final_rank_tab_data = {}
	if not is_cs_rank then
		final_rank_tab_data = self:GetFinalRankTabData()
	end
	local RankTab = {}
	if is_cs_rank then
		RankTab = DeepCopy(Config.ConfigRank.CSRankTab)
	else
		RankTab = DeepCopy(Config.ConfigRank.RankTab)
	end
	local temp_tab = {}
	for i,v in ipairs(RankTab) do
		if not GetModuleIsOpen(v.module_id, v.sub_id) then
			RankTab[i] = nil 
		elseif not is_cs_rank and final_rank_tab_data[v.id] and final_rank_tab_data[v.id].open_lv > RoleManager.Instance.mainRoleInfo.level then
			RankTab[i] = nil 
		else
			if v.sub_tab then
				for i=#v.sub_tab,1,-1 do
					if not GetModuleIsOpen(v.sub_tab[i].module_id, v.sub_tab[i].sub_id) then
						table.remove(v.sub_tab,i)
					end
				end
				if #v.sub_tab>0 then
					temp_tab[v.id] = v
				end
			end
		end
	end
	return temp_tab
end

function RankModel:GetFinalRankTabData(  )
	--开服前七天需要加首位加上冲榜的榜
	local final_rank_tab_data = DeepCopy(RankView.TabData)
	local rush_rank_data = self:GetTodayKfRushTabList()

	final_rank_tab_data[RankModel.TabId.KfRush_1].open_lv = 9999
	final_rank_tab_data[RankModel.TabId.KfRush_2].open_lv = 9999
	final_rank_tab_data[RankModel.TabId.KfRush_3].open_lv = 9999

	if #rush_rank_data == 0 then

	else
		for i=1,#rush_rank_data do
			local key = RankModel.TabId.KfRush_1
			if i == 1 then
				key = RankModel.TabId.KfRush_1
			elseif i == 2 then
				key = RankModel.TabId.KfRush_2
			elseif i == 3 then
				key = RankModel.TabId.KfRush_3
			end
			final_rank_tab_data[key].open_lv = 0
			if rush_rank_data[i].id == 1 then
				final_rank_tab_data[key].name = "座驾"
				Config.ConfigRank.RankTab[key].name = "座驾"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1461
							n.name = "座驾"
							n.sub_type_tab = "horse"
						end
					end
				end
			elseif rush_rank_data[i].id == 2 then
				final_rank_tab_data[key].name = "炫翼"
				Config.ConfigRank.RankTab[key].name = "炫翼"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1462
							n.name = "炫翼"
							n.sub_type_tab = "wing"
						end
					end
				end
			elseif rush_rank_data[i].id == 3 then
				final_rank_tab_data[key].name = "宝具"
				Config.ConfigRank.RankTab[key].name = "宝具"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1463
							n.name = "宝具"
							n.sub_type_tab = "pearl"
						end
					end
				end
			elseif rush_rank_data[i].id == 4 then
				final_rank_tab_data[key].name = "武器"
				Config.ConfigRank.RankTab[key].name = "武器"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1464
							n.name = "武器"
							n.sub_type_tab = "weapon"
						end
					end
				end
			elseif rush_rank_data[i].id == 5 then
				final_rank_tab_data[key].name = "AI娘"
				Config.ConfigRank.RankTab[key].name = "AI娘"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1465
							n.name = "AI娘"
							n.sub_type_tab = "jarvis"
						end
					end
				end
			elseif rush_rank_data[i].id == 6 then
				final_rank_tab_data[key].name = "磁炮"
				Config.ConfigRank.RankTab[key].name = "磁炮"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1466
							n.name = "磁炮"
							n.sub_type_tab = "gun"
						end
					end
				end
			elseif rush_rank_data[i].id == 7 then
				final_rank_tab_data[key].name = "星翼"
				Config.ConfigRank.RankTab[key].name = "星翼"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1467
							n.name = "星翼"
							n.sub_type_tab = "cloud"
						end
					end
				end
			elseif rush_rank_data[i].id == 8 then
				final_rank_tab_data[key].name = "幻甲"
				Config.ConfigRank.RankTab[key].name = "幻甲"
				for k,v in pairs(Config.ConfigRank.RankTab) do
					if v.id == key then
						for m,n in pairs(v.sub_tab) do
							n.id = 1468
							n.name = "幻甲"
							n.sub_type_tab = "armour"
						end
					end
				end
			end
		end
	end	
	return final_rank_tab_data
end


--保存该类型排行榜的点赞状态 22103
function RankModel:SetRankLikeState(vo)
	-- self.rank_like_list[vo.rank_type] = vo.state == 0 and true or false
	self.rank_like_list[vo.rank_type] = vo
end

--根据排行榜类型获取点赞状态
function RankModel:GetRankLikeStateByTypeId(type_id, role_id)
	-- return false
	if self.rank_like_list[type_id] then
		if self.rank_like_list[type_id].role_id == role_id and self.rank_like_list[type_id].state == 1 then
			return true
		end
	end
	return false
end

--刷新某个类型榜单下玩家的点赞数 22104
function RankModel:RefreshRankRoleLikeNum(vo)
	if self.rank_info and self.rank_info.rank_list and vo.rank_type == self.rank_info.rank_type then
		for k,v in pairs(self.rank_info.rank_list) do
			if v.role_id == vo.role_id then
				v.praise_num = vo.praise_num
				return 
			end
		end
	end
end


-----聊天模块需用到以下部分
function RankModel:GetRankChatList( )
	return self.rank_chat_list
end

function RankModel:SetRankChatList(vo)

	local RankTab = DeepCopy(Config.ConfigRank.RankTab)
	local rank_type_power = RankTab[RankModel.TabId.Power].sub_tab[1].id
	local rank_type_level = RankTab[RankModel.TabId.Level].sub_tab[1].id

	if vo.rank_type and vo.rank_type == rank_type_power then
		self.rank_chat_list.fight_list = vo.rank_list or {}
	elseif vo.rank_type and vo.rank_type == rank_type_level then 
		self.rank_chat_list.level_list = vo.rank_list or {}
	end

	--print("=============>>> YiRan:RankModel [start:186] self.rank_chat_list ------------------------------------------")
	--PrintTable(self.rank_chat_list)
	--print("=============>>> YiRan:RankModel [end] ------------------------------------------")
end

function RankModel:SendForRankChat( )

	local RankTab = DeepCopy(Config.ConfigRank.RankTab)
	local rank_type_power = RankTab[RankModel.TabId.Power].sub_tab[1].id
	local rank_type_level = RankTab[RankModel.TabId.Level].sub_tab[1].id

	RankModel:getInstance():Fire(RankModel.REQUEST_CCMD_EVENT,22105,rank_type_power,1,10)
	RankModel:getInstance():Fire(RankModel.REQUEST_CCMD_EVENT,22105,rank_type_level,1,10)
end


------------------------------------------------------------------------------------------------------------------>>>>
--更新当前穿着的装备列表
function RankModel:UpdateEquipList(role_id, list, power)
    if not list or not role_id then
        print("是不是数据出现了问题？15017:", list)
        return
    end

    if self.rank_equip_list and self.rank_equip_list[role_id] then
    	RankModel:getInstance():Fire(RankModel.UPDATE_EQUIP_INFO,role_id)
    	return    	
    end    

    self.rank_equip_list[role_id] = {}
    local goods_model = GoodsModel:getInstance()
    local equip_model = EquipModel:getInstance()
    local count = #list
    local vo = nil
    for i = 1, count do
        vo = list[i]
        local equip_cfg = equip_model:GetEquipmentCfg(vo.type_id)
        if equip_cfg then
            local pos = equip_cfg.equip_type
            local series = equip_cfg.series
            vo.equip_suit_type = pos
            goods_model:SetBaseInfo(vo)
            vo.power = power
            if not self.rank_equip_list[role_id][series] then
               self.rank_equip_list[role_id][series] = {}
            end
            self.rank_equip_list[role_id][series][equip_cfg.equip_type] = vo
        end
    end    
    RankModel:getInstance():Fire(RankModel.UPDATE_EQUIP_INFO,role_id)
end

function RankModel:ClearRoleEquipList()	
	self.rank_equip_list = {}
end

function RankModel:GetEquipList(role_id, suit_id)
	if not role_id or not suit_id then return {} end
	return (self.rank_equip_list and self.rank_equip_list[role_id] and self.rank_equip_list[role_id][suit_id]) and self.rank_equip_list[role_id][suit_id] or {}
end

function RankModel:GetAllEquipList(role_id)
	if not role_id then return {} end
	return (self.rank_equip_list and self.rank_equip_list[role_id]) and self.rank_equip_list[role_id] or {}
end

function RankModel:GetMateShipData( role_id )
	self.mate_ship_data = self.mate_ship_data or {}
	return self.mate_ship_data[role_id]
end

function RankModel:SetMateShipData( role_id,mate_stage,mate_star )
	self.mate_ship_data = self.mate_ship_data or {}
	self.mate_ship_data[role_id] = {mate_stage = mate_stage,mate_star = mate_star}
end
------------------------------------------------------------------------------------------------------------------<<<<



------------------------------------------------------------------------------------------------------------------>>>>
--更新当前的战魂装备列表
function RankModel:UpdateWarSoulList(vo)
	if not vo then return end
	if not vo.equip_list then return end

	local role_id = vo.player_id

    if self.rank_warSoul_list and self.rank_warSoul_list[role_id] then
    	RankModel:getInstance():Fire(RankModel.UPDATE_WARSOUL_INFO,role_id)
    	return
    end

    self.rank_warSoul_list[role_id] = vo

    local count = #vo.equip_list
    local data = nil
    for i = 1, count do
    	data = vo.equip_list[i]
    	local warSoul_cfg = WarSoulModel:getInstance():GetWarSoulCfg(data.type_id)
    	data.warSoul_cfg = warSoul_cfg
    	data.pos = 20
    	data.bind = 1
    	data.expire_time = 0
    	data.goods_num = 1
    	data.convert_time = 0
    end
    RankModel:getInstance():Fire(RankModel.UPDATE_WARSOUL_INFO,role_id)
end

function RankModel:ClearRoleWarSoulList()	
	self.rank_warSoul_list = {}
end

function RankModel:GetWarSoulList(role_id)
	if not role_id then return {} end
	return (self.rank_warSoul_list and self.rank_warSoul_list[role_id]) and self.rank_warSoul_list[role_id] or {}
end

function RankModel:GetWarSoulDataByCell(role_id,cell)
	if not role_id or not cell then return nil end
	if self.rank_warSoul_list and self.rank_warSoul_list[role_id] then
		for k,v in pairs(self.rank_warSoul_list[role_id].equip_list) do
			if v.cell == cell then
				return v
			end
		end
	end
	return nil
end
------------------------------------------------------------------------------------------------------------------<<<<\

--获取今天的开服冲榜项
function RankModel:GetTodayKfRushTabList(  )
	local tab_list = {}
	local openDay = ServerTimeModel:getInstance():GetOpenServerDay()
	for k,v in pairs(Config.Rushrank) do
		if v.start_day == openDay and v.id <= 8 then
			table.insert(tab_list,v)
		end
	end
	return tab_list
end
--判断今天开服冲榜有几项
function RankModel:GetKfRushTabNum(  )
	local tab_list = {}
	local openDay = ServerTimeModel:getInstance():GetOpenServerDay()
	for k,v in pairs(Config.Rushrank) do
		if v.start_day == openDay and v.id <= 8 then
			table.insert(tab_list,v)
		end
	end
	return #tab_list
end