Вы не можете выбрать более 25 тем
Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
881 строки
31 KiB
881 строки
31 KiB
AchieveModel = AchieveModel or BaseClass(BaseVo)
|
|
|
|
AchieveModel.REQUEST_CCMD_EVENT = "AchieveModel.REQUEST_CCMD_EVENT" --请求协议
|
|
-- AchieveModel.GET_NEW_ACHV = "AchieveModel.GET_NEW_ACHV" --有新成就可以领取
|
|
AchieveModel.UPDATE_ACHV_OVER_STAR = "AchieveModel.UPDATE_ACHV_OVER_STAR" --更新成就总览星数
|
|
-- AchieveModel.REMOVE_TIPS_VIEW = "AchieveModel.REMOVE_TIPS_VIEW" --移除成就弹窗
|
|
|
|
AchieveModel.UPDATE_ACHV_COMPLELE = "AchieveModel.UPDATE_ACHV_COMPLELE" --成就完成度的刷新
|
|
AchieveModel.SHOW_GET_ALL_REDDOT = "AchieveModel.SHOW_GET_ALL_REDDOT" --刷新一键领取的红点
|
|
AchieveModel.JINGOODS_FLY_EFFECT = "AchieveModel.JINGOODS_FLY_EFFECT" --成就界面的 显示红钻获得时的动画
|
|
|
|
------明日新增
|
|
AchieveModel.UPDATE_MAIN_TYPE_PROGRESS = "AchieveModel.UPDATE_MAIN_TYPE_PROGRESS" -- 更新成就大类进度信息
|
|
-- AchieveModel.RECEIVE_CHAPTER_REWARD_SUCCEED = "AchieveModel.RECEIVE_CHAPTER_REWARD_SUCCEED" -- 成就章节奖励领取成功刷新事件
|
|
AchieveModel.UPDATE_ACHIEVE_DATA = "AchieveModel.UPDATE_ACHIEVE_DATA" -- 根据成就章节更新成就小类item
|
|
AchieveModel.OPEN_ACHIEVE_TIPS_VIEW = "AchieveModel.OPEN_ACHIEVE_TIPS_VIEW" -- 新版成就完成弹窗事件
|
|
AchieveModel.UPDATE_ACHIEVE_LV_DATA = "AchieveModel.UPDATE_ACHIEVE_LV_DATA" -- 更新成就等级经验数据
|
|
AchieveModel.UPDATE_PRIVILEGE_REWARD_STATUS = "AchieveModel.UPDATE_PRIVILEGE_REWARD_STATUS" -- 更新成就特权奖励状态
|
|
AchieveModel.UPDATE_ACHIEVE_RED = "AchieveModel.UPDATE_ACHIEVE_RED" -- 更新成就红点
|
|
-- AchieveModel.OPEN_ACHIEVE_MAIN_VIEW = "AchieveModel.OPEN_ACHIEVE_MAIN_VIEW" -- 打开成就主界面
|
|
AchieveModel.UPDATE_EXCHANGE_DATA = "AchieveModel.UPDATE_EXCHANGE_DATA" -- 更新特权交易券兑换情况数据
|
|
AchieveModel.OPEN_GUILD_SPEED_TIP_VIEW = "AchieveModel.OPEN_GUILD_SPEED_TIP_VIEW" -- 打开公会竞速称号变更tip界面
|
|
AchieveModel.OPEN_ACHIEVE_PRIVILEGE_VIEW = "AchieveModel.OPEN_ACHIEVE_PRIVILEGE_VIEW" -- 打开成就特权
|
|
AchieveModel.UPDATE_DAILY_RED = "AchieveModel.UPDATE_DAILY_RED" -- 通知刷新日常界面红点
|
|
AchieveModel.UPDATE_ACHIEVE_TASK = "AchieveModel.UPDATE_ACHIEVE_TASK" -- 通知刷新任务列表
|
|
AchieveModel.UPDATE_BASE_VIEW = "AchieveModel.UPDATE_BASE_VIEW" -- 通知成就界面
|
|
|
|
|
|
-- 成就小类排序权值，由成就的完成状态决定
|
|
AchieveModel.StatusSortWeight = {
|
|
[0] = 2, -- 未完成
|
|
[1] = 1, -- 可领取
|
|
[2] = 3, -- 已领取
|
|
}
|
|
|
|
-- 成就红点类型
|
|
AchieveModelRedType = {
|
|
-- MainType = 1, -- 章节已完成
|
|
Achieve = 2, -- 成就已完成
|
|
Privilege = 3, -- 特权奖励
|
|
Weekly = 4, -- 特权每周奖励
|
|
Exchange = 5, -- 交易券兑换红点
|
|
}
|
|
|
|
AchieveModel.AchieveMainType = {
|
|
[1] = 1, -- 养成
|
|
[2] = 2, -- 活跃
|
|
[3] = 3, -- 挑战
|
|
[4] = 4, -- 收集
|
|
}
|
|
|
|
AchieveModel.SpecialOpenFun = {
|
|
[405] = true,
|
|
}
|
|
|
|
local table_insert = table.insert
|
|
|
|
function AchieveModel:__init()
|
|
self.Instance = self
|
|
|
|
self.delay_open_tips = false
|
|
---------------------------------
|
|
-- 配置缓存
|
|
self.achieve_cfg_cache = nil -- 成就内容缓存
|
|
self.achi_privilege_cache = nil -- 成就特权缓存
|
|
-- 协议相关
|
|
self.login_achi_req = false -- 登录首次请求全体协议进度
|
|
self.chapter_progress_data = {} -- 成就章节进度信息
|
|
self.achieve_data = {} -- 成就列表
|
|
self.tip_achieve_data = {} --AchieveTipsView 的所有tip的信息
|
|
self.achieve_lv_data = nil -- 成就等级经验数据
|
|
self.privilege_reward_status = {} -- 成就特权对应的奖励的领取情况
|
|
self.achieve_exchange_data = {} -- 成就特权交易券兑换情况
|
|
self.achieve_weekly_reward_status = 0 -- 成就特权周奖励领取状态 0-未满足条件 1-可领取 2-已领取
|
|
self.exchange_login_red = true -- 首次登录的交易券红点
|
|
self.achv_exhcange_btn_red = false -- 成就交易券兑换按钮红点
|
|
-- 红点相关
|
|
self.achieve_red_cache = {} -- 成就红点缓存 格式 self.achieve_red_cache[red_type][index] = true/false,成就类index为章节，特权为特权对应的成就等级
|
|
self.achieve_red_data = {}
|
|
---------------------------------
|
|
self.QUICK_GET_LEVEL = tonumber(Config.Achievementkv["auto_receive_lv"].value) -- 可以快捷领取的最大等级 小于等于这个等级可以直接领取 大于这个等级改为跳转
|
|
self.total_achieve_cache_red = false -- 总红点缓存
|
|
self.achieve_max_count_cache = {} -- 成就最大数目缓存
|
|
self.achieve_finsh_cache = {} -- 记录所有已经完成的成就id
|
|
self.achieve_can_get_list = {} -- 记录所有可以领奖励的成就id
|
|
self.recommend_list = {} -- 记录推荐任务列表
|
|
self:InitAchieveCache( )
|
|
end
|
|
|
|
function AchieveModel:getInstance()
|
|
if self.Instance == nil then
|
|
self.Instance = AchieveModel.New(
|
|
)
|
|
end
|
|
return self.Instance
|
|
end
|
|
|
|
-- 创建成就节点缓存
|
|
function AchieveModel:InitAchieveCache( )
|
|
if not self.achieve_cfg_cache then
|
|
self.achieve_cfg_cache = {}
|
|
self.achieve_max_count_cache = {} -- 记录了大类的成就总数
|
|
self.achieve_task_show_cache = {} -- 记录在任务栏显示的推荐成就
|
|
for k, v in pairs(Config.Achievementid) do
|
|
self.achieve_cfg_cache[v.type] = self.achieve_cfg_cache[v.type] or {}
|
|
self.achieve_cfg_cache[v.type][v.sub_type] = self.achieve_cfg_cache[v.type][v.sub_type] or {}
|
|
self.achieve_cfg_cache[v.type][v.sub_type][v.id] = v
|
|
-- table_insert(self.achieve_cfg_cache[v.type][v.sub_type], v)
|
|
-- 计总数
|
|
self.achieve_max_count_cache[v.type] = self.achieve_max_count_cache[v.type] or 0
|
|
self.achieve_max_count_cache[v.type] = self.achieve_max_count_cache[v.type] + 1
|
|
-- 记录推荐任务
|
|
if v.task_position ~= 0 then
|
|
self.achieve_task_show_cache[v.task_position] = self.achieve_task_show_cache[v.task_position] or {}
|
|
self.achieve_task_show_cache[v.task_position][v.task_sequence] = v
|
|
end
|
|
end
|
|
-- 插入一个字段记录每个大类的每个小类的起始成就id
|
|
for main_type, v in pairs(self.achieve_cfg_cache) do
|
|
for sub_type, vv in pairs(v) do
|
|
local little_id = 99999999
|
|
for id, vvv in pairs(vv) do
|
|
if little_id > vvv.id then
|
|
little_id = vvv.id
|
|
end
|
|
end
|
|
vv.first_id = little_id
|
|
end
|
|
end
|
|
-- 成就同类型排序
|
|
-- for k,v in pairs(self.achieve_cfg_cache) do
|
|
-- for kk,vv in pairs(v) do
|
|
-- local sort_func = function ( a, b )
|
|
-- return a.id < b.id
|
|
-- end
|
|
-- table.sort(vv, sort_func)
|
|
-- end
|
|
-- end
|
|
-- PrintTable(self.achieve_task_show_cache)
|
|
end
|
|
end
|
|
|
|
function AchieveModel:GetAchieveMaxCount( main_type )
|
|
if not main_type then return end
|
|
if not self.achieve_max_count_cache[main_type] then
|
|
self:InitAchieveCache()
|
|
end
|
|
return self.achieve_max_count_cache[main_type]
|
|
end
|
|
-- 创建特权节点缓存
|
|
function AchieveModel:InitAchievePrivilegeCache( )
|
|
if not self.achi_privilege_cache then
|
|
self.achi_privilege_cache = {}
|
|
for k, v in pairs(Config.Achievementstageprivilege) do
|
|
self.achi_privilege_cache[#self.achi_privilege_cache+1] = v
|
|
end
|
|
end
|
|
end
|
|
|
|
-- 设置成就大类后端数据
|
|
function AchieveModel:SetMainTypeProgress( list )
|
|
if not list then return end
|
|
self.type_progress_data = self.type_progress_data or {}
|
|
for k, v in ipairs(list) do
|
|
self.type_progress_data[v.type] = v
|
|
end
|
|
-- 填充一下空数据
|
|
for k,v in pairs(AchieveModel.AchieveMainType) do
|
|
if not self.type_progress_data[v] then
|
|
self.type_progress_data[v] = {
|
|
type = v,
|
|
count = 0,
|
|
}
|
|
end
|
|
end
|
|
-- 如果是首次登录，则需要获取全体进度的协议信息（待优化，这个遍历发送请求真的是太蛋疼了）
|
|
if not self.login_achi_req then
|
|
local function delay_method( )
|
|
for k, v in pairs(AchieveModel.AchieveMainType) do
|
|
self:Fire(AchieveModel.REQUEST_CCMD_EVENT, 40902, v)
|
|
end
|
|
self.login_achi_req = true
|
|
end
|
|
setTimeout(delay_method, 3)
|
|
end
|
|
end
|
|
|
|
-- 获取大类进度数据
|
|
function AchieveModel:GetMainTypeProgressData()
|
|
return self.type_progress_data or {}
|
|
end
|
|
|
|
-- -- 成就协议相关逻辑start
|
|
-- -- 缓存成就章节进度信息 40900
|
|
-- function AchieveModel:SetChapterProgress(vo)
|
|
-- if not vo then return end
|
|
-- self.chapter_progress_data = self.chapter_progress_data or {}
|
|
-- for k, v in ipairs(vo.detailed_list) do
|
|
-- self.chapter_progress_data[v.category] = v
|
|
-- end
|
|
-- -- 如果是首次登录，则需要获取全体进度的协议信息（待优化，这个遍历发送请求真的是太蛋疼了）
|
|
-- if not self.login_achi_req then
|
|
-- local function delay_method( )
|
|
-- for k, v in pairs(Config.Achievementcategoryreward) do
|
|
-- self:Fire(AchieveModel.REQUEST_CCMD_EVENT, 40902, v.category)
|
|
-- end
|
|
-- self.login_achi_req = true
|
|
-- end
|
|
-- setTimeout(delay_method, 3)
|
|
-- end
|
|
-- end
|
|
|
|
--[[-- 获取成就界面页签展示所需的章节进度信息,避免跳章节的问题,同时需要对章节进行升序排序
|
|
function AchieveModel:GetChapterProgressTabData(add_total_tab)
|
|
local tb = {}
|
|
local category_progress
|
|
for k, v in pairs(Config.Achievementcategoryreward) do
|
|
-- cfg = DeepCopy(v)
|
|
-- category_progress = self:GetTargetChapterProgress(v.category)
|
|
-- cfg.cur_count = category_progress.count or 0
|
|
-- cfg.status = category_progress.status or 0
|
|
tb[#tb+1] = v
|
|
end
|
|
local sort_func = function ( a, b )
|
|
return a.category < b.category
|
|
end
|
|
table.sort(tb, sort_func)
|
|
-- 需要添加总览页签按钮
|
|
if add_total_tab then
|
|
local total_tab = {
|
|
name = "成就总览"
|
|
}
|
|
table.insert(tb, 1, total_tab)
|
|
end
|
|
return tb
|
|
end--]]
|
|
|
|
-- -- 根据成就章节直接查找章节整体进度数据
|
|
-- function AchieveModel:GetTargetChapterProgress(category)
|
|
-- if category then
|
|
-- return self.chapter_progress_data[category] or {}
|
|
-- else
|
|
-- return self.chapter_progress_data
|
|
-- end
|
|
-- end
|
|
|
|
-- -- 领取成就章节奖励成功后，前端刷新奖励领取标识并刷新界面 40901
|
|
-- function AchieveModel:UpdateChapterRewardStatus(category)
|
|
-- if category and self.chapter_progress_data[category] then
|
|
-- self.chapter_progress_data[category].status = 2 -- 2为已领取
|
|
-- end
|
|
-- end
|
|
|
|
-- 获取成就列表 40902
|
|
function AchieveModel:SetAchieveData(vo)
|
|
self.achieve_data[vo.type] = {}
|
|
for k, v in ipairs(vo.list) do
|
|
v.sort_weight = AchieveModel.StatusSortWeight[v.status]
|
|
self.achieve_data[vo.type][v.sub_type] = v
|
|
self.achieve_data[vo.type][v.sub_type].type = vo.type
|
|
self:RecordAchieveFinsh(v)
|
|
end
|
|
self:UpdateRecommendAchiList( true )
|
|
end
|
|
|
|
function AchieveModel:GetAchieveData(main_type)
|
|
return main_type and self.achieve_data[main_type] or nil
|
|
end
|
|
|
|
-- 通过大类获取成就信息
|
|
function AchieveModel:GetAchieveDataByMainType( main_type )
|
|
if not main_type then return end
|
|
local tb = {}
|
|
if not self.achieve_cfg_cache then
|
|
self:InitAchieveCache()
|
|
end
|
|
for k, v in pairs(self.achieve_cfg_cache[main_type]) do
|
|
-- 拿一下后端数据
|
|
local first_data = v[v.first_id] -- 这个成就的起始数据
|
|
local achieve_data = self:GetTargetAchieveData(first_data.type, first_data.sub_type)
|
|
|
|
-- 有后端数据就查进度
|
|
if achieve_data and achieve_data.id then
|
|
for kk, vv in pairs(v) do
|
|
if kk ~= "first_id" and achieve_data.id == vv.id then
|
|
local temp = vv
|
|
-- local temp = DeepCopy(vv)
|
|
temp.progress = achieve_data.progress or 0
|
|
temp.status = achieve_data.status or 0
|
|
temp.sort_weight = achieve_data.sort_weight or AchieveModel.StatusSortWeight[temp.status]
|
|
tb[#tb+1] = temp
|
|
break
|
|
end
|
|
end
|
|
else
|
|
local temp = first_data
|
|
temp.progress = 0
|
|
temp.status = 0
|
|
temp.sort_weight = AchieveModel.StatusSortWeight[temp.status]
|
|
tb[#tb+1] = temp
|
|
end
|
|
end
|
|
self:SortAchieveData(tb)
|
|
return tb
|
|
end
|
|
|
|
--[[-- 获取成就章节中的成就节点数据(等配置,改为读取配置形式)
|
|
function AchieveModel:GetAchieveDataByCategory(category)
|
|
if not category then return nil end
|
|
local tb = {}
|
|
local achieve_data
|
|
if not self.achieve_cfg_cache then
|
|
self:InitAchieveCache()
|
|
end
|
|
for k, v in pairs(self.achieve_cfg_cache[category]) do
|
|
if v.category == category then
|
|
achieve_data = self:GetTargetAchieveData(v.category, v.sub_category)
|
|
v.progress = achieve_data.progress or 0
|
|
v.status = achieve_data.status or 0
|
|
v.sort_weight = achieve_data.sort_weight or AchieveModel.StatusSortWeight[v.status]
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
self:SortAchieveData(tb)
|
|
return tb
|
|
end--]]
|
|
|
|
|
|
-- 根据成就章节和小类直接查找成就进度
|
|
function AchieveModel:GetTargetAchieveData(main_type, sub_type)
|
|
return self.achieve_data[main_type] and self.achieve_data[main_type][sub_type] or {}
|
|
end
|
|
|
|
-- 领取成就奖励后，更新成就状态 40903
|
|
function AchieveModel:UpdateAchieveStatus(vo)
|
|
if not vo then return end
|
|
self.achieve_data[vo.type] = self.achieve_data[vo.type] or {}
|
|
self.achieve_data[vo.type][vo.sub_type] = self.achieve_data[vo.type][vo.sub_type] or {}
|
|
local cfg = self.achieve_cfg_cache[vo.type][vo.sub_type][vo.id]
|
|
local need_anim = false
|
|
if cfg.next_id and cfg.next_id ~= 0 then -- 有下一个任务 后端会发04协议刷新 这里就不刷了
|
|
self.achieve_data[vo.type][vo.sub_type] = {
|
|
type = vo.type,
|
|
sub_type = vo.sub_type,
|
|
id = cfg.next_id,
|
|
status = 0,
|
|
progress = 0,
|
|
sort_weight = AchieveModel.StatusSortWeight[0],
|
|
}
|
|
else -- 没下一个任务了 所以后端不会发04过来刷新 所以得刷新界面
|
|
self.achieve_data[vo.type][vo.sub_type].status = 2
|
|
self.achieve_data[vo.type][vo.sub_type].sort_weight = AchieveModel.StatusSortWeight[2]
|
|
need_anim = true -- 如果有任务完成了全部系列 需要动画
|
|
self:Fire(AchieveModel.UPDATE_ACHIEVE_DATA, vo.type, need_anim)
|
|
end
|
|
self:RecordAchieveFinsh(self.achieve_data[vo.type][vo.sub_type])
|
|
self:UpdateRecommendAchiList( true )
|
|
end
|
|
|
|
-- 给成就章节中的成就小类排序
|
|
function AchieveModel:SortAchieveData(list)
|
|
local sort_func = function ( a, b )
|
|
if a.status == b.status then
|
|
local a_seq_cfg = Config.Achievementseq[a.type .. "@" .. a.sub_type]
|
|
local b_seq_cfg = Config.Achievementseq[b.type .. "@" .. b.sub_type]
|
|
if a_seq_cfg and b_seq_cfg then -- 排序表有数据就按排序表 排序
|
|
return a_seq_cfg.seq < b_seq_cfg.seq
|
|
else -- 否则按子类排
|
|
return a.sub_type < b.sub_type
|
|
end
|
|
else
|
|
return a.sort_weight < b.sort_weight
|
|
end
|
|
end
|
|
table.sort(list, sort_func)
|
|
end
|
|
|
|
-- 更新成就信息 40904
|
|
function AchieveModel:UpdateAchieveData(list)
|
|
if not list then return end
|
|
for k, v in ipairs(list) do
|
|
self.achieve_data[v.type] = self.achieve_data[v.type] or {}
|
|
self.achieve_data[v.type][v.sub_type] = self.achieve_data[v.type][v.sub_type] or {}
|
|
|
|
self.achieve_data[v.type][v.sub_type].status = v.status
|
|
self.achieve_data[v.type][v.sub_type].id = v.id
|
|
self.achieve_data[v.type][v.sub_type].progress = v.progress
|
|
self.achieve_data[v.type][v.sub_type].sort_weight = AchieveModel.StatusSortWeight[v.status]
|
|
-- 更新已完成成就缓存
|
|
self:RecordAchieveFinsh(self.achieve_data[v.type][v.sub_type])
|
|
end
|
|
self:UpdateRecommendAchiList( )
|
|
end
|
|
|
|
-- 更新对获得新的成就的数据的存储,并根据情况弹出提示界面 is_chapter:是否是章节奖励 40904 40905
|
|
function AchieveModel:SetAchieveTipData(data_list, is_chapter)
|
|
if not data_list then return end
|
|
local need_tips_view = false
|
|
for i, data in ipairs(data_list) do
|
|
if data.status == 1 then -- 出现已完成的成就就弹出提示界面
|
|
local vo = {data = data, is_chapter = is_chapter}
|
|
table_insert(self.tip_achieve_data, vo)
|
|
need_tips_view = true
|
|
end
|
|
end
|
|
if need_tips_view then
|
|
self:Fire(AchieveModel.OPEN_ACHIEVE_TIPS_VIEW, true)
|
|
end
|
|
end
|
|
|
|
-- 直接从缓存中推出一个成就
|
|
function AchieveModel:GetAchieveTipData()
|
|
if self.tip_achieve_data and self.tip_achieve_data[1] then
|
|
return table.remove(self.tip_achieve_data, 1)
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
function AchieveModel:RemoveAchieveTipData(not_remove)
|
|
if not not_remove and #self.tip_achieve_data > 0 then
|
|
table.remove(self.tip_achieve_data, 1)
|
|
end
|
|
end
|
|
|
|
-- -- 更新章节进度信息 40905
|
|
-- function AchieveModel:UpdateMainTypeProgress(list)
|
|
-- if not list then return end
|
|
-- for k, v in ipairs(list) do
|
|
-- self.chapter_progress_data[v.type] = v
|
|
-- end
|
|
-- end
|
|
|
|
-- 获得成就等级经验数据 40906
|
|
function AchieveModel:SetAchieveLvData(vo)
|
|
self.achieve_lv_data = vo
|
|
end
|
|
function AchieveModel:GetAchieveLvData( )
|
|
return self.achieve_lv_data or {}
|
|
end
|
|
|
|
-- 设置成就等级特权信息 40907
|
|
function AchieveModel:SetAchievePrivilegeStatus(vo)
|
|
if not vo then return end
|
|
for k, v in ipairs(vo.detial_list) do
|
|
-- 这里的键值用的每个特权对应的那个等级，方便在特权节点那边获取数据
|
|
self.privilege_reward_status[v.lv] = v
|
|
end
|
|
end
|
|
function AchieveModel:GetAchievePrivilegeStatus(privilege_lv)
|
|
return self.privilege_reward_status[privilege_lv] or {}
|
|
end
|
|
-- 获取成就特权按钮数据(需等特权配置)
|
|
function AchieveModel:GetAchievePrivilegeTabData( )
|
|
if not self.achi_privilege_cache then
|
|
self:InitAchievePrivilegeCache()
|
|
local sort_func = function ( a, b )
|
|
return a.stage < b.stage
|
|
end
|
|
table.sort(self.achi_privilege_cache, sort_func)
|
|
end
|
|
return self.achi_privilege_cache
|
|
end
|
|
|
|
-- 更新成就特权奖励领取状态 40908
|
|
function AchieveModel:UpdateAchievePrivilegeStatus(vo)
|
|
if not vo then return end
|
|
self.privilege_reward_status[vo.lv] = self.privilege_reward_status[vo.lv] or {}
|
|
|
|
self.privilege_reward_status[vo.lv] = vo
|
|
end
|
|
|
|
-- 获取交易券兑换情况 40910 40911
|
|
function AchieveModel:SetAchieveExchangeData(vo)
|
|
self.achieve_exchange_data.now_count = vo.now_count
|
|
self.achieve_exchange_data.max_count = vo.max_count
|
|
end
|
|
function AchieveModel:GetAchieveExchangeData( )
|
|
return self.achieve_exchange_data
|
|
end
|
|
|
|
-- 获取/领取周固定奖励 40912
|
|
function AchieveModel:SetWeeklyPrivilegeRewardStatus(vo)
|
|
self.achieve_weekly_reward_status = vo.status
|
|
end
|
|
function AchieveModel:GetWeeklyPrivilegeRewardStatus( )
|
|
return self.achieve_weekly_reward_status
|
|
end
|
|
-- 成就协议相关逻辑end
|
|
|
|
-- 成就红点相关逻辑start
|
|
-- 检查成就红点
|
|
function AchieveModel:CheckAchieveAllRed( )
|
|
local bool = false
|
|
bool = bool or self:CheckAchieveChapterRed()
|
|
bool = bool or self:CheckAchieveItemRed()
|
|
bool = bool or self:CheckAchievePrivilegeRed()
|
|
bool = bool or self:CheckAcheiveWeeklyRewardRed()
|
|
bool = bool or self:CheckAchieveExchangeRed()
|
|
NewMainRoleModel:getInstance():Fire(NewMainRoleModel.UPDATE_RED_DOT, NewMainRoleModel.TabId.ROLE)
|
|
end
|
|
-- 根据红点类型更新红点缓存
|
|
function AchieveModel:CheckAchieveRed(type, is_all, index)
|
|
local bool
|
|
-- if type == AchieveModelRedType.Chapter then -- 章节完成红点
|
|
-- bool = self:CheckAchieveChapterRed(index)
|
|
-- else
|
|
if type == AchieveModelRedType.Achieve then -- 成就完成红点
|
|
bool = self:CheckAchieveItemRed(index)
|
|
elseif type == AchieveModelRedType.Privilege then -- 成就特权终生奖励
|
|
bool = self:CheckAchievePrivilegeRed(index)
|
|
elseif type == AchieveModelRedType.Weekly then -- 成就特权每周奖励
|
|
bool = self:CheckAcheiveWeeklyRewardRed()
|
|
elseif type == AchieveModelRedType.Exchange then -- 成就特权交易券红点(不要了这个功能)
|
|
bool = false -- self:CheckAchieveExchangeRed()
|
|
end
|
|
self:Fire(AchieveModel.UPDATE_ACHIEVE_RED, type, index, bool)
|
|
if is_all then
|
|
-- -- 发送事件更新角色界面的成就红点
|
|
-- NewMainRoleModel:getInstance():Fire(NewMainRoleModel.UPDATE_RED_DOT, NewMainRoleModel.TabId.ROLE)
|
|
GlobalEventSystem:Fire(AchieveModel.UPDATE_DAILY_RED)
|
|
end
|
|
return bool
|
|
end
|
|
-- 获取成就系统的缓存红点
|
|
-- type 红点类型 index 成就页签(章节),子类(小类)传对应的main_type 特权传指定的特权对应打的成就等级
|
|
function AchieveModel:GetAchieveCacheRed(type, index)
|
|
if not type then
|
|
return false
|
|
elseif not index then
|
|
if type == AchieveModelRedType.Weekly or type == AchieveModelRedType.Exchange then
|
|
return self.achieve_red_cache[type] or false
|
|
else
|
|
return self.achieve_red_cache[type] or {}
|
|
end
|
|
else
|
|
return self.achieve_red_cache[type] and self.achieve_red_cache[type][index] or false
|
|
end
|
|
end
|
|
|
|
-- 更新角色界面的成就页签红点
|
|
function AchieveModel:CheckMainRoleInfoViewAchieveRed()
|
|
local bool = false
|
|
for red_type, type_data in pairs(self.achieve_red_cache) do
|
|
if type(type_data) == "table" then
|
|
for k, has_red in pairs(type_data) do
|
|
bool = has_red or bool
|
|
end
|
|
else
|
|
bool = type_data or bool
|
|
end
|
|
end
|
|
self:SetAchieveTotalRedCache( bool )
|
|
return bool
|
|
end
|
|
|
|
-- 设置成就总红点
|
|
function AchieveModel:SetAchieveTotalRedCache( bool )
|
|
self.total_achieve_cache_red = bool
|
|
end
|
|
|
|
-- 获取成就总红点
|
|
function AchieveModel:GetAchieveTotalRedCache( bool )
|
|
return self.total_achieve_cache_red
|
|
end
|
|
|
|
|
|
--[[-- 获取成就章节完成的红点 category:传入章节将获得章节页签的红点
|
|
function AchieveModel:CheckAchieveChapterRed(category)
|
|
self.achieve_red_cache[AchieveModelRedType.Chapter] = self.achieve_red_cache[AchieveModelRedType.Chapter] or {}
|
|
local bool = false
|
|
-- 若传入了特定的成就章节，则只更新对应的红点
|
|
if category then
|
|
bool = self.chapter_progress_data[category] and self.chapter_progress_data[category].status == 1 or false
|
|
self.achieve_red_cache[AchieveModelRedType.Chapter][category] = bool
|
|
else
|
|
for k, v in pairs(self.chapter_progress_data) do
|
|
-- 存在章节已完成的情况返回true(这里不考虑成就完成情况)
|
|
bool = bool or v.status == 1
|
|
self.achieve_red_cache[AchieveModelRedType.Chapter][v.category] = v.status and v.status == 1 or false
|
|
end
|
|
end
|
|
return bool
|
|
end--]]
|
|
|
|
-- 获取成就小类(item)的红点
|
|
function AchieveModel:CheckAchieveItemRed(main_type)
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve] = self.achieve_red_cache[AchieveModelRedType.Achieve] or {}
|
|
local bool = false
|
|
-- 若传入了特定的成就章节，则只更新对应的红点
|
|
if main_type then
|
|
self.achieve_data[main_type] = self.achieve_data[main_type] or {}
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] = false -- 初始是没有红点
|
|
for k, v in pairs(self.achieve_data[main_type]) do
|
|
bool = bool or v.status == 1
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] =
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][main_type] or v.status == 1
|
|
end
|
|
else
|
|
-- 清除缓存
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve] = {}
|
|
for k, main_type_data in pairs(self.achieve_data) do
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][k] = false -- 本来没有红点
|
|
for k2, achieve in pairs(main_type_data) do
|
|
bool = bool or achieve.status == 1
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][k] =
|
|
self.achieve_red_cache[AchieveModelRedType.Achieve][k] or achieve.status == 1
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
-- 检查成就特权奖励领取红点
|
|
function AchieveModel:CheckAchievePrivilegeRed( )
|
|
self.achieve_red_cache[AchieveModelRedType.Privilege] = self.achieve_red_cache[AchieveModelRedType.Privilege] or {}
|
|
local bool = false
|
|
local privilege_cfg
|
|
for k, v in pairs(self.privilege_reward_status) do
|
|
privilege_cfg = Config.Achievementstageprivilege[v.lv]
|
|
if privilege_cfg and privilege_cfg.icon ~= 3 and privilege_cfg.icon ~= 4 then -- 过滤掉两个特殊处理红点的特权
|
|
bool = bool or v.status == 1
|
|
self.achieve_red_cache[AchieveModelRedType.Privilege][v.lv] = v.status == 1
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
-- 检查成就特权每周奖励红点
|
|
function AchieveModel:CheckAcheiveWeeklyRewardRed( )
|
|
local bool = self.achieve_weekly_reward_status == 1
|
|
self.achieve_red_cache[AchieveModelRedType.Weekly] = bool
|
|
return bool
|
|
end
|
|
|
|
-- 检查成就交易券兑换特权页签红点
|
|
function AchieveModel:CheckAchieveExchangeRed( )
|
|
local bool = false
|
|
if self.exchange_login_red then
|
|
bool = self:CheckAchieveExchangeBtnRed()
|
|
end
|
|
self.achieve_red_cache[AchieveModelRedType.Exchange] = bool
|
|
return bool
|
|
end
|
|
-- 检查成就交易券兑换按钮红点(与页签红点分开)
|
|
function AchieveModel:CheckAchieveExchangeBtnRed( )
|
|
self.achv_exhcange_btn_red = false
|
|
local cur_ach_lv = self.achieve_lv_data and self.achieve_lv_data.lv or 0
|
|
for k, v in pairs(Config.Achievementstageprivilege) do
|
|
if v.icon == 4 then -- 先判断是否达到目标特权所需成就等级
|
|
self.achv_exhcange_btn_red = cur_ach_lv >= v.stage
|
|
end
|
|
end
|
|
if self.achv_exhcange_btn_red then
|
|
-- 判断有无剩余次数
|
|
local time_data = self:GetAchieveExchangeData()
|
|
if time_data.now_count and time_data.max_count then
|
|
-- now_count:已经兑换的次数
|
|
self.achv_exhcange_btn_red = time_data.now_count < time_data.max_count
|
|
end
|
|
end
|
|
return self.achv_exhcange_btn_red
|
|
end
|
|
function AchieveModel:GetAchieveExchangeBtnRed( )
|
|
return self.achv_exhcange_btn_red
|
|
end
|
|
-- 红点逻辑 end
|
|
|
|
-- 界面获取数据的逻辑汇总
|
|
-- 根据等级获取当前成就特权等级
|
|
function AchieveModel:GetAchievePrivilegeLv(lv)
|
|
lv = lv or self.achieve_lv_data.lv or 0
|
|
local privilge_lv = 0
|
|
for k, v in pairs(Config.Achievementstageprivilege) do
|
|
-- 如果配置等级不高于当前成就等级，特权等级+1
|
|
if v.stage <= lv then
|
|
privilge_lv = privilge_lv + 1
|
|
end
|
|
end
|
|
return privilge_lv
|
|
end
|
|
|
|
-- 是否解锁了每日十环扫荡日常的特权
|
|
function AchieveModel:HasUnlockedFreeDailyTask( )
|
|
local unlocked = false
|
|
local cur_ach_lv = self.achieve_lv_data and self.achieve_lv_data.lv or 0
|
|
for k, v in pairs(Config.Achievementstageprivilege) do
|
|
if v.icon == 5 then -- 先判断是否达到目标特权所需成就等级
|
|
unlocked = cur_ach_lv >= v.stage
|
|
break
|
|
end
|
|
end
|
|
return unlocked
|
|
end
|
|
|
|
-- 检查是否可以快捷领取
|
|
function AchieveModel:CheckCanQuickGetReward( )
|
|
return RoleManager.Instance.mainRoleInfo.level <= self.QUICK_GET_LEVEL
|
|
end
|
|
|
|
-- 获取当前特权数据
|
|
function AchieveModel:GetCurPrivilegeStage( )
|
|
local cur_achieve_lv = self:GetAchieveLvData().lv or 1
|
|
local privilege_data = self:GetAchievePrivilegeTabData()
|
|
local index = 1
|
|
for k,v in ipairs(privilege_data) do
|
|
if v.stage <= cur_achieve_lv then
|
|
index = k
|
|
end
|
|
end
|
|
return index
|
|
end
|
|
|
|
-- 主界面用（totalview） 获取第一个可领的index 或者是下一个将可领取的index
|
|
function AchieveModel:GetCanGetPrivilegeStage( )
|
|
local cur_achieve_lv = self:GetAchieveLvData().lv or 1
|
|
local privilege_data = self:GetAchievePrivilegeTabData()
|
|
local index = 0
|
|
for k,v in ipairs(privilege_data) do
|
|
if v.stage <= cur_achieve_lv then
|
|
index = k
|
|
local status_data = self:GetAchievePrivilegeStatus(v.stage)
|
|
if status_data.status and status_data.status == 1 then -- 如果有奖领 就返回了
|
|
return index
|
|
end
|
|
end
|
|
end
|
|
if index ~= #privilege_data then -- 下一个可领特权
|
|
index = index + 1
|
|
end
|
|
return index
|
|
end
|
|
|
|
-- 获取当前特权的数据缓存
|
|
function AchieveModel:GetCurPrivilegeData( )
|
|
local index = self:GetCurPrivilegeStage( )
|
|
local privilege_data = self:GetAchievePrivilegeTabData()
|
|
return privilege_data[index]
|
|
end
|
|
|
|
----------推荐任务相关-start---------
|
|
-- 更新列表 02 03 04协议更新成就进度后都会刷一下
|
|
function AchieveModel:UpdateRecommendAchiList( for_update )
|
|
local count = TableSize(self.recommend_list) or 0
|
|
self.recommend_list = {}
|
|
for pos, list in ipairs(self.achieve_task_show_cache) do
|
|
for seq, cfg in pairsByKeys(list) do
|
|
if not self:AchiIsFinish(cfg.id) then --找到第一个未领取奖励的成就
|
|
local progress_data = self:GetTargetAchieveData(cfg.type, cfg.sub_type)
|
|
if progress_data and progress_data.id and progress_data.id < cfg.id then -- 进度还没到的成就不进推荐
|
|
break
|
|
end
|
|
if self.achieve_can_get_list[cfg.id] then -- 当前可领奖的不放在推荐任务这里
|
|
break
|
|
end
|
|
self.recommend_list[pos] = cfg
|
|
break
|
|
end
|
|
end
|
|
end
|
|
local new_count = TableSize(self.recommend_list) or 0
|
|
local is_achi_count_change = new_count ~= count
|
|
self:Fire(AchieveModel.UPDATE_ACHIEVE_TASK, is_achi_count_change or for_update)
|
|
end
|
|
|
|
-- 获取推荐成就列表
|
|
function AchieveModel:GetRecommendAchiList( )
|
|
return self.recommend_list
|
|
end
|
|
|
|
-- 获取当前可领奖的成就任务列表
|
|
function AchieveModel:GetCanGetAchiList( )
|
|
return self.achieve_can_get_list
|
|
end
|
|
|
|
-- 判断指定成就是否已经完成(指的是领完奖励)
|
|
function AchieveModel:AchiIsFinish( id )
|
|
return self.achieve_finsh_cache[id] == true
|
|
end
|
|
|
|
-- 记录已经完成的任务(指的是领完奖励)
|
|
function AchieveModel:RecordAchieveFinsh( data )
|
|
-- if data.status ~= 2 then return end -- 只记录已经领取的任务
|
|
if not self.achieve_cfg_cache then
|
|
self:InitAchieveCache()
|
|
end
|
|
if not data.type then return end
|
|
local cfg = self.achieve_cfg_cache[data.type][data.sub_type]
|
|
if not cfg then return end
|
|
for k,v in self:PairsByKeys( cfg ) do
|
|
if k ~= "first_id" and v.id < data.id then
|
|
self.achieve_finsh_cache[v.id] = true
|
|
self.achieve_can_get_list[v.id] = nil
|
|
elseif data.status == 2 and v.id == data.id then
|
|
self.achieve_finsh_cache[v.id] = true
|
|
self.achieve_can_get_list[v.id] = nil
|
|
elseif data.status == 1 and v.id == data.id then
|
|
self.achieve_can_get_list[v.id] = v
|
|
end
|
|
end
|
|
end
|
|
|
|
function AchieveModel:SetOpenFunCache( main_type, sub_type )
|
|
self.temp_open_fun_cache = {
|
|
main_type = main_type,
|
|
sub_type = sub_type,
|
|
}
|
|
end
|
|
|
|
function AchieveModel:GetOpenFunCache( )
|
|
return self.temp_open_fun_cache
|
|
end
|
|
|
|
function AchieveModel:DelOpenFunCache( )
|
|
self.temp_open_fun_cache = nil
|
|
end
|
|
|
|
-- 通用那个不能带有string 这里会排除string的干扰
|
|
function AchieveModel:PairsByKeys(t)
|
|
local temp = {}
|
|
for k in pairs(t) do
|
|
if type(k) == "number" then
|
|
temp[#temp+1] = k
|
|
end
|
|
end
|
|
table.sort(temp)
|
|
local i = 0
|
|
return function()
|
|
i = i+1
|
|
return temp[i], t[temp[i]]
|
|
end
|
|
end
|
|
|
|
-- 解析描述进度的condition 返回进度字符串（0/1）
|
|
function AchieveModel:ParseCondition( cfg_data )
|
|
local achieve_cfg = cfg_data
|
|
local progress_data = self:GetTargetAchieveData(cfg_data.type, cfg_data.sub_type)
|
|
progress_data.progress = progress_data.progress or 0
|
|
local str = ""
|
|
if achieve_cfg then
|
|
local condition = stringtotable(achieve_cfg.condition)[1] -- 将成就的需求总数固定存在条件的第一个中
|
|
local percentage = 0
|
|
if condition[1] == "arena_rank" then -- 竞技联赛不显示进度，改为追加显示当前排行
|
|
percentage = progress_data.status == 0 and 0 or 1
|
|
local my_info = PkRankModel:getInstance().my_info
|
|
if progress_data.status ~= 0 then
|
|
str = ""
|
|
elseif not my_info or not my_info.rank or my_info.rank == 0 then
|
|
str = string.format("当前名次：%s", HtmlColorTxt("未上榜", ColorUtil.GREEN_DARK))
|
|
else
|
|
str = string.format("当前名次：%s", HtmlColorTxt( tostring(my_info.rank), ColorUtil.GREEN_DARK) )
|
|
end
|
|
elseif condition[1] == "uranium_skill" then -- 技能激活
|
|
str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/" .. condition[3]
|
|
elseif condition[1] == "stage" then -- 进阶
|
|
str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/1"
|
|
else
|
|
str = HtmlColorTxt( progress_data.progress, ColorUtil.GREEN_DARK) .. "/" .. condition[2]
|
|
end
|
|
end
|
|
local str = str ~= "" and "(" .. str .. ")" or ""
|
|
return str
|
|
end
|
|
----------推荐任务相关-end-----------
|
|
----------成就动画状态-start---------
|
|
function AchieveModel:SetAchieveItemAnimState( is_anim )
|
|
self.achieve_item_is_animing = is_anim
|
|
end
|
|
|
|
function AchieveModel:AchieveItemIsAniming( )
|
|
return self.achieve_item_is_animing
|
|
end
|
|
|
|
function AchieveModel:SetSCMDWaitFlag( bool )
|
|
self.wait_scmd40903 = bool
|
|
end
|
|
|
|
function AchieveModel:GetSCMDWaitFlag( )
|
|
return self.wait_scmd40903
|
|
end
|
|
----------成就动画状态-end-----------
|