You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2753 lines
97 KiB
2753 lines
97 KiB
OperateActivityModel = OperateActivityModel or BaseClass(BaseVo, true)
|
|
local OperateActivityModel = OperateActivityModel
|
|
|
|
OperateActivityModel.REQUEST_INFO = "OperateActivityModel.REQUEST_INFO"
|
|
OperateActivityModel.OPEN_ACTIVITY_BASE_VIEW = "OperateActivityModel.OPEN_ACTIVITY_BASE_VIEW"--打开主界面
|
|
OperateActivityModel.UPDATE_ACTIVITY_BASE_VIEW = "OperateActivityModel.UPDATE_ACTIVITY_BASE_VIEW"--更新主界面
|
|
OperateActivityModel.OPEN_RANK_SHOW_VIEW = "OperateActivityModel.OPEN_RANK_SHOW_VIEW"--打开往期排行
|
|
OperateActivityModel.REQUEST_INFO = "OperateActivityModel.REQUEST_INFO"--请求协议
|
|
OperateActivityModel.ANS_UPDATE_VIEW = "OperateActivityModel.ANS_UPDATE_VIEW"--更新界面
|
|
OperateActivityModel.START_LUCKY_TURN_ACTION = "OperateActivityModel.START_LUCKY_TURN_ACTION"--转盘抽奖动画
|
|
OperateActivityModel.QUIK_USE = "OperateActivityModel.QUIK_USE"--触发快捷使用
|
|
OperateActivityModel.SHOW_REWARD_TIP = "OperateActivityModel.SHOW_REWARD_TIP"--显示物品列表（奖池等）
|
|
OperateActivityModel.SHOW_REWARD_TIP_NEW = "OperateActivityModel.SHOW_REWARD_TIP_NEW"--显示物品列表（有小标题）
|
|
|
|
OperateActivityModel.SCRAPING_CARD_BASE_DRAW_UPDATE = "OperateActivityModel.SCRAPING_CARD_UPDATEINFO"--刮刮卡抽卡更新
|
|
OperateActivityModel.SCRAPING_CARD_SCROE_DRAW_UPDATE = "OperateActivityModel.SCRAPING_CARD_SCROE_DRAW_UPDATE"--刮刮卡积分抽卡更新
|
|
OperateActivityModel.SCRAPING_CARD_REFRESH_UPDATE = "OperateActivityModel.SCRAPING_CARD_REFRESH_UPDATE"--刮刮卡重置
|
|
|
|
OperateActivityModel.TAROT_BASE_UPDATE = "OperateActivityModel.TAROT_BASE_UPDATE"--塔罗牌基本信息刷新
|
|
OperateActivityModel.TAROT_RECORD_UPDATE = "OperateActivityModel.TAROT_RECORD_UPDATE"--塔罗牌记录刷新
|
|
OperateActivityModel.TAROT_DRAW_UPDATE = "OperateActivityModel.TAROT_DRAW_UPDATE"--塔罗牌抽卡刷新
|
|
|
|
|
|
|
|
OperateActivityModel.STAGE_EXCHANGE_BASE_UPDATE = "OperateActivityModel.STAGE_EXCHANGE_BASE_UPDATE"--阶段兑换基本信息刷新
|
|
OperateActivityModel.STAGE_EXCHANGE_REWARD_UPDATE = "OperateActivityModel.STAGE_EXCHANGE_REWARD_UPDATE"--阶段兑换阶段奖励列表
|
|
|
|
OperateActivityModel.ADVENTURE_BASE_UPDATE = "OperateActivityModel.ADVENTURE_BASE_UPDATE"--冒险征途基本信息刷新
|
|
|
|
OperateActivityModel.UPDATE_GIDSAW_EVENT_DATA = "OperateActivityModel.UPDATE_GIDSAW_EVENT_DATA" -- 更新活跃拼图协议信息
|
|
OperateActivityModel.REVERSI_BASE_UPDATE = "OperateActivityModel.REVERSI_BASE_UPDATE"--黑白棋总信息刷新
|
|
OperateActivityModel.REVERSI_CUR_STATUS_UPDATE = "OperateActivityModel.REVERSI_CUR_STATUS_UPDATE"--黑白棋当前棋盘状态刷新
|
|
OperateActivityModel.REVERSI_CUR_REWARD_UPDATE = "OperateActivityModel.REVERSI_CUR_REWARD_UPDATE"--黑白棋当前棋盘奖励刷新
|
|
OperateActivityModel.OPEN_REFRESH_TIP = "OperateActivityModel.OPEN_REFRESH_TIP"--黑白棋刷新提示
|
|
OperateActivityModel.DO_REFRESH_ANIM = "OperateActivityModel.DO_REFRESH_ANIM"--执行黑白棋刷新动画
|
|
|
|
OperateActivityModel.OPEN_FESTIVAL_BOSS_REWARD_VIEW = "OperateActivityModel.OPEN_FESTIVAL_BOSS_REWARD_VIEW"--节日幻魔奖励列表
|
|
OperateActivityModel.REFRESH_FESTIVAL_BOSS = "OperateActivityModel.REFRESH_FESTIVAL_BOSS"--节日幻魔数据更新
|
|
|
|
OperateActivityModel.AMASING_JIPSAW_UPDATE_BASEINFO = "OperateActivityModel.AMASING_JIPSAW_UPDATE_BASEINFO"--眼疾手快基本数据
|
|
OperateActivityModel.AMASING_JIPSAW_UPDATE_GAMEINFO = "OperateActivityModel.AMASING_JIPSAW_UPDATE_GAMEINFO"--眼疾手快游戏数据
|
|
OperateActivityModel.AMASING_JIPSAW_UPDATE_GAME_START = "OperateActivityModel.AMASING_JIPSAW_UPDATE_GAME_START"--眼疾手快游戏开始
|
|
OperateActivityModel.AMASING_JIPSAW_UPDATE_GAME_EXCHANGE = "OperateActivityModel.AMASING_JIPSAW_UPDATE_GAME_EXCHANGE"--眼疾手快卡片交换
|
|
OperateActivityModel.AMASING_JIPSAW_UPDATE_REWARD = "OperateActivityModel.AMASING_JIPSAW_UPDATE_REWARD"--眼疾手快奖励
|
|
|
|
OperateActivityModel.PRAY_TREE_BASE_INFO = "OperateActivityModel.PRAY_TREE_BASE_INFO"--人参果树基本信息
|
|
OperateActivityModel.PRAY_TREE_DRAW = "OperateActivityModel.PRAY_TREE_DRAW"--人参果树抽卡
|
|
OperateActivityModel.PRAY_TREE_GET_REWARD = "OperateActivityModel.PRAY_TREE_GET_REWARD"--人参果树获取奖励
|
|
|
|
OperateActivityModel.UPDATE_COMPOSE_ROBOT_ANNOUNCE_INFO = "OperateActivityModel.UPDATE_COMPOSE_ROBOT_ANNOUNCE_INFO"--发明家信息更新
|
|
OperateActivityModel.UPDATE_COMPOSE_ROBOT_FORMULA_INFO = "OperateActivityModel.UPDATE_COMPOSE_ROBOT_FORMULA_INFO"--配方状态信息更新
|
|
OperateActivityModel.UPDATE_COMPOSE_ROBOT_COLLECT_INFO = "OperateActivityModel.UPDATE_COMPOSE_ROBOT_COLLECT_INFO"--配方收藏信息更新
|
|
OperateActivityModel.UPDATE_COMPOSE_ROBOT_MATERIAL_GOODS_NUM = "OperateActivityModel.UPDATE_COMPOSE_ROBOT_MATERIAL_GOODS_NUM"--材料数量更新
|
|
OperateActivityModel.ADD_COMPOSE_ROBOT_MATERIAL = "OperateActivityModel.ADD_COMPOSE_ROBOT_MATERIAL"--添加材料
|
|
OperateActivityModel.MINUS_COMPOSE_ROBOT_MATERIAL = "OperateActivityModel.MINUS_COMPOSE_ROBOT_MATERIAL"--减去材料
|
|
OperateActivityModel.UPDATE_COMPOSE_ROBOT_ASK_CD = "OperateActivityModel.UPDATE_COMPOSE_ROBOT_ASK_CD"--询问cd刷新
|
|
|
|
--自选扭蛋
|
|
OperateActivityModel.UPDATE_SELECT_EGG_VIEW = "OperateActivityModel.UPDATE_SELECT_EGG_VIEW"--刷新自选扭蛋界面
|
|
OperateActivityModel.UPDATE_SELECT_EGG_SELECT_REWARDS = "OperateActivityModel.UPDATE_SELECT_EGG_SELECT_REWARDS"--自选奖励后刷新选中状态
|
|
OperateActivityModel.UPDATE_SELECT_EGG_VIEW_AFTER_DRAW = "OperateActivityModel.UPDATE_SELECT_EGG_VIEW_AFTER_DRAW"--抽奖后刷新界面
|
|
OperateActivityModel.OPEN_SELECT_EGG_PREVIEW = "OperateActivityModel.OPEN_SELECT_EGG_PREVIEW"--预览奖励
|
|
OperateActivityModel.SELECT_EGG_START_DRAW = "OperateActivityModel.SELECT_EGG_START_DRAW"--准备发出抽奖协议
|
|
OperateActivityModel.AFTER_SELECT_EGG_DRAW = "OperateActivityModel.AFTER_SELECT_EGG_DRAW"--抽奖后放动画
|
|
OperateActivityModel.DO_SELECT_SELECT_EGG_REWARD = "OperateActivityModel.DO_SELECT_SELECT_EGG_REWARD"--要选择奖励的事件，通知主界面判断是否要切换栏目
|
|
OperateActivityModel.CANCLE_CHANGE_RARE_LINE = "OperateActivityModel.CANCLE_CHANGE_RARE_LINE"--取消切换栏目
|
|
|
|
OperateActivityModel.OPEN_SUPER_AWARD_SHOW_VIEW = "OperateActivityModel.OPEN_SUPER_AWARD_SHOW_VIEW"--打开超能大奖奖励展示界面
|
|
|
|
OperateActivityModel.OPEN_MATERIALSUBMIT_REQ_VIEW = "OperateActivityModel.OPEN_MATERIALSUBMIT_REQ_VIEW"--打开材料提交彩钻提交界面
|
|
OperateActivityModel.OPEN_MATERIAL_SUBMIT_BUFF_VIEW = "OperateActivityModel.OPEN_MATERIAL_SUBMIT_BUFF_VIEW"--打开材料提交buff界面
|
|
|
|
function OperateActivityModel:__init()
|
|
OperateActivityModel.Instance = self
|
|
self.login_red = nil--登陆红点
|
|
self:Reset()
|
|
end
|
|
|
|
OperateActivityModel.ScrapingCardFLAGTYPE =
|
|
{
|
|
RANDOM_DRAW = 1,
|
|
CUSTOM_DRAW = 2
|
|
}
|
|
|
|
OperateActivityModel.MaterialSubmitBuffKind = {
|
|
PEACH_EXP = 1,--触发加成后，参加舞池派对和公会篝火期间检验额外加成100%
|
|
BOSS_HUT_ADD = 2,--触发加成后，每次挑战赏金幻魔首次钻石鼓舞免费
|
|
BOSS_ATTACK_ADD = 3,--触发加成后，参加赏金幻魔和专属幻魔时，伤害结算计算BUFF加成，对BOSS伤害提高10%，BOSS对人物伤害降低10%，针对原属性采用加算
|
|
ADVENTURE_EXP_UP = 4,--触发加成后，玩家每分钟放置冒险经验收益提升100%（增对初始数值计算）
|
|
BOSS_DROP_DOUBLE = 5,--触发加成后，玩家赏金幻魔/专属幻魔掉落概率+100%
|
|
EGG_LUCKY_NUM = 6,--触发加成后，<color@1>龙神宝库</color>幸运值持续维持999，抽中不清空
|
|
BOSS_ADD_TIME = 11,--触发加成后，刷新所有赏金幻魔复活状态，且玩家挑战剩余次数+1
|
|
DUN_DOUBLE = 12,--触发加成后，通关材料副本可获得双倍奖励
|
|
DUN_ADD_TIMES = 13,--触发加成后，所有材料副本、守卫幼宠剩余次数+1
|
|
LUCKY_OFFER = 14,--触发加成后，龙神宝库首次10连抽、50连抽分别享受八折优惠
|
|
ADVENTURE_EXP = 15,--触发加成后，玩家放置冒险获得1次免费2倍速（不计入消耗次数）
|
|
GUILD_SPORT = 16,--拼单献礼触发加成后，<color@1>社团协助</color>玩法每人收益提升10%
|
|
ACT_LUCKY_OFFER = 21,--触发加成后，玩家参加定制活动108刮刮卡/111塔罗牌/115黑白棋时，前10次非免费抽奖享受8折
|
|
ACT_LUCKY_FREE = 22,--触发加成后，玩家参加定制活动108刮刮卡/111塔罗牌/115黑白棋时，首次抽奖免费
|
|
}
|
|
|
|
function OperateActivityModel:Reset()
|
|
self.view_info = {}--界面信息
|
|
self.act_red_dot_info = {}
|
|
self.red_dot_info = {}
|
|
self.is_close_main_icon = false
|
|
self.lucky_turn_table_base_info = {}--幸运转盘基础信息
|
|
self.lucky_turn_table_record_info = {}--幸运转盘记录信息
|
|
self.lucky_turn_table_open = false--是否打开了幸运转盘
|
|
self.lucky_turn_subtype = nil--幸运转盘多开子活动
|
|
self.lucky_turn_table_type = nil --幸运转盘的种类
|
|
self.is_skip_lucky_turn_table_action = false--跳过动画
|
|
|
|
---刮刮卡
|
|
self.sc_all_reward_list = false
|
|
self.sc_base_info = {}
|
|
self.sc_cfg = false
|
|
|
|
---塔罗牌卡
|
|
self.tarot_all_reward_list = false
|
|
self.tarot_base_info = {}
|
|
self.tarot_draw_cnt_list = {}
|
|
self.tarot_cfg = false
|
|
|
|
--阶段兑换
|
|
self.stage_exchange_info = {}
|
|
|
|
--冒险征途
|
|
self.adventure_num_info = {}--进度值信息
|
|
self.adventure_task_info = {}--任务信息
|
|
self.adventure_random_pool = {}--奖池列表
|
|
--黑白棋
|
|
self.reversi_info = {}
|
|
self.reversi_cur_info = {}
|
|
self.reversi_cur_pool_info = {}
|
|
|
|
-- 活跃拼图
|
|
self.jigsaw_event_list = {} -- 活跃拼图协议数据
|
|
self.jigsaw_red_cache = {} -- 拼图红点
|
|
|
|
--三日作战信息
|
|
self.three_fight_view_info = {}
|
|
self.three_fight_toggle = {}--三日作战补给购买复选
|
|
|
|
--人参果树
|
|
self.pray_tree_info = false --人参果树基本数据
|
|
self.pray_tree_reward_list = {} --人参果树奖励配置
|
|
|
|
-- 眼疾手快
|
|
self.amasing_jipsaw_info = {} -- 眼疾手快基本数据
|
|
|
|
--合成机
|
|
self.compose_robot_material_cfg = {} --原材料配置
|
|
self.compose_robot_formula_cfg = {} --配方配置
|
|
self.compose_robot_pool_cfg = {}--奖池配置
|
|
self.compose_robot_normal_pool_cfg = {}--普通奖池
|
|
self.compose_robot_collect_list = {} --收藏的合成配方列表
|
|
self.compose_robot_formula_data = {} --配方状态信息
|
|
self.compose_robot_announce_data = {} --广播滚动的发明家信息
|
|
self.compose_robot_now_use_material_list = {} --当前选中的材料列表
|
|
self.compose_robot_act_first_red = {} --活动开启的一次性红点
|
|
self.compose_robot_have_open_view = {} --是否打开过界面的标记
|
|
self.is_in_compose_view = {}
|
|
self.compose_robot_red_info = {}
|
|
self.compose_robot_ask_time = {}
|
|
|
|
--自选扭蛋
|
|
self.select_egg_ser_data = {}--自选扭蛋奖励等后端数据
|
|
self.select_egg_red_info = {}--自选扭蛋红点信息
|
|
self.select_egg_is_in_drawing = false
|
|
|
|
|
|
|
|
self.material_submit_info = {}--材料上交信息
|
|
|
|
self:InitCfg()
|
|
end
|
|
|
|
function OperateActivityModel:getInstance()
|
|
if OperateActivityModel.Instance == nil then
|
|
OperateActivityModel.Instance = OperateActivityModel.New()
|
|
end
|
|
return OperateActivityModel.Instance
|
|
end
|
|
|
|
--初始化配置
|
|
function OperateActivityModel:InitCfg( )
|
|
self.drop_time_limit = {}--BOSS掉落基本配置
|
|
local drop_time_limit = DeepCopy(Config.Droptimelimit)
|
|
local link = nil
|
|
for k,v in pairs(drop_time_limit) do
|
|
local data = v
|
|
link = stringtotable(v.link)--跳转数据
|
|
data.link = link and link[1]
|
|
data.award = stringtotable(v.award)--掉落奖励
|
|
data.desc = Trim(v.desc)--名字
|
|
data.tips = Trim(v.tips)--大奖名字
|
|
if not self.drop_time_limit[v.drop_type] then
|
|
self.drop_time_limit[v.drop_type] = {}
|
|
end
|
|
self.drop_time_limit[v.drop_type][v.drop_way] = data
|
|
end
|
|
|
|
self:InitThreeFightTaskCFG()--初始化三日作战任务表配置
|
|
self:InitThreeFightTaskActCFG()--初始化三日作战任务活动配置
|
|
|
|
self:InitComposeRobotMaterialCfg()--初始化合成机材料配置
|
|
self:InitComposeRobotFormulaCfg()--初始化合成机配方配置
|
|
self:InitComposeRobotPoolCfg()--初始化合成机奖池配置
|
|
end
|
|
|
|
--检查主界面红点(合并活动全部放在KFmodel里面了)
|
|
function OperateActivityModel:CheckMainIconRedDot()
|
|
|
|
end
|
|
|
|
--检测开服活动活动图标是否需要开启[兼顾设置开服活动活动内部的活动列表](合并活动全部放在KFmodel里面了)
|
|
function OperateActivityModel:CheckIconBoolOpen()
|
|
|
|
end
|
|
|
|
--这样写红点 每次调全局的只要调两次
|
|
function OperateActivityModel:IsNeedRedAll( )
|
|
|
|
end
|
|
|
|
--(合并活动全部放在KFmodel里面了)
|
|
function OperateActivityModel:IsNeedRed( id,is_all,sub_type )
|
|
-- local bool = false
|
|
-- self:Fire(OperateActivityModel.ANS_UPDATE_VIEW,id,bool)
|
|
-- if not is_all then
|
|
-- self:CheckMainIconRedDot()
|
|
-- end
|
|
-- print("huangcong:OperateActivityModel [222]: ",bool,id)
|
|
-- PrintTable(self.red_dot_info)
|
|
end
|
|
|
|
--获得活动信息页签列表(合并活动全部放在KFmodel里面了)
|
|
function OperateActivityModel:UpdateTab( )
|
|
|
|
end
|
|
|
|
--获得活动信息页签列表(合并活动全部放在KFmodel里面了)
|
|
function OperateActivityModel:CheckActivityIdOpen( id )
|
|
|
|
end
|
|
|
|
--获得界面类
|
|
function OperateActivityModel:GetViewClass(id)
|
|
|
|
end
|
|
|
|
--获得boss掉落奖励获取途径配置
|
|
function OperateActivityModel:GetBossDropTimeLimitCfg( drop_type )
|
|
return self.drop_time_limit[drop_type]
|
|
end
|
|
|
|
--得到副本是否是多倍掉落的数据信息
|
|
function OperateActivityModel:GetDunIsMulDropVo( dun_id,dun_type )
|
|
local sub_type_list = DeepCopy(CustomActivityModel:getInstance():getAllActListByBaseType(CustomActivityModel.CustomActBaseType.DUN_MUL_DROP))
|
|
local temp_list = {}
|
|
for i,v in pairs(sub_type_list) do
|
|
for ii,vv in ipairs(v.condition_list) do
|
|
if vv[1] and vv[2] then
|
|
if vv[1] == "type" then
|
|
if dun_id then--目前只有进阶副本只传副本ID
|
|
if tonumber(vv[3]) == dun_id then
|
|
temp_list[#temp_list + 1] = v
|
|
end
|
|
elseif dun_type then--副本类型
|
|
if tonumber(vv[2]) == dun_type then
|
|
temp_list[#temp_list + 1] = v
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if #temp_list == 1 then
|
|
return temp_list[1]
|
|
else
|
|
local sort_list = {}
|
|
local curTime = TimeUtil:getServerTime()
|
|
for kk,vv in ipairs(temp_list) do
|
|
if vv.stime <= curTime and curTime <= vv.etime then
|
|
return vv
|
|
else
|
|
sort_list[#sort_list + 1] = vv
|
|
end
|
|
end
|
|
if #sort_list > 0 then--如果没有找到时间内开放的活动 找与当前时间差值小的活动展示
|
|
local sort_func = function ( a, b )--开始时间从小到大
|
|
return a.stime < b.stime
|
|
end
|
|
if #sort_list > 1 then
|
|
table.sort(sort_list, sort_func)
|
|
end
|
|
|
|
for k,v in pairs(sort_list) do--找到开始时间里当前时间最近的
|
|
if curTime < v.stime then
|
|
return v
|
|
end
|
|
end
|
|
return sort_list[#sort_list]--没找到返回最后一个
|
|
end
|
|
end
|
|
end
|
|
|
|
--得到副本是否是多倍掉落
|
|
function OperateActivityModel:GetDunIsMulDrop( dun_id,dun_type )
|
|
local sub_type_list = DeepCopy(CustomActivityModel:getInstance():getAllActListByBaseType(CustomActivityModel.CustomActBaseType.DUN_MUL_DROP))
|
|
local mul_info = self:GetDunIsMulDropVo(dun_id,dun_type)
|
|
local mul_num = 0
|
|
local open_lv = 1
|
|
local dun_type = dun_type or 1
|
|
local temp_list = {}
|
|
|
|
if mul_info then
|
|
for ii,vv in ipairs(mul_info.condition_list) do
|
|
if vv[1] and vv[2] then
|
|
if vv[1] == "open_lv" then
|
|
open_lv = tonumber(vv[2])
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
local act_sec = mul_info.etime - TimeUtil:getServerTime()--活动剩余时间
|
|
local act_have_start = mul_info.stime - TimeUtil:getServerTime()--活动剩余时间
|
|
if act_have_start <= 0 and act_sec > 0 then
|
|
for i,v in ipairs(mul_info.condition_list) do
|
|
if v[1] and v[2] then
|
|
if v[1] == "multiple" then
|
|
mul_num = tonumber(v[2])
|
|
end
|
|
end
|
|
end
|
|
if open_lv > RoleManager.Instance.mainRoleInfo.level then
|
|
return false,mul_num
|
|
elseif dun_type == BaseDungeonModel.DUN_TYPE.VIP and RoleManager.Instance.mainRoleInfo.vip_flag < 1 then
|
|
return false,mul_num
|
|
else
|
|
return true,mul_num
|
|
end
|
|
end
|
|
else
|
|
return false,mul_num
|
|
end
|
|
end
|
|
--幸运转盘界面信息
|
|
function OperateActivityModel:SetLuckyTurnTableBaseInfo( subtype, turn_type, vo )
|
|
if subtype and turn_type then
|
|
if not self.lucky_turn_table_base_info[subtype] then
|
|
self.lucky_turn_table_base_info[subtype] = {}
|
|
end
|
|
self.lucky_turn_table_base_info[subtype][turn_type] = vo
|
|
end
|
|
self:ChangeVar("lucky_turn_table_base_info", self.lucky_turn_table_base_info, false, true)
|
|
end
|
|
|
|
function OperateActivityModel:GetLuckyTurnTableBaseInfo( subtype, turn_type )
|
|
if self.lucky_turn_table_base_info[subtype] then
|
|
return self.lucky_turn_table_base_info[subtype][turn_type] or {}
|
|
else
|
|
return {}
|
|
end
|
|
end
|
|
--幸运转盘记录信息
|
|
function OperateActivityModel:SetLuckyTurenTableRecordInfo( subtype, turn_type, vo )
|
|
if subtype and turn_type then
|
|
if not self.lucky_turn_table_record_info[subtype] then
|
|
self.lucky_turn_table_record_info[subtype] = {}
|
|
end
|
|
self.lucky_turn_table_record_info[subtype][turn_type] = vo
|
|
end
|
|
self:ChangeVar("lucky_turn_table_record_info", self.lucky_turn_table_record_info, false, true)
|
|
end
|
|
|
|
function OperateActivityModel:GetLuckyTurnTableRecordInfo( subtype, turn_type )
|
|
if self.lucky_turn_table_record_info[subtype] then
|
|
return self.lucky_turn_table_record_info[subtype][turn_type] or {}
|
|
end
|
|
return {}
|
|
end
|
|
|
|
function OperateActivityModel:IsLuckyTurnTableOpen( )
|
|
return self.lucky_turn_table_open
|
|
end
|
|
|
|
function OperateActivityModel:RefreshLuckyTurnTableSCMD( )
|
|
if self.lucky_turn_table_open and self.lucky_turn_subtype and self.lucky_turn_table_type then
|
|
self:Fire(OperateActivityModel.REQUEST_INFO, 33202, self.lucky_turn_subtype, self.lucky_turn_table_type)
|
|
end
|
|
end
|
|
|
|
---------------------------------------刮刮卡开始 ---------------------------------------
|
|
function OperateActivityModel:SetScrapingCardBaseInfo(vo)
|
|
self.sc_base_info = self.sc_base_info or {}
|
|
self.sc_base_info.sub_type = vo.sub_type
|
|
self.sc_base_info.all_reward_list = vo.reward_list
|
|
self.sc_base_info.card_list = {}
|
|
for i,v in ipairs(vo.card_list) do
|
|
self.sc_base_info.card_list[v.pos] = v.goods_list[1]
|
|
end
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_BASE_DRAW_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:SetScrapingCardScoreInfo(vo)
|
|
self.sc_base_info = self.sc_base_info or {}
|
|
self.sc_base_info.sub_type = vo.sub_type
|
|
|
|
self.sc_base_info.score = vo.score
|
|
self.sc_base_info.next_score = vo.next_score
|
|
self.sc_base_info.draw_times = vo.draw_times
|
|
|
|
local draw_list_pos = {}
|
|
for i,v in ipairs(vo.draw_list) do
|
|
draw_list_pos[v.draw_pos] = true
|
|
end
|
|
local score_reward_list = {}
|
|
for i,v in ipairs(vo.reward_list) do
|
|
score_reward_list[v.pos] =
|
|
{
|
|
goods = v.goods_list[1],
|
|
is_get = draw_list_pos[v.pos] or false,
|
|
}
|
|
end
|
|
self.sc_base_info.score_reward_list = score_reward_list
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ScrapingCard, nil, vo.sub_type)
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_SCROE_DRAW_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:SaveScrapingCardBaseDrawResult(vo)
|
|
local pos = false
|
|
self.sc_base_info.card_list = self.sc_base_info.card_list or {}
|
|
for i,v in ipairs(vo.reward_list) do
|
|
self.sc_base_info.card_list[v.pos] = v.goods_list[1]
|
|
if not pos then
|
|
pos = v.pos
|
|
end
|
|
end
|
|
local get_scroce = vo.score - self.sc_base_info.score
|
|
self.sc_base_info.score = vo.score
|
|
if vo.option == 1 and pos then
|
|
local t = vo.reward_list[1].goods_list[1]
|
|
local d =
|
|
{
|
|
sub_type = vo.sub_type,
|
|
goods_type_id = t.goods_type_id,
|
|
num = t.num,
|
|
}
|
|
|
|
KfActivityModel:getInstance():Fire(KfActivityModel.OPEN_SCRAOING_CARD_TIPS_VIEW_VIEW, d)
|
|
self.sc_base_info.ignore_pos = pos
|
|
end
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ScrapingCard, nil, vo.sub_type)
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_BASE_DRAW_UPDATE)
|
|
Message.show(string.format("获得 %s 刮刮卡积分", HtmlColorTxt(get_scroce, ColorUtil.SHALLOW_GREEN)))
|
|
end
|
|
|
|
function OperateActivityModel:SaveScrapingCardScoreDrawResult(vo)
|
|
self.sc_base_info.score = vo.score
|
|
self.sc_base_info.next_score = vo.next_score
|
|
|
|
local draw_list_pos = {}
|
|
for i,v in ipairs(vo.draw_list) do
|
|
draw_list_pos[v.draw_pos] = true
|
|
end
|
|
local score_reward_list = {}
|
|
for i,v in ipairs(vo.reward_list) do
|
|
score_reward_list[v.pos] =
|
|
{
|
|
goods = v.goods_list[1],
|
|
is_get = draw_list_pos[v.pos] or false,
|
|
}
|
|
end
|
|
self.sc_base_info.score_reward_list = score_reward_list
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ScrapingCard, nil, vo.sub_type)
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_SCROE_DRAW_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:RefreshScrapingCardBaseDraw()
|
|
self.sc_base_info = self.sc_base_info or {}
|
|
self.sc_base_info.card_list = {}
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_BASE_DRAW_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:ScrapingCardInitCfg(vo)
|
|
self.sc_cfg = vo
|
|
end
|
|
|
|
function OperateActivityModel:ScrapingCardShowRewardTips(vo)
|
|
if vo.pos then
|
|
self.sc_base_info.ignore_pos = false
|
|
if self.sc_base_info and self.sc_base_info.card_list and self.sc_base_info.card_list[vo.pos] then
|
|
local goods_type_id = self.sc_base_info.card_list[vo.pos].goods_type_id
|
|
local num = self.sc_base_info.card_list[vo.pos].num
|
|
local goods_fly_data = {[1] = goods_type_id}
|
|
if TableSize(goods_fly_data) > 0 then
|
|
MainUIModel:getInstance():PlayGoodsFlyList(goods_fly_data)
|
|
end
|
|
--飘字
|
|
local goods_fly_data = {
|
|
[1] = {
|
|
goods_type_id = goods_type_id,
|
|
num = num,
|
|
}
|
|
}
|
|
if TableSize(goods_fly_data) > 0 then
|
|
MainUIModel:getInstance():AddFloatInfo(goods_fly_data, true)
|
|
end
|
|
end
|
|
self:Fire(OperateActivityModel.SCRAPING_CARD_BASE_DRAW_UPDATE)
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:ScrapingCardCheckDo(can_do, price, str, ok_func, tips_flag_type)
|
|
function ok_function( )
|
|
if ok_func then
|
|
ok_func()
|
|
end
|
|
end
|
|
function toggle_function( flag )
|
|
if OperateActivityModel.ScrapingCardFLAGTYPE.RANDOM_DRAW == tips_flag_type then
|
|
self.sc_base_info.random_draw_toggle = flag
|
|
elseif OperateActivityModel.ScrapingCardFLAGTYPE.CUSTOM_DRAW == tips_flag_type then
|
|
self.sc_base_info.custom_draw_toggle = flag
|
|
end
|
|
end
|
|
|
|
local show_tips_flag = false
|
|
self.sc_base_info = self.sc_base_info
|
|
if OperateActivityModel.ScrapingCardFLAGTYPE.RANDOM_DRAW == tips_flag_type then
|
|
show_tips_flag = self.sc_base_info.random_draw_toggle or false
|
|
elseif OperateActivityModel.ScrapingCardFLAGTYPE.CUSTOM_DRAW == tips_flag_type then
|
|
show_tips_flag = self.sc_base_info.custom_draw_toggle or false
|
|
end
|
|
if not show_tips_flag then
|
|
if can_do then
|
|
local data =
|
|
{
|
|
show_content = str,
|
|
type = Alert.Type.Four,
|
|
ok_callback = ok_function,
|
|
toggle_function = toggle_function,
|
|
}
|
|
Alert.showbytable(data)
|
|
else
|
|
price = price or 0
|
|
local asset, source = WordManager:GetCommonMoneyIcon(1)
|
|
local data = {
|
|
gold_ab_res = asset,
|
|
gold_res = source,
|
|
price = price,
|
|
insufficientText = "",
|
|
priceText = str,
|
|
titleText = "提示",
|
|
ok_callback = ok_function,
|
|
toggle_function = toggle_function,
|
|
}
|
|
GlobalEventSystem:Fire(EventName.OPEN_COM_TOGGLE_TIP_VIEW, data)
|
|
end
|
|
else
|
|
ok_func()
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:ScrapingGetDrawCfg()
|
|
local need_item_id = 102350
|
|
local one_draw_cnt = 10
|
|
local item_money = 1
|
|
local cfg = self.sc_cfg
|
|
if cfg and cfg.condition_list then
|
|
for k,v in pairs(cfg.condition_list ) do
|
|
if v[1] == "scratch_card_cost" then
|
|
if v[2][1] and v[2][1][2] then
|
|
need_item_id = tonumber(v[2][1][2])
|
|
one_draw_cnt = tonumber(v[2][1][3])
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local item_cfg = Config.Goodsprice[self.need_item_id]
|
|
if item_cfg then
|
|
item_money = item_cfg.price
|
|
end
|
|
return need_item_id, one_draw_cnt, item_money
|
|
end
|
|
|
|
function OperateActivityModel:ScrapingCradGetRedDot(sub_type)
|
|
local b = false
|
|
if self.sc_base_info and self.sc_base_info.score and self.sc_base_info.next_score then
|
|
b = self.sc_base_info.score >= self.sc_base_info.next_score
|
|
end
|
|
if not b then
|
|
local base_type = CustomActivityModel.CustomActBaseType.TAROT
|
|
local free_buff_kind = OperateActivityModel.MaterialSubmitBuffKind.ACT_LUCKY_FREE --是否存在活动加成buff 首次抽奖免费
|
|
local free_buff_cfg,free_buff_info = OperateActivityModel:getInstance():GetMaterialBuffInfoByKind(free_buff_kind)
|
|
local buff_free_times = 0
|
|
if free_buff_cfg and free_buff_info then
|
|
local sec = free_buff_info.etime - TimeUtil:getServerTime( )
|
|
if sec > 0 then
|
|
self:ActScrapingCardBuffTimeLate(sec,sub_type)
|
|
buff_free_times = free_buff_cfg.data
|
|
for k,v in pairs(free_buff_info.used) do
|
|
if v.kdata == base_type then--十连还有次数
|
|
buff_free_times = buff_free_times - v.vdata
|
|
break
|
|
end
|
|
end
|
|
if buff_free_times > 0 then
|
|
b = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return b
|
|
end
|
|
|
|
--刮刮卡活动BUFF时间倒计时
|
|
function OperateActivityModel:ActScrapingCardBuffTimeLate( sec,sub_type )
|
|
if self.act_scraping_card_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_scraping_card_buff_timer_id)
|
|
self.act_scraping_card_buff_timer_id = nil
|
|
end
|
|
if self.scraping_card_act_sec and self.scraping_card_act_sec >= sec then
|
|
return
|
|
else
|
|
self.scraping_card_act_sec = sec
|
|
end
|
|
local sec = sec or 0
|
|
if sec > 0 then
|
|
local function onTimer()
|
|
sec = sec - 1
|
|
if sec > 0 then
|
|
|
|
else
|
|
if self.act_scraping_card_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_scraping_card_buff_timer_id)
|
|
self.act_scraping_card_buff_timer_id = nil
|
|
end
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ScrapingCard,nil,sub_type)
|
|
end
|
|
end
|
|
if not self.act_scraping_card_buff_timer_id then
|
|
self.act_scraping_card_buff_timer_id = GlobalTimerQuest:AddPeriodQuest(onTimer, 1, -1)
|
|
end
|
|
onTimer()
|
|
else
|
|
if self.act_scraping_card_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_scraping_card_buff_timer_id)
|
|
self.act_scraping_card_buff_timer_id = nil
|
|
end
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ScrapingCard,nil,sub_type)
|
|
end
|
|
end
|
|
|
|
|
|
function OperateActivityModel:ScrapingCradIsOpen(sub_type)
|
|
local b = false
|
|
if self.sc_cfg and self.sc_cfg.sub_type == sub_type then
|
|
local time = TimeUtil:getServerTime()
|
|
if time >= self.sc_cfg.stime and time <= self.sc_cfg.etime then
|
|
b = true
|
|
end
|
|
end
|
|
if not b then
|
|
Message.show("活动未开启")
|
|
end
|
|
return b
|
|
end
|
|
---------------------------------------刮刮卡结束 ---------------------------------------
|
|
|
|
|
|
---------------------------------------塔罗牌开始 ---------------------------------------
|
|
|
|
function OperateActivityModel:SetTarotBaseInfo(vo)
|
|
self.tarot_base_info = self.tarot_base_info or {}
|
|
self.tarot_base_info.sub_type = vo.sub_type
|
|
local reward_pool = vo.reward_pool
|
|
table.sort(reward_pool, function (a, b)
|
|
return a.index < b.index
|
|
end)
|
|
self.tarot_base_info.reward_pool = reward_pool
|
|
local get_reward_list = {}
|
|
local cnt = 0
|
|
for i,v in ipairs( vo.reward_pool) do
|
|
if v.status ~= 0 then
|
|
get_reward_list[v.status] = v
|
|
cnt = cnt + 1
|
|
end
|
|
end
|
|
local card_list = vo.card_list
|
|
table.sort(card_list, function (a, b)
|
|
return a.pos < b.pos
|
|
end)
|
|
self.tarot_base_info.card_list = card_list
|
|
self.tarot_base_info.get_reward_list = get_reward_list
|
|
|
|
self.tarot_draw_cnt_list = self.tarot_draw_cnt_list or {}
|
|
self.tarot_draw_cnt_list[vo.sub_type] = cnt
|
|
|
|
self:Fire(OperateActivityModel.TAROT_BASE_UPDATE)
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Tarot, nil, vo.sub_type)
|
|
end
|
|
|
|
function OperateActivityModel:UpdateTarorDrag(vo)
|
|
if self.tarot_base_info then
|
|
if self.tarot_base_info.reward_pool then
|
|
for i,v in ipairs(self.tarot_base_info.reward_pool) do
|
|
if v.index == vo.index then
|
|
v.status = vo.pos
|
|
self.tarot_base_info.get_reward_list = self.tarot_base_info.get_reward_list or {}
|
|
self.tarot_base_info.get_reward_list[vo.pos] = v
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
if self.tarot_base_info.card_list then
|
|
for i,v in ipairs(self.tarot_base_info.card_list) do
|
|
if v.pos == vo.pos then
|
|
v.status = 1
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self.tarot_draw_cnt_list = self.tarot_draw_cnt_list or {}
|
|
self.tarot_draw_cnt_list[vo.sub_type] = self.tarot_draw_cnt_list[vo.sub_type] or 0
|
|
self.tarot_draw_cnt_list[vo.sub_type] = self.tarot_draw_cnt_list[vo.sub_type] + 1
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Tarot, nil, vo.sub_type)
|
|
self:Fire(OperateActivityModel.TAROT_DRAW_UPDATE, vo.pos)
|
|
end
|
|
|
|
function OperateActivityModel:GetTargetRewardInfoByPos(pos)
|
|
local info
|
|
if self.tarot_base_info and self.tarot_base_info.get_reward_list then
|
|
info = self.tarot_base_info.get_reward_list[pos]
|
|
end
|
|
return info
|
|
end
|
|
|
|
function OperateActivityModel:GetTargetResList(list, size, sub_type)
|
|
local res_list = {}
|
|
if list and #list > 0 and size and size >= #list then
|
|
self.tarot_base_info.res_list = self.tarot_base_info.res_list or {}
|
|
self.tarot_base_info.res_list[sub_type] = self.tarot_base_info.res_list[sub_type] or {}
|
|
local function init_res_list(need_size, max_size)
|
|
local t = {}
|
|
local res_table = {}
|
|
for i=1,max_size do
|
|
t[i] = i
|
|
end
|
|
|
|
for i=1,need_size do
|
|
local idx = math.random(1, #t)
|
|
local tt = table.remove(t, idx)
|
|
res_table[i] = tt
|
|
end
|
|
return res_table
|
|
end
|
|
if #self.tarot_base_info.res_list[sub_type] == 0 then
|
|
self.tarot_base_info.res_list[sub_type] = init_res_list(#list, size)
|
|
else
|
|
local is_open = false
|
|
for i,v in ipairs(list) do
|
|
if v.status ~= 0 then
|
|
is_open = true
|
|
break
|
|
end
|
|
end
|
|
if not is_open then
|
|
self.tarot_base_info.res_list[sub_type] = init_res_list(#list, size)
|
|
end
|
|
end
|
|
res_list = self.tarot_base_info.res_list[sub_type]
|
|
end
|
|
return res_list
|
|
end
|
|
|
|
function OperateActivityModel:UpdateTarorRefresh(vo)
|
|
self:Fire(OperateActivityModel.TAROT_BASE_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:SetTarotResetFlag(flag)
|
|
self.tarot_base_info = self.tarot_base_info or {}
|
|
self.tarot_base_info.reset_flag = flag
|
|
end
|
|
|
|
function OperateActivityModel:GetTarotResetFlag()
|
|
return self.tarot_base_info.reset_flag
|
|
end
|
|
|
|
function OperateActivityModel:SetTarotRecordInfo(vo)
|
|
self.tarot_base_info = self.tarot_base_info or {}
|
|
self.tarot_base_info.sub_type = vo.sub_type
|
|
local goods_log = {}
|
|
for i,v in ipairs(vo.goods_log) do
|
|
table.insert(goods_log, v)
|
|
end
|
|
self.tarot_base_info.goods_log = goods_log
|
|
self:Fire(OperateActivityModel.TAROT_RECORD_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:SetTarotRecordInfoAdd(vo)
|
|
self.tarot_base_info = self.tarot_base_info or {}
|
|
self.tarot_base_info.goods_log = self.tarot_base_info.goods_log or {}
|
|
table.insert(self.tarot_base_info.goods_log, 1, vo)
|
|
if #self.tarot_base_info.goods_log > 30 then
|
|
table.remove(self.tarot_base_info.goods_log, #self.tarot_base_info.goods_log)
|
|
end
|
|
self:Fire(OperateActivityModel.TAROT_RECORD_UPDATE)
|
|
end
|
|
|
|
function OperateActivityModel:GetTargetRandomPos()
|
|
local pos = 0
|
|
local t = {}
|
|
if self.tarot_base_info and self.tarot_base_info.card_list then
|
|
for i,v in ipairs(self.tarot_base_info.card_list) do
|
|
if v.status == 0 then
|
|
table.insert(t, i)
|
|
end
|
|
end
|
|
if #t > 1 then
|
|
local idx = math.random(1, #t)
|
|
pos = t[idx]
|
|
elseif #t == 1 then
|
|
pos = t[1]
|
|
end
|
|
end
|
|
return pos
|
|
end
|
|
|
|
function OperateActivityModel:SetTarotCfg(vo)
|
|
self.tarot_cfg = self.tarot_cfg or {}
|
|
self.tarot_cfg[vo.sub_type]= vo
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Tarot, nil, vo.sub_type)
|
|
end
|
|
|
|
function OperateActivityModel:IsTarotOver()
|
|
local b = false
|
|
if self.tarot_cfg then
|
|
local cur_time = TimeUtil:getServerTime()
|
|
if self.tarot_cfg.etime > cur_time then
|
|
b = true
|
|
end
|
|
end
|
|
return b
|
|
end
|
|
|
|
function OperateActivityModel:GetTarotAllRewardList(base_type, sub_type)
|
|
if not self.tarot_all_reward_list or not self.tarot_all_reward_list[base_type] or not self.tarot_all_reward_list[base_type][sub_type] then
|
|
self.tarot_all_reward_list = self.tarot_all_reward_list or {}
|
|
local act_info = CustomActivityModel:getInstance():getOneActRewardList(base_type, sub_type)
|
|
if act_info then
|
|
local list = {}
|
|
for i=#act_info.reward_list,1,-1 do
|
|
local t = stringtotable(act_info.reward_list[i].reward)
|
|
table.insert(list, t[1])
|
|
end
|
|
self.tarot_all_reward_list = self.tarot_all_reward_list or {}
|
|
self.tarot_all_reward_list[base_type] = self.tarot_all_reward_list[base_type] or {}
|
|
if list and #list > 1 then
|
|
table.sort(list, function ( a,b )
|
|
a.basic = a.basic or GoodsModel:getInstance():GetGoodsBasicByTypeId(tonumber(a[2]))
|
|
b.basic = b.basic or GoodsModel:getInstance():GetGoodsBasicByTypeId(tonumber(b[2]))
|
|
return a.basic.color > b.basic.color
|
|
end)
|
|
end
|
|
self.tarot_all_reward_list[base_type][sub_type] = list
|
|
end
|
|
end
|
|
return self.tarot_all_reward_list and self.tarot_all_reward_list[base_type] and self.tarot_all_reward_list[base_type][sub_type] or {}
|
|
end
|
|
|
|
function OperateActivityModel:GetTarotDrawCnt()
|
|
local cnt = 0
|
|
if self.tarot_base_info and self.tarot_base_info.card_list then
|
|
for i,v in ipairs(self.tarot_base_info.card_list) do
|
|
if v.status ~= 0 then
|
|
cnt = cnt + 1
|
|
end
|
|
end
|
|
end
|
|
return cnt
|
|
end
|
|
|
|
function OperateActivityModel:GetDragCostInfo(sub_type, cnt)
|
|
local info =
|
|
{
|
|
goods_id = 102350,
|
|
cost_num = 9,
|
|
price = 1,
|
|
price_type = 1,
|
|
}
|
|
if self.tarot_cfg and self.tarot_cfg[sub_type] and self.tarot_cfg[sub_type].condition_list then
|
|
local cfg = self.tarot_cfg[sub_type]
|
|
|
|
if cfg.condition_list[1] and cfg.condition_list[1][2] then
|
|
info.goods_id = tonumber(cfg.condition_list[1][2])
|
|
end
|
|
local draw_cnt = cnt or self:GetTarotDrawCnt() + 1
|
|
if cfg.condition_list[2] and cfg.condition_list[2][2] then
|
|
info.cost_num = tonumber(cfg.condition_list[2][2][draw_cnt])
|
|
end
|
|
end
|
|
local cfg = Config.Goodsprice
|
|
if cfg[info.goods_id] then
|
|
info.price = cfg[info.goods_id].price
|
|
info.price_type = cfg[info.goods_id].price_type
|
|
end
|
|
return info
|
|
end
|
|
|
|
function OperateActivityModel:GetRefreshCostInfo(sub_type)
|
|
local info =
|
|
{
|
|
goods_id = 102314,
|
|
cost_num = 1,
|
|
price = 1,
|
|
price_type = 1,
|
|
}
|
|
if self.tarot_cfg and self.tarot_cfg[sub_type] and self.tarot_cfg[sub_type].condition_list then
|
|
local cfg = self.tarot_cfg[sub_type]
|
|
if cfg.condition_list[3] and cfg.condition_list[3][2] and cfg.condition_list[3][2][1] then
|
|
local d = cfg.condition_list[3][2][1]
|
|
info.goods_id = tonumber(d[2])
|
|
info.cost_num = tonumber(d[3])
|
|
end
|
|
end
|
|
|
|
local cfg = Config.Goodsprice
|
|
if cfg[info.goods_id] then
|
|
info.price = cfg[info.goods_id].price
|
|
info.price_type = cfg[info.goods_id].price_type
|
|
end
|
|
return info
|
|
end
|
|
|
|
function OperateActivityModel:GetDragGoodsId()
|
|
local goods_id = 102350
|
|
for k,v in pairs(self.tarot_cfg) do
|
|
local cfg = v
|
|
if cfg.condition_list[1] and cfg.condition_list[1][2] then
|
|
goods_id = tonumber(cfg.condition_list[1][2])
|
|
end
|
|
break
|
|
end
|
|
return goods_id
|
|
end
|
|
|
|
function OperateActivityModel:GetRefreshGoodsId()
|
|
local goods_id = 102314
|
|
for k,v in pairs(self.tarot_cfg) do
|
|
local cfg = v
|
|
if cfg.condition_list[3] and cfg.condition_list[3][2] and cfg.condition_list[3][2][1] and cfg.condition_list[3][2][1][2] then
|
|
goods_id = tonumber(cfg.condition_list[3][2][1][2])
|
|
end
|
|
break
|
|
end
|
|
return goods_id
|
|
end
|
|
|
|
function OperateActivityModel:TarotIsOpen(sub_type)
|
|
local b = false
|
|
if self.tarot_cfg and self.tarot_cfg[sub_type] then
|
|
local cfg = self.tarot_cfg[sub_type]
|
|
local time = TimeUtil:getServerTime()
|
|
if time >= cfg.stime and time <= cfg.etime then
|
|
b = true
|
|
end
|
|
end
|
|
if not b then
|
|
Message.show("活动未开启")
|
|
end
|
|
return b
|
|
end
|
|
|
|
|
|
function OperateActivityModel:TarotCheckDo(can_do, price, str, ok_func)
|
|
function ok_function( )
|
|
if ok_func then
|
|
ok_func()
|
|
end
|
|
end
|
|
function toggle_function( flag )
|
|
self.tarot_base_info.custom_draw_toggle = flag
|
|
end
|
|
|
|
local show_tips_flag = self.tarot_base_info.custom_draw_toggle or false
|
|
if not can_do and not show_tips_flag then
|
|
price = price or 0
|
|
local asset, source = WordManager:GetCommonMoneyIcon(1)
|
|
local data = {
|
|
gold_ab_res = asset,
|
|
gold_res = source,
|
|
price = price,
|
|
insufficientText = "",
|
|
priceText = str,
|
|
titleText = "提示",
|
|
ok_callback = ok_function,
|
|
toggle_function = toggle_function,
|
|
}
|
|
GlobalEventSystem:Fire(EventName.OPEN_COM_TOGGLE_TIP_VIEW, data)
|
|
else
|
|
ok_func()
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:TarotCheckRefresh(can_do, price, str, ok_func)
|
|
function ok_function( )
|
|
if ok_func then
|
|
ok_func()
|
|
end
|
|
end
|
|
function toggle_function( flag )
|
|
self.tarot_base_info.custom_refresh_toggle = flag
|
|
end
|
|
|
|
local show_tips_flag = self.tarot_base_info.custom_refresh_toggle or false
|
|
if not can_do and not show_tips_flag then
|
|
price = price or 0
|
|
local asset, source = WordManager:GetCommonMoneyIcon(1)
|
|
local data = {
|
|
gold_ab_res = asset,
|
|
gold_res = source,
|
|
price = price,
|
|
insufficientText = "",
|
|
priceText = str,
|
|
titleText = "提示",
|
|
ok_callback = ok_function,
|
|
toggle_function = toggle_function,
|
|
}
|
|
GlobalEventSystem:Fire(EventName.OPEN_COM_TOGGLE_TIP_VIEW, data)
|
|
else
|
|
ok_func()
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:TarotGetRedDot(sub_type)
|
|
local b = false
|
|
if self.tarot_cfg and self.tarot_cfg[sub_type] and self.tarot_draw_cnt_list and self.tarot_draw_cnt_list[sub_type] then
|
|
local draw_cost_info = self:GetDragCostInfo(self.tarot_draw_cnt_list[sub_type] + 1)
|
|
b = draw_cost_info.cost_num == 0
|
|
end
|
|
|
|
if not b then
|
|
local base_type = CustomActivityModel.CustomActBaseType.TAROT
|
|
local free_buff_kind = OperateActivityModel.MaterialSubmitBuffKind.ACT_LUCKY_FREE --是否存在活动加成buff 首次抽奖免费
|
|
local free_buff_cfg,free_buff_info = OperateActivityModel:getInstance():GetMaterialBuffInfoByKind(free_buff_kind)
|
|
local buff_free_times = 0
|
|
if free_buff_cfg and free_buff_info then
|
|
local sec = free_buff_info.etime - TimeUtil:getServerTime( )
|
|
if sec > 0 then
|
|
self:ActTarotBuffTimeLate(sec)
|
|
buff_free_times = free_buff_cfg.data
|
|
for k,v in pairs(free_buff_info.used) do
|
|
if v.kdata == base_type then--十连还有次数
|
|
buff_free_times = buff_free_times - v.vdata
|
|
break
|
|
end
|
|
end
|
|
if buff_free_times > 0 then
|
|
b = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return b
|
|
end
|
|
|
|
--塔罗牌活动BUFF时间倒计时
|
|
function OperateActivityModel:ActTarotBuffTimeLate( sec )
|
|
if self.act_tarot_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_tarot_buff_timer_id)
|
|
self.act_tarot_buff_timer_id = nil
|
|
end
|
|
if self.tarot_act_sec and self.tarot_act_sec >= sec then
|
|
return
|
|
else
|
|
self.tarot_act_sec = sec
|
|
end
|
|
local sec = sec or 0
|
|
if sec > 0 then
|
|
local function onTimer()
|
|
sec = sec - 1
|
|
if sec > 0 then
|
|
|
|
else
|
|
if self.act_tarot_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_tarot_buff_timer_id)
|
|
self.act_tarot_buff_timer_id = nil
|
|
end
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Tarot)
|
|
end
|
|
end
|
|
if not self.act_tarot_buff_timer_id then
|
|
self.act_tarot_buff_timer_id = GlobalTimerQuest:AddPeriodQuest(onTimer, 1, -1)
|
|
end
|
|
onTimer()
|
|
else
|
|
if self.act_tarot_buff_timer_id then
|
|
GlobalTimerQuest:CancelQuest(self.act_tarot_buff_timer_id)
|
|
self.act_tarot_buff_timer_id = nil
|
|
end
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Tarot)
|
|
end
|
|
end
|
|
---------------------------------------塔罗牌结束 ---------------------------------------
|
|
|
|
---------------------------------------阶段兑换商城信息 ---------------------------------------
|
|
function OperateActivityModel:GetStageExchangeInfo( sub_type )
|
|
return self.stage_exchange_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetStageExchangeInfo( value,one_data )
|
|
if (not value) and one_data then
|
|
--修改单条信息
|
|
local base_info = self:GetStageExchangeInfo(one_data.sub_type)
|
|
if base_info then
|
|
for k,v in pairs(base_info) do
|
|
if v.phase == one_data.phase then
|
|
for kk,vv in pairs(v.goods_list) do
|
|
if vv.grade_id == one_data.grade_id then
|
|
vv.exchange_num = one_data.exchange_num
|
|
-------------------------
|
|
if one_data.phase == 4 and vv.limit_num == 999 then
|
|
--无限制的那些要特殊处理
|
|
vv.exchange_num = 0
|
|
end
|
|
-------------------------
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return
|
|
end
|
|
-------------------------
|
|
for k,v in pairs(self.stage_exchange_info) do
|
|
if v.phase == 4 then
|
|
for kk,vv in pairs(v.goods_list) do
|
|
if vv.limit_num == 999 then
|
|
--无限制的那些要特殊处理
|
|
vv.exchange_num = 0
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-------------------------
|
|
local function sort_call( a,b )
|
|
return a.phase < b.phase
|
|
end
|
|
table.sort( value.goods_phase, sort_call )
|
|
self.stage_exchange_info[value.sub_type] = value.goods_phase
|
|
end
|
|
--获取阶段商城当前解锁期
|
|
function OperateActivityModel:GetStageExchangeUnlockPhase( sub_type )
|
|
local base_info = self:GetStageExchangeInfo(sub_type)
|
|
if not base_info then return 0 end
|
|
local unlock_phase = 0
|
|
for i,v in ipairs(base_info) do
|
|
unlock_phase = v.phase
|
|
for a,b in pairs(v.goods_list) do
|
|
if b.exchange_num < b.limit_num then
|
|
return unlock_phase
|
|
end
|
|
end
|
|
end
|
|
return unlock_phase
|
|
end
|
|
function OperateActivityModel:GetStageExchangeCostId( sub_type )
|
|
self.cost_id_stage_exchange = self.cost_id_stage_exchange or {}
|
|
if not self.cost_id_stage_exchange[sub_type] then
|
|
local act_info = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.STAGE_EXCHANGE, sub_type)
|
|
local list_condition = stringtotable(act_info.condition)
|
|
for k,v in pairs(list_condition) do
|
|
if v[1] == "cost_type" then
|
|
self.cost_id_stage_exchange[sub_type] = tonumber(v[2])
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return self.cost_id_stage_exchange[sub_type]
|
|
end
|
|
---------------------------------------阶段兑换商城信息 ---------------------------------------
|
|
|
|
|
|
---------------------------------------冒险征途 start---------------------------------------
|
|
--进度值信息
|
|
function OperateActivityModel:GetAdventureNumInfo( sub_type )
|
|
return self.adventure_num_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetAdventureNumInfo( value )
|
|
self.adventure_num_info[value.sub_type] = value
|
|
self:AdventureTaskFix(value.sub_type)
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Adventure,nil,value.sub_type)
|
|
end
|
|
--任务信息
|
|
function OperateActivityModel:GetAdventureTaskInfo( sub_type )
|
|
return self.adventure_task_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetAdventureTaskInfo( value )
|
|
self.adventure_task_info[value.sub_type] = value.mod_list
|
|
self:AdventureTaskFix(value.sub_type)
|
|
self:SetAdventureRandomPool(value.sub_type,value.reward_list or {})
|
|
end
|
|
--随机奖池
|
|
function OperateActivityModel:GetAdventureRandomPool( sub_type )
|
|
return self.adventure_random_pool[sub_type]
|
|
end
|
|
function OperateActivityModel:SetAdventureRandomPool( sub_type,value )
|
|
self.adventure_random_pool[sub_type] = value
|
|
end
|
|
--给任务信息添加进度信息
|
|
function OperateActivityModel:AdventureTaskFix( sub_type )
|
|
local data_1 = self:GetAdventureNumInfo(sub_type)
|
|
local data_2 = self:GetAdventureTaskInfo(sub_type)
|
|
if data_1 and data_2 then
|
|
for k,v in pairs(data_2) do
|
|
for kk,vv in pairs(data_1.task_list) do
|
|
if (v.mod_id == vv.mod_id) and (v.sub_id == vv.sub_id) then
|
|
v.times = vv.times
|
|
break
|
|
end
|
|
end
|
|
v.times = v.times or 0
|
|
end
|
|
end
|
|
end
|
|
function OperateActivityModel:GetAdventureCostIcon( sub_type )
|
|
local act_info = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.ADVENTURE, sub_type)
|
|
if act_info and act_info.condition then
|
|
local confition_list = stringtotable(act_info.condition)
|
|
for k,v in pairs(confition_list) do
|
|
if v[1] == "act_icon_pic" then
|
|
return v[2]
|
|
end
|
|
end
|
|
end
|
|
return 1
|
|
end
|
|
---------------------------------------冒险征途 end---------------------------------------
|
|
|
|
---------------------------------------活跃拼图 start---------------------------------------
|
|
-- 缓存活跃拼图协议信息 33153
|
|
function OperateActivityModel:SetJigsawEventData(vo)
|
|
if not vo then return end
|
|
self.jigsaw_event_list[vo.sub_type] = self.jigsaw_event_list[vo.sub_type] or {}
|
|
self.jigsaw_event_list[vo.sub_type].grades = {}
|
|
-- 按键值存储已领取阶段
|
|
for k, v in ipairs(vo.grades) do
|
|
self.jigsaw_event_list[vo.sub_type].grades[v.grade] = true
|
|
end
|
|
self.jigsaw_event_list[vo.sub_type].tasks = {}
|
|
local key = ""
|
|
for k, v in ipairs(vo.tasks) do
|
|
key = v.task_row .. "@" .. v.task_colu
|
|
self.jigsaw_event_list[vo.sub_type].tasks[key] = v
|
|
end
|
|
end
|
|
function OperateActivityModel:GetJigsawEventData(sub_type)
|
|
return self.jigsaw_event_list[sub_type] or nil
|
|
end
|
|
-- 获取活跃拼图奖励领取情况 已领取会返回true
|
|
function OperateActivityModel:GetJigsawGradeFlag(sub_type, grade)
|
|
if sub_type and grade and self.jigsaw_event_list[sub_type] then
|
|
return self.jigsaw_event_list[sub_type].grades[grade]
|
|
end
|
|
return false
|
|
end
|
|
-- 获取活跃拼图任务协议数据
|
|
function OperateActivityModel:GetJigsawTaskEventData(sub_type, task_row, task_colu)
|
|
if sub_type then
|
|
if task_row and task_colu then
|
|
return self.jigsaw_event_list[sub_type]
|
|
and self.jigsaw_event_list[sub_type].tasks
|
|
and self.jigsaw_event_list[sub_type].tasks[task_row .. "@" .. task_colu] or nil
|
|
else
|
|
return self.jigsaw_event_list[sub_type] and self.jigsaw_event_list[sub_type].tasks or nil
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
-- 返回表1：根据活跃拼图的奖励配置，筛选出带有奖励的任务列表 格式为 [任务行@任务列] = true
|
|
-- 返回表2：根据活动的condition_list,拼接形成键值后用gade作为值成表方便查询grade
|
|
function OperateActivityModel:GetJigsawAwardTaskListAndGradeList(reward_cfg)
|
|
local tb1, tb2 = {}, {}
|
|
local key = ""
|
|
if reward_cfg then
|
|
for k, v in ipairs(reward_cfg.reward_list) do
|
|
for k2, v2 in ipairs(v.condition_list) do
|
|
for k3, v3 in ipairs(v2) do
|
|
if k3 == 1 then
|
|
key = v3
|
|
else
|
|
key = key .. "@" .. v3
|
|
end
|
|
end
|
|
-- 根据条件列表组合成键值保存奖励档次
|
|
tb2[key] = v.grade
|
|
-- 如果是任务节点的奖励，则重新创建键值并添加到表1
|
|
if v2[1] == "order" then
|
|
key = v2[2] .. "@" .. v2[3]
|
|
tb1[key] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return tb1, tb2
|
|
end
|
|
-- 获取活跃拼图任务进度 task_state:0待完成 1可领取 2已领取(有部分任务有奖励，要做是否存在奖励分类处理，对于没有奖励的任务，前端新增状态3)
|
|
function OperateActivityModel:GetJigsawTaskState(sub_type, award_task_list, task_row, task_colu)
|
|
local state = 0
|
|
if sub_type and award_task_list and task_row and task_colu then
|
|
-- 是否是有奖励的任务
|
|
local has_reward = award_task_list[task_row.."@"..task_colu] or false
|
|
-- 获取任务状态
|
|
local event_data = self:GetJigsawTaskEventData(sub_type, task_row, task_colu)
|
|
state = event_data and event_data.task_state or 0
|
|
-- 完成没有奖励的任务，特殊处理为3
|
|
if not has_reward and state == 1 then
|
|
state = 3
|
|
end
|
|
end
|
|
return state
|
|
end
|
|
|
|
-- 拼图活动领取更新缓存 33154
|
|
function OperateActivityModel:UpdateJigsawGradeData(vo)
|
|
if vo and self.jigsaw_event_list[vo.sub_type] and self.jigsaw_event_list[vo.sub_type].grades then
|
|
self.jigsaw_event_list[vo.sub_type].grades[vo.grade] = true
|
|
end
|
|
end
|
|
|
|
-- 获取活跃拼图任务配置
|
|
function OperateActivityModel:GetJigsawTaskCfgData(condition_list)
|
|
if not condition_list then return end
|
|
local tb = {}
|
|
local suit_id, bg_res = nil, "bg_1" -- 背景图有默认资源
|
|
-- 获取任务套的id
|
|
for k, v in ipairs(condition_list) do
|
|
if v[1] == "suit" then
|
|
suit_id = tonumber(v[2])
|
|
end
|
|
if string.find(v[1], "bg_") then
|
|
bg_res = v[1]
|
|
end
|
|
end
|
|
-- 根据任务套id获取任务内容
|
|
if suit_id then
|
|
for k, v in pairs(Config.Actslicetask) do
|
|
if v.suit == suit_id then
|
|
tb[#tb+1] = v
|
|
end
|
|
end
|
|
-- 排序任务
|
|
local sort_func = function ( a, b )
|
|
if a.row == b.row then
|
|
return a.colu < b.colu
|
|
else
|
|
return a.row < b.row
|
|
end
|
|
end
|
|
table.sort(tb, sort_func)
|
|
end
|
|
return tb, suit_id, bg_res
|
|
end
|
|
|
|
-- 活跃拼图红点
|
|
function OperateActivityModel:GetJigsawRed(sub_type, reward_cfg)
|
|
local bool = false
|
|
if sub_type and reward_cfg then
|
|
self.jigsaw_red_cache[sub_type] = {}
|
|
-- 行，列的完成任务数
|
|
local row_task_state_tb, col_task_state_tb = {}, {}
|
|
-- 先检测任务可完成的红点
|
|
local award_task_list, grade_list = self:GetJigsawAwardTaskListAndGradeList(reward_cfg)
|
|
local key, state = "", 0
|
|
local tasks = self:GetJigsawTaskEventData(sub_type) -- 任务协议状态
|
|
local total_task_num = TableSize(tasks)
|
|
local task_finished_num = 0
|
|
if tasks then
|
|
for k, v in pairs(tasks) do
|
|
state = self:GetJigsawTaskState(sub_type, award_task_list, v.task_row, v.task_colu)
|
|
key = v.task_row .. "@" .. v.task_colu
|
|
-- 根据行列记录任务完成数
|
|
row_task_state_tb[v.task_row] = row_task_state_tb[v.task_row] or 0
|
|
row_task_state_tb[v.task_row] = state >= 2 and row_task_state_tb[v.task_row] + 1 or row_task_state_tb[v.task_row]
|
|
col_task_state_tb[v.task_colu] = col_task_state_tb[v.task_colu] or 0
|
|
col_task_state_tb[v.task_colu] = state >= 2 and col_task_state_tb[v.task_colu] + 1 or col_task_state_tb[v.task_colu]
|
|
|
|
-- 累加完成个数
|
|
task_finished_num = state >= 2 and task_finished_num + 1 or task_finished_num
|
|
|
|
bool = state == 1 or bool
|
|
end
|
|
end
|
|
|
|
-- 再检测横行竖列的红点
|
|
local key_list = {}
|
|
for k, v in pairs(grade_list) do
|
|
if not self:GetJigsawGradeFlag(sub_type, v) then -- 没有已领取记录
|
|
key_list = Split(k, "@")
|
|
if key_list[1] == "row" and row_task_state_tb[tonumber(key_list[2])] then -- 检测横行的红点
|
|
bool = row_task_state_tb[tonumber(key_list[2])] >= 3 or bool
|
|
elseif key_list[1] == "column" and col_task_state_tb[tonumber(key_list[2])] then -- 检测竖列的红点
|
|
bool = col_task_state_tb[tonumber(key_list[2])] >= 3 or bool
|
|
elseif key_list[1] == "count" then -- 检测任务是否全部完成
|
|
-- 缓存红点
|
|
self.jigsaw_red_cache[sub_type][key_list[1]] = task_finished_num >= total_task_num and total_task_num > 0
|
|
bool = self.jigsaw_red_cache[sub_type][key_list[1]] or bool
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
function OperateActivityModel:GetJigsawRedCache(sub_type, red_type)
|
|
if sub_type then
|
|
if red_type then
|
|
return self.jigsaw_red_cache[sub_type] and self.jigsaw_red_cache[sub_type][red_type] or false
|
|
else
|
|
return self.jigsaw_red_cache[sub_type]
|
|
end
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
---------------------------------------活跃拼图 end---------------------------------------
|
|
---------------------------------------黑白棋 start---------------------------------------
|
|
--总奖励列表
|
|
function OperateActivityModel:GetReversiInfo( sub_type )
|
|
return self.reversi_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetReversiInfo( value )
|
|
self.reversi_info[value.sub_type] = value
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Reversi, nil, value.sub_type)
|
|
end
|
|
|
|
--当前奖池状态
|
|
function OperateActivityModel:GetReversiCurInfo( sub_type )
|
|
return self.reversi_cur_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetReversiCurInfo( value )
|
|
self.reversi_cur_info[value.sub_type] = value.reward_list
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.Reversi, nil, value.sub_type)
|
|
end
|
|
--当前奖池奖励列表
|
|
function OperateActivityModel:GetReversiCurPoolInfo( sub_type )
|
|
return self.reversi_cur_pool_info[sub_type]
|
|
end
|
|
function OperateActivityModel:SetReversiCurPoolInfo( value )
|
|
value.cost_tb = stringtotable(value.cost)[1]
|
|
value.other_cost_tb = stringtotable(value.other_cost)[1]
|
|
self.reversi_cur_pool_info[value.sub_type] = value
|
|
end
|
|
---------------------------------------黑白棋 end---------------------------------------
|
|
|
|
---------------------------------------三日作战 start---------------------------------------
|
|
function OperateActivityModel:InitThreeFightTaskCFG( )--初始化三日作战任务表配置
|
|
self.three_fight_task_cfg = {}
|
|
local data = DeepCopy(Config.Daysplantask)
|
|
for k,v in pairs(data) do
|
|
if not self.three_fight_task_cfg[v.task_type] then
|
|
self.three_fight_task_cfg[v.task_type] = {}
|
|
end
|
|
v.reward = stringtotable(v.reward)
|
|
v.link = stringtotable(v.link)
|
|
v.desc = Trim(v.desc)
|
|
self.three_fight_task_cfg[v.task_type][v.task_id] = v
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:GetThreeFightTaskCfg( task_type,task_id )--获得三日作战任务表配置
|
|
if self.three_fight_task_cfg[task_type] then
|
|
return self.three_fight_task_cfg[task_type][task_id]
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:InitThreeFightTaskActCFG( )--初始化三日作战任务活动配置
|
|
self.three_fight_act_task_cfg = {}
|
|
local data = DeepCopy(Config.Daysplantasksuit)
|
|
for k,v in pairs(data) do
|
|
if not self.three_fight_act_task_cfg[v.suit] then
|
|
self.three_fight_act_task_cfg[v.suit] = {}
|
|
end
|
|
if not self.three_fight_act_task_cfg[v.suit][v.open_day] then
|
|
self.three_fight_act_task_cfg[v.suit][v.open_day] = {}
|
|
end
|
|
self.three_fight_act_task_cfg[v.suit][v.open_day][#self.three_fight_act_task_cfg[v.suit][v.open_day] + 1] = v
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:SetThreeFightViewInfoOne( v )--设置三日作战服务端数据
|
|
local new_data = {}
|
|
local cur_times = 0
|
|
local max_times = 0
|
|
for kk,vv in pairs(v.list) do
|
|
new_data[vv.day] = vv
|
|
end
|
|
v.list = new_data
|
|
self.three_fight_view_info[v.sub_type] = v
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ThreeFight,nil,v.sub_type)
|
|
end
|
|
|
|
function OperateActivityModel:CheckThreeFightRedDot( sub_type )--检查三日作战红点
|
|
local show = false
|
|
self.three_fight_red_info = self.three_fight_red_info or {}
|
|
self.three_fight_red_info[sub_type] = {}
|
|
local base_type = CustomActivityModel.CustomActBaseType.THREE_FIGHT
|
|
local sub_type = sub_type or CustomActivityModel:getInstance():getActMinSubType(base_type)
|
|
local act_list = CustomActivityModel:getInstance():getActList(base_type, sub_type)
|
|
local act_type = CustomActivityModel.CustomIconActType.KfAct
|
|
if act_list then
|
|
act_type = act_list.act_type
|
|
local start_day = math.ceil((TimeUtil:getServerTime() - act_list.stime)/60/60/24)--当前活动开始的第几天
|
|
for k,v in pairs(self.three_fight_view_info) do
|
|
if v.sub_type == sub_type then
|
|
for kk,vv in pairs(v.list) do
|
|
for kkk,vvv in pairs(vv.task_list) do
|
|
if vvv.state == 1 and start_day >= vv.day then
|
|
show = true
|
|
self.three_fight_red_info[sub_type][vv.day] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return show,act_type
|
|
end
|
|
---------------------------------------三日作战 end---------------------------------------
|
|
|
|
---------------------------------------眼疾手快 start---------------------------------------
|
|
--更新眼疾手快基本信息
|
|
function OperateActivityModel:SetAmasingJipSawBaseInfo(vo)
|
|
self.amasing_jipsaw_info = self.amasing_jipsaw_info or {}
|
|
self.amasing_jipsaw_info.base_info = {}
|
|
self.amasing_jipsaw_info.base_info.sub_type = vo.sub_type
|
|
self.amasing_jipsaw_info.base_info.stage = vo.stage
|
|
self.amasing_jipsaw_info.base_info.puzzle_times = vo.puzzle_times
|
|
self:Fire(OperateActivityModel.AMASING_JIPSAW_UPDATE_BASEINFO)
|
|
end
|
|
|
|
--更新眼疾手快游戏拼图数据
|
|
function OperateActivityModel:SetAmasingJipSawGameInfo(vo)
|
|
self.amasing_jipsaw_info = self.amasing_jipsaw_info or {}
|
|
self.amasing_jipsaw_info.pic_info = {}
|
|
self.amasing_jipsaw_info.pic_info.sub_type = vo.sub_type
|
|
self.amasing_jipsaw_info.pic_info.option_type = vo.option_type
|
|
self.amasing_jipsaw_info.pic_info.picture_id = vo.picture_id
|
|
self.amasing_jipsaw_info.pic_info.start_time = vo.start_time
|
|
self.amasing_jipsaw_info.pic_info.end_time = vo.end_time
|
|
self.amasing_jipsaw_info.pic_info.row = 0
|
|
self.amasing_jipsaw_info.pic_info.col = 0
|
|
local card_list = vo.card_list
|
|
if #card_list > 0 then
|
|
table.sort( card_list, function (a, b)
|
|
if a.x ~= b.x then
|
|
return a.x < b.x
|
|
else
|
|
return a.y < b.y
|
|
end
|
|
end )
|
|
|
|
self.amasing_jipsaw_info.pic_info.row = card_list[#card_list].x
|
|
self.amasing_jipsaw_info.pic_info.col = card_list[#card_list].y
|
|
|
|
local t = {}
|
|
for i,v in ipairs(card_list) do
|
|
table.insert(t, v.num)
|
|
end
|
|
card_list = t
|
|
end
|
|
|
|
self.amasing_jipsaw_info.pic_info.card_list = card_list
|
|
self:Fire(OperateActivityModel.AMASING_JIPSAW_UPDATE_GAMEINFO, vo.option_type)
|
|
|
|
--如果是开始游戏，同步一下进度
|
|
if vo.option_type == 2 then
|
|
self:Fire(OperateActivityModel.REQUEST_INFO, 33271, vo.sub_type)
|
|
end
|
|
end
|
|
|
|
--拼图交换
|
|
function OperateActivityModel:SetAmasingJipSawGameExchange(old_idx, new_idx)
|
|
if self.amasing_jipsaw_info.pic_info and self.amasing_jipsaw_info.pic_info.card_list then
|
|
if self.amasing_jipsaw_info.pic_info.card_list[old_idx] and self.amasing_jipsaw_info.pic_info.card_list[new_idx] then
|
|
self.amasing_jipsaw_info.pic_info.card_list[old_idx], self.amasing_jipsaw_info.pic_info.card_list[new_idx] = self.amasing_jipsaw_info.pic_info.card_list[new_idx], self.amasing_jipsaw_info.pic_info.card_list[old_idx]
|
|
end
|
|
end
|
|
end
|
|
|
|
--眼疾手快奖励
|
|
function OperateActivityModel:SetAmasingJipSawReward(vo)
|
|
self.amasing_jipsaw_info = self.amasing_jipsaw_info or {}
|
|
self.amasing_jipsaw_info.base_info = {}
|
|
self.amasing_jipsaw_info.base_info.sub_type = vo.sub_type
|
|
self.amasing_jipsaw_info.base_info.stage = vo.stage
|
|
self.amasing_jipsaw_info.base_info.puzzle_times = vo.puzzle_times
|
|
self.amasing_jipsaw_info.reward_list = vo.reward_list
|
|
end
|
|
|
|
--更新眼疾手快奖励预览信息
|
|
function OperateActivityModel:SetAmasingJipSawShowReward(vo)
|
|
self.amasing_jipsaw_info = self.amasing_jipsaw_info or {}
|
|
self.amasing_jipsaw_info.show_info = {}
|
|
self.amasing_jipsaw_info.show_info.sub_type = vo.sub_type
|
|
local reward_list = {}
|
|
if #vo.reward_list > 0 then
|
|
for i=1,6 do
|
|
local idx = #vo.reward_list - i + 1
|
|
if vo.reward_list[idx] then
|
|
table.insert(reward_list, vo.reward_list[idx])
|
|
end
|
|
end
|
|
end
|
|
|
|
self.amasing_jipsaw_info.show_info.reward_list = reward_list
|
|
self:Fire(OperateActivityModel.AMASING_JIPSAW_UPDATE_BASEINFO)
|
|
end
|
|
|
|
--眼疾手快获取基本数据
|
|
function OperateActivityModel:GetAmasingJipSawBaseInfo()
|
|
return (self.amasing_jipsaw_info and self.amasing_jipsaw_info.base_info) and self.amasing_jipsaw_info.base_info or nil
|
|
end
|
|
|
|
--眼疾手快获取奖励预览数据
|
|
function OperateActivityModel:GetAmasingJipSawShowReward()
|
|
return (self.amasing_jipsaw_info and self.amasing_jipsaw_info.show_info and self.amasing_jipsaw_info.show_info.reward_list) and self.amasing_jipsaw_info.show_info.reward_list or nil
|
|
end
|
|
|
|
--眼疾手快获取拼图数据
|
|
function OperateActivityModel:GetAmasingJipSawGameInfo()
|
|
return (self.amasing_jipsaw_info and self.amasing_jipsaw_info.pic_info) and self.amasing_jipsaw_info.pic_info or nil
|
|
end
|
|
|
|
--眼疾手快游戏开始
|
|
function OperateActivityModel:AmasingJipSawGameStart(vo)
|
|
self:Fire(OperateActivityModel.AMASING_JIPSAW_UPDATE_GAME_START, vo.sub_type, vo.stage)
|
|
end
|
|
---------------------------------------眼疾手快 end---------------------------------------
|
|
|
|
---------------------------------------人参果树 start---------------------------------------
|
|
--人参果树基本信息
|
|
function OperateActivityModel:SetPrayTreeBaseInfo(vo)
|
|
self.pray_tree_info = self.pray_tree_info or {}
|
|
self.pray_tree_info.sub_type = vo.sub_type
|
|
self.pray_tree_info.next_hit = vo.next_hit
|
|
self.pray_tree_info.score = vo.score
|
|
self.pray_tree_info.free_count = vo.free_count
|
|
self:Fire(OperateActivityModel.PRAY_TREE_BASE_INFO)
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.PrayTree, nil, vo.sub_type)
|
|
end
|
|
|
|
--人参果树抽卡
|
|
function OperateActivityModel:SetPrayTreeDrawnfo(vo)
|
|
self:Fire(OperateActivityModel.PRAY_TREE_DRAW, vo)
|
|
end
|
|
|
|
--人参果树领奖
|
|
function OperateActivityModel:SetPrayTreeRewardInfo(vo)
|
|
self:Fire(OperateActivityModel.PRAY_TREE_GET_REWARD)
|
|
end
|
|
|
|
--人参果树领奖
|
|
function OperateActivityModel:GetPrayTreeBaseInfo()
|
|
return self.pray_tree_info
|
|
end
|
|
|
|
--人参果树最大祝福值
|
|
function OperateActivityModel:GetPrayTreeMaxValue()
|
|
local cfg = Config.Customactkv
|
|
return (cfg and cfg["120@blessing_value_max"]) and cfg["120@blessing_value_max"].value_content or 100
|
|
end
|
|
|
|
--人参果树祝福奖励
|
|
function OperateActivityModel:GetPrayTreeLessReward()
|
|
local cfg = Config.Customactkv
|
|
return (cfg and cfg["120@blessing_reward"]) and stringtotable(cfg["120@blessing_reward"].value_content)[1] or false
|
|
end
|
|
|
|
--人参果树最大祝福值
|
|
function OperateActivityModel:GetPrayTreeDrawCost(draw_type)
|
|
local cfg = Config.Customactkv
|
|
--单抽
|
|
if draw_type == 1 then
|
|
if (cfg and cfg["120@cost_one"]) then
|
|
local info = stringtotable(cfg["120@cost_one"].value_content)
|
|
local cost_item_id = info[1][2]
|
|
local cost_info =
|
|
{
|
|
kind = info[1][1],
|
|
goods_id = info[1][2],
|
|
cost_num = info[1][3],
|
|
}
|
|
local price_cfg = Config.Goodsprice
|
|
if price_cfg and price_cfg[cost_item_id] then
|
|
local d = price_cfg[cost_item_id]
|
|
cost_info.price = d.price
|
|
cost_info.price_type = d.price_type
|
|
end
|
|
return cost_info
|
|
end
|
|
else
|
|
--连抽
|
|
if (cfg and cfg["120@cost_ten"]) then
|
|
local info = stringtotable(cfg["120@cost_ten"].value_content)
|
|
local cost_item_id = info[1][2]
|
|
local cost_info =
|
|
{
|
|
kind = info[1][1],
|
|
goods_id = info[1][2],
|
|
cost_num = info[1][3],
|
|
}
|
|
local price_cfg = Config.Goodsprice
|
|
if price_cfg and price_cfg[cost_item_id] then
|
|
local d = price_cfg[cost_item_id]
|
|
cost_info.price = d.price
|
|
cost_info.price_type = d.price_type
|
|
end
|
|
return cost_info
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
--人参果树抽取id
|
|
function OperateActivityModel:GetPrayTreeDrawId()
|
|
local cost_info = self:GetPrayTreeDrawCost(1)
|
|
return cost_info and cost_info.goods_id or 0
|
|
end
|
|
|
|
--人参果树最大祝福值
|
|
function OperateActivityModel:GetPrayTreeRewardList(base_type, sub_type, show_type)
|
|
if not base_type or not sub_type or not show_type then
|
|
return {}
|
|
end
|
|
local key = base_type .. "@" .. sub_type .. "@" .. show_type
|
|
if not self.pray_tree_reward_list[key] then
|
|
local rewards = CustomActivityModel.getInstance():getOneActRewardList(base_type, sub_type)
|
|
local t = self.pray_tree_reward_list
|
|
if rewards and rewards.reward_list then
|
|
local l_key
|
|
for i,v in ipairs(rewards.reward_list) do
|
|
l_key = base_type .. "@" .. sub_type .. "@" .. v.condition_list[1][2]
|
|
t[l_key] = t[l_key] or {}
|
|
local item = {[1] = v.reward_info[1].goods_kind,[2] = v.reward_info[1].goods_id, [3] = v.reward_info[1].goods_count}
|
|
table.insert(t[l_key], item)
|
|
end
|
|
end
|
|
end
|
|
return self.pray_tree_reward_list[key] or {}
|
|
end
|
|
|
|
function OperateActivityModel:PrayTreeCheckDo(can_do, price, str, ok_func)
|
|
function ok_function( )
|
|
if ok_func then
|
|
ok_func()
|
|
end
|
|
end
|
|
function toggle_function( flag )
|
|
self.pray_tree_info.custom_draw_toggle = flag
|
|
end
|
|
|
|
local show_tips_flag = self.pray_tree_info.custom_draw_toggle or false
|
|
if not can_do and not show_tips_flag then
|
|
price = price or 0
|
|
local asset, source = WordManager:GetCommonMoneyIcon(1)
|
|
local data = {
|
|
gold_ab_res = asset,
|
|
gold_res = source,
|
|
price = price,
|
|
insufficientText = "",
|
|
priceText = str,
|
|
titleText = "提示",
|
|
ok_callback = ok_function,
|
|
toggle_function = toggle_function,
|
|
}
|
|
GlobalEventSystem:Fire(EventName.OPEN_COM_TOGGLE_TIP_VIEW, data)
|
|
else
|
|
ok_func()
|
|
end
|
|
end
|
|
|
|
--人参果树红点
|
|
function OperateActivityModel:PrayTreeGetRedDot()
|
|
local b = false
|
|
if self.pray_tree_info and self.pray_tree_info.free_count then
|
|
local max_value = self:GetPrayTreeMaxValue()
|
|
b = self.pray_tree_info.free_count > 0 or self.pray_tree_info.score >= max_value
|
|
end
|
|
return b
|
|
end
|
|
---------------------------------------人参果树 end---------------------------------------
|
|
|
|
---------------------------------------合成机 start---------------------------------------
|
|
--保存收藏列表 33294
|
|
function OperateActivityModel:SetComposeRobotCollectList(vo)
|
|
self.compose_robot_collect_list[vo.sub_type] = vo.print_list
|
|
local function onSortFunction(v1, v2)
|
|
return v1.id < v2.id
|
|
end
|
|
table.sort(self.compose_robot_collect_list[vo.sub_type], onSortFunction)
|
|
end
|
|
|
|
--获取收藏列表
|
|
function OperateActivityModel:GetComposeRobotCollectList(sub_type)
|
|
if not self.compose_robot_collect_list[sub_type] then return {} end
|
|
return self.compose_robot_collect_list[sub_type]
|
|
end
|
|
|
|
--判断收藏列表中有没有该id的配方
|
|
function OperateActivityModel:IsInComposeRobotCollectList(sub_type, id)
|
|
if not self.compose_robot_collect_list[sub_type] then return false end
|
|
for k,v in pairs(self.compose_robot_collect_list[sub_type]) do
|
|
if v.id == id then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--更新收藏列表 33293
|
|
function OperateActivityModel:UpdateComposeRobotCollectList(vo)
|
|
local is_in_collect_list = self:IsInComposeRobotCollectList(vo.sub_type, vo.id)
|
|
if vo.type == 0 then--取消收藏
|
|
if is_in_collect_list then
|
|
local temp = nil
|
|
for k,v in pairs(self.compose_robot_collect_list[vo.sub_type]) do
|
|
if v.id == vo.id then
|
|
temp = v
|
|
break
|
|
end
|
|
end
|
|
if temp then
|
|
TableRemove(self.compose_robot_collect_list[vo.sub_type],temp)
|
|
end
|
|
end
|
|
elseif vo.type == 1 then--收藏
|
|
if not is_in_collect_list then
|
|
self.compose_robot_collect_list[vo.sub_type] = self.compose_robot_collect_list[vo.sub_type] or {}
|
|
local temp = {
|
|
id = vo.id,
|
|
}
|
|
table.insert(self.compose_robot_collect_list[vo.sub_type], temp)
|
|
local function onSortFunction(v1, v2)
|
|
return v1.id < v2.id
|
|
end
|
|
table.sort(self.compose_robot_collect_list[vo.sub_type], onSortFunction)
|
|
end
|
|
end
|
|
end
|
|
|
|
--保存配方状态信息 33296
|
|
function OperateActivityModel:SetComposeRobotFormulaData(vo)
|
|
self.compose_robot_formula_data[vo.sub_type] = {}
|
|
for i,v in ipairs(vo.print_list) do
|
|
self.compose_robot_formula_data[vo.sub_type][v.id] = v
|
|
end
|
|
end
|
|
|
|
--增量更新配方状态信息列表 33296
|
|
function OperateActivityModel:UpdateComposeRobotFormulaData(vo)
|
|
self.compose_robot_formula_data[vo.sub_type] = self.compose_robot_formula_data[vo.sub_type] or {}
|
|
for i,v in ipairs(vo.print_list) do
|
|
for kk,vv in pairs(self.compose_robot_formula_data[vo.sub_type]) do
|
|
if vv.id == v.id then
|
|
vv.state = v.state
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取配方状态信息列表
|
|
function OperateActivityModel:GetComposeRobotFormulaData(sub_type)
|
|
if not self.compose_robot_formula_data[sub_type] then return {} end
|
|
return self.compose_robot_formula_data[sub_type]
|
|
end
|
|
|
|
--获取某id配方的状态信息
|
|
function OperateActivityModel:GetComposeRobotFormulaStateById(sub_type, id)
|
|
if not self.compose_robot_formula_data[sub_type] or not self.compose_robot_formula_data[sub_type][id] then
|
|
return 0
|
|
end
|
|
return self.compose_robot_formula_data[sub_type][id].state
|
|
end
|
|
|
|
--保存发明家消息列表 33297
|
|
function OperateActivityModel:SetComposeRobotAnnounceData(vo)
|
|
self.compose_robot_announce_data[vo.sub_type] = vo.rold_list
|
|
local function onSortFunction(v1, v2)
|
|
return v1.id < v2.id
|
|
end
|
|
table.sort(self.compose_robot_announce_data[vo.sub_type], onSortFunction)
|
|
end
|
|
|
|
--更新发明家消息列表 33298
|
|
function OperateActivityModel:UpdateComposeRobotAnnounceData(vo)
|
|
self.compose_robot_announce_data[vo.sub_type] = self.compose_robot_announce_data[vo.sub_type] or {}
|
|
local temp_data = {
|
|
role_name = vo.role_name,
|
|
id = vo.id,
|
|
}
|
|
table.insert(self.compose_robot_announce_data[vo.sub_type],temp_data)
|
|
local function onSortFunction(v1, v2)
|
|
return v1.id < v2.id
|
|
end
|
|
table.sort(self.compose_robot_announce_data[vo.sub_type], onSortFunction)
|
|
end
|
|
|
|
--拿到发明家消息列表
|
|
function OperateActivityModel:GetComposeRobotAnnounceData(sub_type)
|
|
if not self.compose_robot_announce_data[sub_type] then return {} end
|
|
return self.compose_robot_announce_data[sub_type]
|
|
end
|
|
|
|
--拿到当前子类型合成机活动的原料套数item_suit
|
|
function OperateActivityModel:GetComposeRobotItemSuit(sub_type)
|
|
local act_data = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.COMPOSE_ROBOT,sub_type)
|
|
local item_suit_id = 0
|
|
if act_data and act_data.condition_list then
|
|
for k,v in pairs(act_data.condition_list) do
|
|
if v[1] == "item_suit" then
|
|
item_suit_id = tonumber(v[2])
|
|
end
|
|
end
|
|
end
|
|
return item_suit_id
|
|
end
|
|
|
|
--初始化合成机原材料配置
|
|
function OperateActivityModel:InitComposeRobotMaterialCfg( )
|
|
for k,v in pairs(Config.Printerdraw) do
|
|
self.compose_robot_material_cfg[v.item_suit] = self.compose_robot_material_cfg[v.item_suit] or {}
|
|
table.insert(self.compose_robot_material_cfg[v.item_suit], v)
|
|
end
|
|
for k,v in pairs(self.compose_robot_material_cfg) do
|
|
for kk,vv in pairs(v) do
|
|
local function onSortFunction(v1, v2)
|
|
return v1.exchange_item < v2.exchange_item
|
|
end
|
|
table.sort(v, onSortFunction)
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取当前子类型合成机活动的原材料配置
|
|
function OperateActivityModel:GetComposeRobotMaterialCfg(sub_type)
|
|
local item_suit = self:GetComposeRobotItemSuit(sub_type)
|
|
if not self.compose_robot_material_cfg[item_suit] then return {} end
|
|
return self.compose_robot_material_cfg[item_suit]
|
|
end
|
|
|
|
--初始化合成机配方配置
|
|
function OperateActivityModel:InitComposeRobotFormulaCfg( )
|
|
for k,v in pairs(Config.Printerdrawlist) do
|
|
self.compose_robot_formula_cfg[v.item_suit] = self.compose_robot_formula_cfg[v.item_suit] or {}
|
|
-- self.compose_robot_formula_cfg[v.item_suit][v.id] = v
|
|
table.insert(self.compose_robot_formula_cfg[v.item_suit],v)
|
|
end
|
|
end
|
|
|
|
--根据配方id获取配置
|
|
function OperateActivityModel:GetComposeRobotFormulaCfgById(sub_type,id)
|
|
local item_suit = self:GetComposeRobotItemSuit(sub_type)
|
|
if not self.compose_robot_formula_cfg[item_suit] then return nil end
|
|
for k,v in pairs(self.compose_robot_formula_cfg[item_suit]) do
|
|
if v.id == id then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--获取当前的配方配置列表
|
|
function OperateActivityModel:GetComposeRobotFormulaListCfg(sub_type)
|
|
local item_suit = self:GetComposeRobotItemSuit(sub_type)
|
|
if not self.compose_robot_formula_cfg[item_suit] then return {} end
|
|
return self.compose_robot_formula_cfg[item_suit]
|
|
end
|
|
|
|
--传入原材料id列表，判断是否合法配方并返回配置
|
|
function OperateActivityModel:JudgeCanMaterialCompose(sub_type, material_id_list)
|
|
if #material_id_list ~= 3 then return nil end
|
|
local id_list = DeepCopy(material_id_list)
|
|
local item_suit = self:GetComposeRobotItemSuit(sub_type)
|
|
if not self.compose_robot_formula_cfg[item_suit] then return nil end
|
|
--先把id_list排序一下
|
|
local function onSortFunction(v1, v2)
|
|
return v1 < v2
|
|
end
|
|
table.sort(id_list, onSortFunction)
|
|
for k,v in pairs(self.compose_robot_formula_cfg[item_suit]) do
|
|
local need_material_list = DeepCopy(stringtotable(v.exchange))
|
|
local function onSortFunction(v1, v2)
|
|
return v1 < v2
|
|
end
|
|
table.sort(need_material_list, onSortFunction)
|
|
if need_material_list[1] == id_list[1] and need_material_list[2] == id_list[2] and need_material_list[3] == id_list[3] then
|
|
return v
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
--拿到配方所需的材料列表
|
|
function OperateActivityModel:GetComposeRobotMaterialList(sub_type, formula_id)
|
|
local formula_cfg = self:GetComposeRobotFormulaCfgById(sub_type, formula_id)
|
|
if not formula_cfg then return {} end
|
|
return stringtotable(formula_cfg.exchange)
|
|
end
|
|
|
|
--初始化奖池配置
|
|
function OperateActivityModel:InitComposeRobotPoolCfg( )
|
|
for k,v in pairs(Config.Printerdrawpool) do
|
|
self.compose_robot_pool_cfg[v.pool] = self.compose_robot_pool_cfg[v.pool] or {}
|
|
table.insert(self.compose_robot_pool_cfg[v.pool], stringtotable(v.goods)[1])
|
|
|
|
self.compose_robot_normal_pool_cfg[v.pool_type] = self.compose_robot_normal_pool_cfg[v.pool_type] or {}
|
|
if v.is_show == 1 then
|
|
table.insert(self.compose_robot_normal_pool_cfg[v.pool_type], stringtotable(v.goods)[1])
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取普通奖励
|
|
function OperateActivityModel:GetComposeRobotNormalReward(sub_type)
|
|
local item_suit = self:GetComposeRobotItemSuit(sub_type)
|
|
if not self.compose_robot_normal_pool_cfg[item_suit] then return {} end
|
|
return self.compose_robot_normal_pool_cfg[item_suit]
|
|
end
|
|
|
|
--根据奖池id获取奖池列表
|
|
function OperateActivityModel:GetComposeRobotRewardList(pool_id)
|
|
if not self.compose_robot_pool_cfg[pool_id] then return {} end
|
|
return self.compose_robot_pool_cfg[pool_id]
|
|
end
|
|
|
|
--材料数量更新
|
|
function OperateActivityModel:OnMaterialGoodsNumUpdate( )
|
|
self:Fire(OperateActivityModel.UPDATE_COMPOSE_ROBOT_MATERIAL_GOODS_NUM)
|
|
local sub_type_list = CustomActivityModel:getInstance():getAllActListByBaseType(CustomActivityModel.CustomActBaseType.COMPOSE_ROBOT)
|
|
for k,v in pairs(sub_type_list) do
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.ComposeRobot,nil,v.sub_type)
|
|
end
|
|
end
|
|
|
|
--获取当前的选中材料列表
|
|
function OperateActivityModel:GetNowUseComposeMaterial(sub_type)
|
|
if not self.compose_robot_now_use_material_list[sub_type] then
|
|
self.compose_robot_now_use_material_list[sub_type] = {
|
|
[1] = 0,
|
|
[2] = 0,
|
|
[3] = 0,
|
|
}
|
|
end
|
|
return self.compose_robot_now_use_material_list[sub_type]
|
|
end
|
|
|
|
--加入材料到选中列表
|
|
function OperateActivityModel:AddComposeMaterial(sub_type, goods_id)
|
|
if not self.compose_robot_now_use_material_list[sub_type] then
|
|
self.compose_robot_now_use_material_list[sub_type] = {
|
|
[1] = 0,
|
|
[2] = 0,
|
|
[3] = 0,
|
|
}
|
|
end
|
|
local add_index = 0
|
|
for i,v in ipairs(self.compose_robot_now_use_material_list[sub_type]) do
|
|
if v == 0 then
|
|
self.compose_robot_now_use_material_list[sub_type][i] = goods_id
|
|
add_index = i
|
|
break
|
|
end
|
|
end
|
|
return add_index
|
|
end
|
|
|
|
--取消选中材料
|
|
function OperateActivityModel:MinusComposeMaterial(sub_type, pos_index)
|
|
if self.compose_robot_now_use_material_list[sub_type] then
|
|
self.compose_robot_now_use_material_list[sub_type][pos_index] = 0
|
|
end
|
|
end
|
|
|
|
--重置选中列表
|
|
function OperateActivityModel:ResetUseComposeMaterialList(sub_type)
|
|
self.compose_robot_now_use_material_list[sub_type] = {
|
|
[1] = 0,
|
|
[2] = 0,
|
|
[3] = 0,
|
|
}
|
|
end
|
|
|
|
--保存活动开启的红点
|
|
function OperateActivityModel:SetComposeRobotActFirstRed(sub_type)
|
|
self.compose_robot_act_first_red[sub_type] = true
|
|
end
|
|
|
|
--记录是否打开过界面的标识
|
|
function OperateActivityModel:SetComposeRobotViewOpenState(sub_type)
|
|
self.compose_robot_have_open_view[sub_type] = true
|
|
end
|
|
|
|
function OperateActivityModel:CheckComposeRobotActFirstRedDot(sub_type)
|
|
if not self.compose_robot_have_open_view[sub_type] and self.compose_robot_act_first_red[sub_type] and not self.is_in_compose_view[sub_type]then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function OperateActivityModel:CheckComposeRobotCanComposeRed(sub_type)
|
|
self.compose_robot_red_info[sub_type] = false
|
|
if self.is_in_compose_view[sub_type] then
|
|
return false
|
|
end
|
|
local formula_list = DeepCopy(self:GetComposeRobotFormulaListCfg(sub_type))
|
|
for i,v in ipairs(formula_list) do
|
|
v.formula_state =self:GetComposeRobotFormulaStateById(sub_type,v.id)
|
|
local material_list = self:GetComposeRobotMaterialList(sub_type,v.id)
|
|
local main_need_material_list = {}
|
|
for ii,vv in ipairs(material_list) do
|
|
local goods_num = GoodsModel:getInstance():GetTypeGoodsNum(vv)
|
|
if not main_need_material_list[vv] then
|
|
main_need_material_list[vv] = {
|
|
id = vv,
|
|
need_num = 1,
|
|
bag_goods_num = goods_num
|
|
}
|
|
else
|
|
main_need_material_list[vv].need_num = main_need_material_list[vv].need_num + 1
|
|
end
|
|
end
|
|
local max_can_get_num = 99999999
|
|
for m,n in pairs(main_need_material_list) do
|
|
local multi = math.floor(n.bag_goods_num/n.need_num)
|
|
if multi < max_can_get_num then
|
|
max_can_get_num = multi
|
|
end
|
|
end
|
|
if max_can_get_num > 0 then
|
|
self.compose_robot_red_info[sub_type] = true
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--得到合成级红点
|
|
function OperateActivityModel:GetComposeRobotMainRed(sub_type)
|
|
local can_compose_red = self:CheckComposeRobotCanComposeRed(sub_type)
|
|
local first_red = self:CheckComposeRobotActFirstRedDot(sub_type)
|
|
if first_red or can_compose_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
--询问cd状态
|
|
function OperateActivityModel:SetComposeRobotAskCd(vo)
|
|
self.compose_robot_ask_time[vo.sub_type] = vo.time
|
|
end
|
|
|
|
function OperateActivityModel:GetComposeRobotAskCd(sub_type)
|
|
if not self.compose_robot_ask_time[sub_type] then return 0 end
|
|
return self.compose_robot_ask_time[sub_type]
|
|
end
|
|
---------------------------------------合成机 end---------------------------------------
|
|
|
|
|
|
|
|
---------------------------------------自选扭蛋 start---------------------------------------
|
|
--33600 保存自选扭蛋相关数据
|
|
function OperateActivityModel:SetSelectEggServerData(vo)
|
|
self.select_egg_ser_data[vo.sub_type] = {}
|
|
self.select_egg_ser_data[vo.sub_type].sub_type = vo.sub_type
|
|
self.select_egg_ser_data[vo.sub_type].reward_list = {}
|
|
for k,v in pairs(vo.reward_list) do--已抽中的奖励列表
|
|
local rewards_data = stringtotable(v.rewards)
|
|
self.select_egg_ser_data[vo.sub_type].reward_list[v.rare] = rewards_data
|
|
end
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list = {}
|
|
for k,v in pairs(vo.select_reward_list) do--已选择的奖励列表
|
|
local rewards_data = stringtotable(v.rewards)
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list[v.rare] = rewards_data
|
|
end
|
|
self.select_egg_ser_data[vo.sub_type].cfg_reward_list = {}
|
|
for k,v in pairs(vo.cfg_reward_list) do--本期活动的奖池
|
|
local rewards_data = stringtotable(v.cfg_rewards)
|
|
self.select_egg_ser_data[vo.sub_type].cfg_reward_list[v.cfg_rare] = rewards_data
|
|
end
|
|
self.select_egg_ser_data[vo.sub_type].cost_goods_type_id = vo.cost_goods_type_id--下一抽消耗物品类型Id
|
|
self.select_egg_ser_data[vo.sub_type].cost_num = vo.cost_num--下一抽消耗物品数量
|
|
self.select_egg_ser_data[vo.sub_type].left_reset_times = vo.left_reset_times--剩余重置次数
|
|
self.select_egg_ser_data[vo.sub_type].is_ensure = vo.is_ensure--是否确认奖励
|
|
end
|
|
|
|
--33601 选择奖励后更新选中的奖励列表
|
|
function OperateActivityModel:UpdateSelectEggSelectRewardList(vo)
|
|
if not self.select_egg_ser_data[vo.sub_type] then return end
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list = {}
|
|
for k,v in pairs(vo.select_reward_list) do
|
|
local rewards_data = stringtotable(v.rewards)
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list[v.rare] = rewards_data
|
|
end
|
|
end
|
|
|
|
--33603 抽奖后更新相关数据
|
|
function OperateActivityModel:UpdateSelectEggDataAfterDraw(vo)
|
|
if not self.select_egg_ser_data[vo.sub_type] then return end
|
|
self.select_egg_ser_data[vo.sub_type].reward_list = self.select_egg_ser_data[vo.sub_type].reward_list or {}
|
|
self.select_egg_ser_data[vo.sub_type].reward_list[vo.rare] = self.select_egg_ser_data[vo.sub_type].reward_list[vo.rare] or {}
|
|
local rewards_data = stringtotable(vo.rewards)
|
|
table.insert(self.select_egg_ser_data[vo.sub_type].reward_list[vo.rare],rewards_data[1])
|
|
|
|
self.select_egg_ser_data[vo.sub_type].cost_goods_type_id = vo.cost_goods_type_id--下一抽消耗物品类型Id
|
|
self.select_egg_ser_data[vo.sub_type].cost_num = vo.cost_num--下一抽消耗物品数量
|
|
self.select_egg_ser_data[vo.sub_type].is_ensure = vo.is_ensure--是否确认奖励
|
|
end
|
|
|
|
--33604 快速选奖更新相关数据
|
|
function OperateActivityModel:UpdateSelectEggDataAfterQuiclSelect(vo)
|
|
if not self.select_egg_ser_data[vo.sub_type] then return end
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list = {}
|
|
for k,v in pairs(vo.select_reward_list) do--已选择的奖励列表
|
|
local rewards_data = stringtotable(v.rewards)
|
|
self.select_egg_ser_data[vo.sub_type].select_reward_list[v.rare] = rewards_data
|
|
end
|
|
end
|
|
|
|
--33605 刷新确认状态
|
|
function OperateActivityModel:UpdateSelectEggEnsureState(vo)
|
|
if not self.select_egg_ser_data[vo.sub_type] then return end
|
|
self.select_egg_ser_data[vo.sub_type].is_ensure = vo.is_ensure--是否确认奖励
|
|
end
|
|
|
|
--是否已经确认奖池
|
|
function OperateActivityModel:IsSelectEggPoolEnsure(sub_type)
|
|
if not self.select_egg_ser_data[sub_type] then return false end
|
|
return self.select_egg_ser_data[sub_type].is_ensure or false
|
|
end
|
|
|
|
--获取选中的奖励列表
|
|
function OperateActivityModel:GetSelectEggSelectRewardListByRare(sub_type,rare)
|
|
if not self.select_egg_ser_data[sub_type] then return {} end
|
|
if not self.select_egg_ser_data[sub_type].select_reward_list then return {} end
|
|
return self.select_egg_ser_data[sub_type].select_reward_list[rare] or {}
|
|
end
|
|
|
|
--判断物品是否已经在选中列表中
|
|
function OperateActivityModel:IsInSelectEggSelectRewardList(sub_type,reward_id)
|
|
if not self.select_egg_ser_data[sub_type] then return false end
|
|
if not self.select_egg_ser_data[sub_type].select_reward_list then return false end
|
|
|
|
for k,v in pairs(self.select_egg_ser_data[sub_type].select_reward_list) do
|
|
for m,n in pairs(v) do
|
|
if n[1] == reward_id then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--判断物品是否在已抽中列表中
|
|
function OperateActivityModel:IsInSelectEggGetRewardList(sub_type,reward_id)
|
|
if not self.select_egg_ser_data[sub_type] then return false end
|
|
if not self.select_egg_ser_data[sub_type].reward_list then return false end
|
|
|
|
local bool = false
|
|
for k,v in pairs(self.select_egg_ser_data[sub_type].reward_list) do
|
|
for m,n in pairs(v) do
|
|
if n[1] == reward_id then
|
|
bool = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return bool
|
|
end
|
|
|
|
--快速选择奖励，返回奖励id列表
|
|
function OperateActivityModel:GetQuickSelectRewardList(sub_type,rare)
|
|
if not self.select_egg_ser_data[sub_type] then return {} end
|
|
if not self.select_egg_ser_data[sub_type].cfg_reward_list then return {} end
|
|
if not self.select_egg_ser_data[sub_type].cfg_reward_list[rare] then return {} end
|
|
|
|
local not_select_list = {}
|
|
for k,v in pairs(self.select_egg_ser_data[sub_type].cfg_reward_list[rare]) do
|
|
if not self:IsInSelectEggSelectRewardList(sub_type,v[1]) then
|
|
table.insert(not_select_list,v[1])
|
|
end
|
|
end
|
|
|
|
local select_reward_list = self:GetSelectEggSelectRewardListByRare(sub_type,rare)
|
|
local left_can_select_num = 0
|
|
if rare == 1 then
|
|
left_can_select_num = 1-#select_reward_list
|
|
elseif rare == 2 then
|
|
left_can_select_num = 3-#select_reward_list
|
|
elseif rare == 3 then
|
|
left_can_select_num = 4-#select_reward_list
|
|
end
|
|
|
|
if left_can_select_num == 0 then return {} end
|
|
|
|
local final_list = {}
|
|
for i=1,left_can_select_num do
|
|
local random_index = math.random(1, #not_select_list)
|
|
table.insert(final_list,not_select_list[random_index])
|
|
table.remove(not_select_list,random_index)
|
|
end
|
|
|
|
return final_list
|
|
end
|
|
|
|
--获取现在的中奖列表
|
|
function OperateActivityModel:GetSelectEggAllRewardList(sub_type)
|
|
if not self.select_egg_ser_data[sub_type] then return {} end
|
|
if not self.select_egg_ser_data[sub_type].reward_list then return {} end
|
|
local all_list = {}
|
|
for k,v in pairs(self.select_egg_ser_data[sub_type].reward_list) do
|
|
for m,n in pairs(v) do
|
|
table.insert(all_list,n)
|
|
end
|
|
end
|
|
return all_list
|
|
end
|
|
|
|
--根据稀有度获取奖池列表
|
|
function OperateActivityModel:GetSelectEggPoolRewardListByRare(sub_type,rare)
|
|
if not self.select_egg_ser_data[sub_type] then return {} end
|
|
if not self.select_egg_ser_data[sub_type].cfg_reward_list then return {} end
|
|
return self.select_egg_ser_data[sub_type].cfg_reward_list[rare] or {}
|
|
end
|
|
|
|
--根据稀有度获取抽中的奖励列表
|
|
function OperateActivityModel:GetSelectEggGottenRewardListByRare(sub_type,rare)
|
|
if not self.select_egg_ser_data[sub_type] then return {} end
|
|
if not self.select_egg_ser_data[sub_type].reward_list then return {} end
|
|
return self.select_egg_ser_data[sub_type].reward_list[rare] or {}
|
|
end
|
|
|
|
--获取下次抽奖的消耗信息
|
|
function OperateActivityModel:GetSelectEggNextDrawCostData(sub_type)
|
|
if not self.select_egg_ser_data[sub_type] then return nil,nil end
|
|
return self.select_egg_ser_data[sub_type].cost_goods_type_id,self.select_egg_ser_data[sub_type].cost_num
|
|
end
|
|
|
|
--获取剩余重置次数
|
|
function OperateActivityModel:GetSelectEggLeftResetTimes(sub_type)
|
|
if not self.select_egg_ser_data[sub_type] then return 0 end
|
|
return self.select_egg_ser_data[sub_type].left_reset_times
|
|
end
|
|
|
|
--判断当前扭蛋阶段（开始抽奖了就表示不可以抽了）（判断依据是服务端发回来的reward_list长度）
|
|
--1|选奖阶段 #reward_list==0 不可抽奖 不可重置 只能选奖
|
|
--2|抽奖阶段 #reward_list>0 or ensure == 1 不可选奖 可重置 可抽奖
|
|
--3|抽完阶段 #reward_list==8 不可选奖 可重置 不可抽奖
|
|
--4|奖励选完待确认 #reward_list == 0 and #select_reward == 8 and ensure == 0可选奖 不可重置 不可抽奖
|
|
--5|奖励选完可以开抽 #reward_list == 0 and #select_reward == 8 and ensure == 1不可选奖 可重置 可抽奖
|
|
function OperateActivityModel:GetSelectEggNowPlayState(sub_type)
|
|
local all_reward_list = self:GetSelectEggAllRewardList(sub_type)
|
|
local ensure = self:IsSelectEggPoolEnsure(sub_type)
|
|
if #all_reward_list == 0 then
|
|
local select_reward_list_1 = self:GetSelectEggSelectRewardListByRare(sub_type,1)
|
|
local select_reward_list_2 = self:GetSelectEggSelectRewardListByRare(sub_type,2)
|
|
local select_reward_list_3 = self:GetSelectEggSelectRewardListByRare(sub_type,3)
|
|
if #select_reward_list_1 + #select_reward_list_2 + #select_reward_list_3 == 8 and ensure == 0 then
|
|
return 4
|
|
elseif #select_reward_list_1 + #select_reward_list_2 + #select_reward_list_3 == 8 and ensure == 1 then
|
|
return 5
|
|
else
|
|
return 1
|
|
end
|
|
elseif #all_reward_list > 0 and #all_reward_list < 8 then
|
|
return 2
|
|
elseif #all_reward_list == 8 then
|
|
return 3
|
|
end
|
|
return 0
|
|
end
|
|
|
|
|
|
|
|
--得到自选扭蛋红点
|
|
-- 红点规则：
|
|
-- 1、玩家有足够抽奖道具时红点提示【扭一次】
|
|
-- 2、玩家所有道具抽取完，且存在重置次数，红点提示【重置奖励】
|
|
function OperateActivityModel:GetSelectEggMainRed(sub_type)
|
|
local can_draw_red = self:CheckSelectEggCanFDrawRed(sub_type,true)
|
|
local can_reset_red = self:CheckSelectEggCanResetRed(sub_type,true)
|
|
local can_ensure_red = self:CheckSelectEggCanEnsureRed(sub_type,true)
|
|
local com_act_red = self:CheckSelectEggComActRed(sub_type,true)
|
|
if can_draw_red or can_reset_red or can_ensure_red or com_act_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
--自选扭蛋有道具可抽奖红点
|
|
function OperateActivityModel:CheckSelectEggCanFDrawRed(sub_type,check_new)
|
|
if not check_new then
|
|
if self.select_egg_red_info[sub_type] and self.select_egg_red_info[sub_type].can_draw_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
------------------
|
|
self.select_egg_red_info[sub_type] = self.select_egg_red_info[sub_type] or {}
|
|
local bool = false
|
|
local state = self:GetSelectEggNowPlayState(sub_type)
|
|
if state~=2 and state~=5 then
|
|
bool = false
|
|
else
|
|
--判断当前抽奖所需消耗的道具数量是否足够
|
|
local cost_goods_type_id,cost_need_num = self:GetSelectEggNextDrawCostData(sub_type)
|
|
if cost_goods_type_id and cost_need_num then
|
|
local have_cost_num = GoodsModel:getInstance():GetTypeGoodsNum(cost_goods_type_id)
|
|
if have_cost_num >= cost_need_num then
|
|
bool = true
|
|
end
|
|
end
|
|
end
|
|
self.select_egg_red_info[sub_type].can_draw_red = bool
|
|
return bool
|
|
end
|
|
|
|
--自选扭蛋可重置红点
|
|
function OperateActivityModel:CheckSelectEggCanResetRed(sub_type,check_new)
|
|
if not check_new then
|
|
if self.select_egg_red_info[sub_type] and self.select_egg_red_info[sub_type].can_reset_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
------------------
|
|
self.select_egg_red_info[sub_type] = self.select_egg_red_info[sub_type] or {}
|
|
local bool = false
|
|
--这轮抽完且有重置次数才能给红点
|
|
local state = self:GetSelectEggNowPlayState(sub_type)
|
|
local left_reset_times = self:GetSelectEggLeftResetTimes(sub_type)
|
|
if state == 3 and left_reset_times > 0 then
|
|
bool = true
|
|
end
|
|
|
|
self.select_egg_red_info[sub_type].can_reset_red = bool
|
|
return bool
|
|
end
|
|
|
|
--确认红点
|
|
function OperateActivityModel:CheckSelectEggCanEnsureRed(sub_type,check_new)
|
|
if not check_new then
|
|
if self.select_egg_red_info[sub_type] and self.select_egg_red_info[sub_type].can_ensure_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
------------------
|
|
self.select_egg_red_info[sub_type] = self.select_egg_red_info[sub_type] or {}
|
|
local bool = false
|
|
|
|
local state = self:GetSelectEggNowPlayState(sub_type)
|
|
bool = state == 4
|
|
|
|
self.select_egg_red_info[sub_type].can_ensure_red = bool
|
|
return bool
|
|
end
|
|
|
|
--自选扭蛋通用礼包
|
|
function OperateActivityModel:CheckSelectEggComActRed(sub_type,check_new)
|
|
if not check_new then
|
|
if self.select_egg_red_info[sub_type] and self.select_egg_red_info[sub_type].com_act_red then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
------------------
|
|
self.select_egg_red_info[sub_type] = self.select_egg_red_info[sub_type] or {}
|
|
local bool = false
|
|
|
|
local com_act_red_info = CustomActivityModel:getInstance():GetActComAwardInfo(CustomActivityModel.CustomActBaseType.SELECT_EGG,sub_type)
|
|
if com_act_red_info then
|
|
bool = com_act_red_info.status == 1
|
|
end
|
|
|
|
self.select_egg_red_info[sub_type].com_act_red = bool
|
|
return bool
|
|
end
|
|
|
|
--自选扭蛋消耗道具数量更新 通知刷红点
|
|
function OperateActivityModel:OnSelectEggCostGoodsNumChange( )
|
|
local sub_type_list = CustomActivityModel:getInstance():getAllActListByBaseType(CustomActivityModel.CustomActBaseType.SELECT_EGG)
|
|
for k,v in pairs(sub_type_list) do
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.SelectEgg,nil,v.sub_type)
|
|
end
|
|
end
|
|
|
|
---------------------------------------自选扭蛋 end---------------------------------------
|
|
|
|
|
|
|
|
|
|
---------------------------------------材料上交 start------------------------------------
|
|
function OperateActivityModel:SetMaterialSubmitInfo( vo )
|
|
self.material_submit_info[vo.sub_type] = {}
|
|
|
|
local buffs_dot_list = {}--buff点位信息
|
|
local buffs_bid_list = {}--buff id信息
|
|
for i,v in ipairs(vo.buffs) do
|
|
buffs_dot_list[v.dot] = v
|
|
buffs_bid_list[v.bid] = v
|
|
end
|
|
|
|
local role_awards_dot_list = {}
|
|
for i,v in ipairs(vo.role_awards) do
|
|
role_awards_dot_list[v.dot] = v
|
|
end
|
|
|
|
local server_awards_dot_list = {}
|
|
for i,v in ipairs(vo.server_awards) do
|
|
server_awards_dot_list[v.dot] = v
|
|
end
|
|
|
|
self.material_submit_info[vo.sub_type].server_pro = vo.server_pro
|
|
self.material_submit_info[vo.sub_type].role_pro = vo.role_pro
|
|
self.material_submit_info[vo.sub_type].buffs_dot_list = buffs_dot_list
|
|
self.material_submit_info[vo.sub_type].buffs_bid_list = buffs_bid_list
|
|
self.material_submit_info[vo.sub_type].role_awards_dot_list = role_awards_dot_list
|
|
self.material_submit_info[vo.sub_type].server_awards_dot_list = server_awards_dot_list
|
|
end
|
|
|
|
function OperateActivityModel:GetMaterialSubmitInfo( subtype )
|
|
return self.material_submit_info[subtype]
|
|
end
|
|
|
|
--检查材料上交红点
|
|
function OperateActivityModel:CheckMaterialSubmitRedDot( base_type,sub_type )
|
|
local server_info = self:GetMaterialSubmitInfo(sub_type)
|
|
if not server_info then return false end
|
|
local act_list = CustomActivityModel:getInstance():getActList(base_type, sub_type)
|
|
if not act_list then return false end
|
|
local group_num = 0
|
|
local suit_sub_id = nil
|
|
local cost_id = 0
|
|
for k,v in pairs(act_list.condition_list) do--[{role_lv,80},{sub,1},{cost,30},{group,5}]
|
|
if v[1] == "suit" then--全服进度套件ID
|
|
suit_sub_id = tonumber(v[2])
|
|
elseif v[1] == "group" then--材料提交份数
|
|
group_num = tonumber(v[2])
|
|
elseif v[1] == "cost_type" then--材料提交份数
|
|
cost_id = tonumber(v[2])
|
|
end
|
|
end
|
|
local num = GoodsModel:getInstance():GetTypeGoodsNum(cost_id) or 0
|
|
if num >= group_num then
|
|
return true
|
|
end
|
|
|
|
--先计算个人奖励的
|
|
local award_data = CustomActivityModel:getInstance():getOneActRewardList(base_type,sub_type)
|
|
if not award_data or not award_data.reward_list then return false end
|
|
local submit = 0
|
|
for k,v in pairs(award_data.reward_list) do
|
|
submit = 0
|
|
for kk,vv in pairs(v.condition_list) do
|
|
if vv[1] == "submit" then--点数需求
|
|
submit = tonumber(vv[2])
|
|
break
|
|
end
|
|
end
|
|
if server_info.role_pro >= submit and not server_info.role_awards_dot_list[v.grade] then
|
|
return true
|
|
end
|
|
end
|
|
|
|
--计算全服奖励的
|
|
local server_award_cfg = self:GetMaterialSubmitServerCfg(suit_sub_id)
|
|
if server_award_cfg then
|
|
for k,v in ipairs(server_award_cfg) do
|
|
if v.type == 3 and server_info.server_pro >= v.need and not server_info.server_awards_dot_list[v.dot] then
|
|
return true
|
|
elseif server_info.server_awards_dot_list and v.type == 2 then
|
|
if server_info.server_pro >= v.need and not server_info.server_awards_dot_list[v.dot] then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
--初始化材料上交全服配置
|
|
function OperateActivityModel:InitMaterialSubmitServerCfg( )
|
|
if not self.material_submit_server_cfg then
|
|
self.material_submit_server_cfg = {}
|
|
local cfg = DeepCopy(Config.Unitebuffawards)
|
|
for k,v in pairs(cfg) do
|
|
if v.type == 2 or v.type == 3 then
|
|
v.awards = stringtotable(v.awards)
|
|
end
|
|
if not self.material_submit_server_cfg[v.suit] then
|
|
self.material_submit_server_cfg[v.suit] = {}
|
|
end
|
|
self.material_submit_server_cfg[v.suit][#self.material_submit_server_cfg[v.suit] + 1] = v
|
|
end
|
|
end
|
|
end
|
|
|
|
--获取材料上交全服配置
|
|
function OperateActivityModel:GetMaterialSubmitServerCfg( suit,dot )
|
|
if not self.material_submit_server_cfg then
|
|
self:InitMaterialSubmitServerCfg()
|
|
end
|
|
if not dot then
|
|
return self.material_submit_server_cfg[suit]
|
|
elseif self.material_submit_server_cfg[suit] and dot then
|
|
for i,v in ipairs(self.material_submit_server_cfg[suit]) do
|
|
if v.dot == dot then
|
|
return v
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function OperateActivityModel:GetMaterialSubmitCostId( sub_type )
|
|
local cost_id = nil
|
|
local act_list = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.MATERIAL_SUBMIT, sub_type)
|
|
if not act_list then
|
|
return
|
|
end
|
|
for k,v in pairs(act_list.condition_list) do--[{role_lv,80},{sub,1},{cost,30},{group,5}]
|
|
if v[1] == "cost_type" then--提交消耗材料
|
|
cost_id = tonumber(v[2])
|
|
break
|
|
end
|
|
end
|
|
return cost_id
|
|
end
|
|
|
|
--通过类型获得相关BUFF加成
|
|
function OperateActivityModel:GetMaterialBuffInfoByKind( kind )
|
|
if self.material_submit_info then
|
|
local curTime = TimeUtil:getServerTime()
|
|
local buff_list = {}
|
|
for k,v in pairs(self.material_submit_info) do
|
|
for kk,vv in pairs(v.buffs_bid_list) do
|
|
if Config.Unitebuff[kk] and Config.Unitebuff[kk].kind == kind and vv.stime < curTime and curTime < vv.etime then--激活
|
|
buff_list[#buff_list + 1] = vv
|
|
end
|
|
end
|
|
end
|
|
|
|
local len = #buff_list
|
|
if len > 0 and len == 1 then
|
|
return Config.Unitebuff[buff_list[1].bid],DeepCopy(buff_list[1]),buff_list[1].dot
|
|
elseif len >= 2 then
|
|
local cur_data = nil
|
|
for k,v in ipairs(buff_list) do
|
|
if not cur_data then
|
|
cur_data = v
|
|
else
|
|
local cur_data_cfg = Config.Unitebuff[cur_data.bid]
|
|
local next_cfg = Config.Unitebuff[v.bid]
|
|
cur_data = cur_data_cfg.data > next_cfg.data and cur_data or v
|
|
end
|
|
end
|
|
if cur_data then
|
|
return Config.Unitebuff[cur_data.bid],DeepCopy(cur_data),cur_data.dot
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
--设置集字红点提示cookie
|
|
function OperateActivityModel:SetJiZiRedDotTipCookie( sub_type,grade,no_show_red )
|
|
local list = self:GetJiZiRedDotTipCookie() or {}
|
|
list[sub_type] = list[sub_type] or {}
|
|
list[sub_type][grade] = no_show_red
|
|
CookieWrapper.Instance:SaveCookie(CookieLevelType.Account,CookieTimeType.TYPE_ALWAYS,CookieKey.OP_JI_ZI_RED_DOT_TIP,list)
|
|
CookieWrapper.Instance:WriteAll()
|
|
KfActivityModel:getInstance():IsNeedRed(KfActivityModel.TabID.CollectZi,nil,sub_type)
|
|
end
|
|
|
|
--获得集字红点提示cookie
|
|
function OperateActivityModel:GetJiZiRedDotTipCookie( )
|
|
local list = CookieWrapper.Instance:GetCookie(CookieLevelType.Account,CookieKey.OP_JI_ZI_RED_DOT_TIP) or {}
|
|
return list
|
|
end
|
|
|
|
--获得Boss掉落活动展示奖励
|
|
function OperateActivityModel:GetBossActDropAward( sub_type )
|
|
--如果有BOSS掉落活动 这里要添加展示奖励
|
|
local award_list = {}
|
|
local sub_type = sub_type or CustomActivityModel:getInstance():getActMinSubType(CustomActivityModel.CustomActBaseType.BOSS_DROP)
|
|
local act_list = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.BOSS_DROP, sub_type)
|
|
if act_list then
|
|
local drop_type = nil
|
|
local drop_goods_id = nil
|
|
for i,v in ipairs(act_list.condition_list) do
|
|
if v[1] and v[2] then
|
|
if v[1] == "drop_type" then
|
|
drop_type = tonumber(v[2])
|
|
elseif v[1] == "drop_goods" then
|
|
drop_goods_id = tonumber(v[2])
|
|
end
|
|
end
|
|
end
|
|
if drop_type and not (drop_type >= 101 and not drop_goods_id) then
|
|
local drop_time_limit_cfg = OperateActivityModel:getInstance():GetBossDropTimeLimitCfg(drop_type)
|
|
if not drop_time_limit_cfg then return end
|
|
local item_list = DeepCopy(drop_time_limit_cfg)
|
|
if not item_list or TableSize(item_list) == 0 then
|
|
return
|
|
end
|
|
local new_list = {}
|
|
for i,v in pairs(item_list) do
|
|
new_list[#new_list + 1] = v
|
|
end
|
|
local sort_func = function ( a, b )
|
|
return a.drop_way < b.drop_way
|
|
end
|
|
table.sort(new_list, sort_func)
|
|
item_list = new_list
|
|
|
|
if drop_type < 101 then
|
|
for i,v in ipairs(item_list) do
|
|
for ii,vv in ipairs(v.award) do
|
|
if vv[2] then
|
|
award_list[#award_list + 1] = vv[2]
|
|
end
|
|
end
|
|
break
|
|
end
|
|
else
|
|
award_list = {{0,drop_goods_id,1}}
|
|
end
|
|
end--没有展示奖励立即退出
|
|
end
|
|
return award_list
|
|
end
|