742 lines
28 KiB
Lua
742 lines
28 KiB
Lua
local BattlePassUtils = {}
|
|
|
|
function BattlePassUtils.CheckBattlePassSeasonValid()
|
|
local seasonData = GameInstance.player.battlePassSystem.seasonData
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
if string.isEmpty(seasonData.seasonId) or curServerTime < seasonData.openTime or curServerTime >= seasonData.closeTime then
|
|
return false
|
|
end
|
|
if seasonData.closeInfo ~= nil and seasonData.closeInfo.isClose then
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
function BattlePassUtils.CheckBattlePassPurchaseBlock()
|
|
return BLOCK_BATTLEPASS_PURCHASE or (CashShopUtils.IsPS() and CashShopUtils.NoCashShopGoods())
|
|
end
|
|
|
|
function BattlePassUtils.GetSeasonLeftTime()
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return 0
|
|
end
|
|
local closeTime = GameInstance.player.battlePassSystem.seasonData.closeTime
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
if curServerTime > closeTime then
|
|
return 0
|
|
end
|
|
return closeTime - curServerTime
|
|
end
|
|
|
|
function BattlePassUtils.GetSeasonLastDay()
|
|
return UIUtils.getLeftTime(BattlePassUtils.GetSeasonLeftTime())
|
|
end
|
|
|
|
function BattlePassUtils.CheckBattlePassJumpAvail(jumpId)
|
|
local hasJump, jumpInfo = Tables.systemJumpTable:TryGetValue(jumpId)
|
|
if not hasJump then
|
|
return false
|
|
end
|
|
if not lume.find(Tables.battlePassConst.jumpForbidGameMode, GameInstance.mode.modeType) then
|
|
return true
|
|
end
|
|
if lume.find(Tables.battlePassConst.jumpForbidSystemWhiteList, jumpInfo.bindSystem) then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.GetBattlePassTrackName(trackType)
|
|
local trackName = ''
|
|
for _, trackData in pairs(Tables.battlePassTrackTable) do
|
|
if trackData.trackType == trackType then
|
|
trackName = trackData.name
|
|
break
|
|
end
|
|
end
|
|
return trackName
|
|
end
|
|
|
|
function BattlePassUtils.CheckBattlePassItemCanUse(itemId)
|
|
local seasonValid = BattlePassUtils.CheckBattlePassSeasonValid()
|
|
if not seasonValid then
|
|
return false, Language.LUA_BATTLEPASS_TICKET_SEASON_INVALID
|
|
end
|
|
local hasTrackType, trackType = BattlePassUtils.GetBattlePassTicketTrackType(itemId)
|
|
if not hasTrackType then
|
|
return false, Language.LUA_BATTLEPASS_TICKET_TICKET_INVALID
|
|
end
|
|
local trackName = BattlePassUtils.GetBattlePassTrackName(trackType)
|
|
local trackActivate = BattlePassUtils.CheckBattlePassTrackActive(trackType)
|
|
if trackActivate then
|
|
return false, string.format(Language.LUA_BATTLEPASS_TICKET_TRACK_INVALID, trackName)
|
|
end
|
|
return true
|
|
end
|
|
|
|
function BattlePassUtils.TryUseBattlePassItem(itemId, instId)
|
|
local canUse, cantReason = BattlePassUtils.CheckBattlePassItemCanUse(itemId)
|
|
if not canUse then
|
|
Notify(MessageConst.SHOW_TOAST, cantReason)
|
|
end
|
|
local hasTrackType, trackType = BattlePassUtils.GetBattlePassTicketTrackType(itemId)
|
|
if not hasTrackType then
|
|
return
|
|
end
|
|
local trackName = BattlePassUtils.GetBattlePassTrackName(trackType)
|
|
local itemName = Tables.itemTable[itemId].name
|
|
local hintFormat = nil
|
|
if trackType == GEnums.BPTrackType.PAY then
|
|
hintFormat = Language.LUA_BATTLEPASS_TICKET_PAY_USE_HINT
|
|
else
|
|
hintFormat = Language.LUA_BATTLEPASS_TICKET_ORG_USE_HINT
|
|
end
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = string.format(hintFormat, itemName, trackName),
|
|
onConfirm = function()
|
|
if BattlePassUtils.TimeCloseToEnd() then
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = string.format(Language.LUA_BATTLEPASS_BUY_TRACK_SUBTITLE, BattlePassUtils.GetSeasonLastDay()),
|
|
onConfirm = function()
|
|
GameInstance.player.inventory:UseBattlePassItem(itemId, instId)
|
|
end
|
|
})
|
|
return
|
|
end
|
|
GameInstance.player.inventory:UseBattlePassItem(itemId, instId)
|
|
end,
|
|
})
|
|
end
|
|
|
|
function BattlePassUtils.GetBattlePassTicketTrackType(itemId)
|
|
for _, orgItemId in pairs(Tables.battlePassConst.voucherOriginiumTrack) do
|
|
if itemId == orgItemId then
|
|
return true, GEnums.BPTrackType.ORIGINIUM
|
|
end
|
|
end
|
|
for _, payItemId in pairs(Tables.battlePassConst.voucherPayTrack) do
|
|
if itemId == payItemId then
|
|
return true, GEnums.BPTrackType.PAY
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckBattlePassTrackActive(trackType)
|
|
local trackData = GameInstance.player.battlePassSystem.trackData
|
|
for trackId, playerTrack in pairs(trackData.trackRewards) do
|
|
local hasTrack, trackInfo = Tables.battlePassTrackTable:TryGetValue(trackId)
|
|
if hasTrack and trackInfo.trackType == trackType then
|
|
return true, playerTrack
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.GetBattlePassExpBoost()
|
|
local expBoost = 0
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return expBoost
|
|
end
|
|
local trackTable = Tables.battlePassTrackTable
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
for trackId, trackData in pairs(trackTable) do
|
|
if bpSystem.trackData.trackRewards:ContainsKey(trackId) then
|
|
expBoost = expBoost + trackData.bpExpUpRatio
|
|
end
|
|
end
|
|
return expBoost
|
|
end
|
|
|
|
function BattlePassUtils.GetAdventureDailyBpExpBaseCount(rewardId)
|
|
local rewardData = Tables.rewardTable[rewardId]
|
|
local bpItemId = Tables.battlePassConst.bpExpItem
|
|
local bpExpBaseCount = 0
|
|
if rewardData ~= nil then
|
|
for _, itemBundle in pairs(rewardData.itemBundles) do
|
|
if itemBundle.id == bpItemId then
|
|
bpExpBaseCount = itemBundle.count
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return bpExpBaseCount
|
|
end
|
|
|
|
function BattlePassUtils.CheckHasAvailBpPlanReward()
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false, -1
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
if bpSystem.firstCanObtainedLevel < 0 then
|
|
return false, -1
|
|
end
|
|
return true, bpSystem.firstCanObtainedLevel
|
|
end
|
|
|
|
function BattlePassUtils.GetLastGainBpPlanLevel()
|
|
local lastLevel = -1
|
|
local trackData = GameInstance.player.battlePassSystem.trackData
|
|
for _, playerTrack in pairs(trackData.trackRewards) do
|
|
if playerTrack ~= nil then
|
|
for _, level in pairs(playerTrack.rewardGainedLevel) do
|
|
if level > lastLevel then
|
|
lastLevel = level
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if lastLevel > 0 then
|
|
return true, lastLevel
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckHasCompletedTask()
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
for taskId, taskInfo in pairs(bpSystem.taskData.taskInfos) do
|
|
if taskInfo.taskState == CS.Proto.BP_TASK_STATE.HasCompleted then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckLabelVisible(labelId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasLabel, playerLabel = bpSystem.taskData.taskLabels:TryGetValue(labelId)
|
|
if not hasLabel then
|
|
return false
|
|
end
|
|
local hasTaskLabelData, taskLabelData = Tables.battlePassTaskLabelTable:TryGetValue(labelId)
|
|
if not hasTaskLabelData then
|
|
return false
|
|
end
|
|
if playerLabel.closeInfo ~= nil and playerLabel.closeInfo.isClose then
|
|
return false
|
|
end
|
|
|
|
local isConditionVisible = playerLabel.visibleConditions.Count <= 0 or playerLabel.visibleConditions:GetAndCondition()
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
local isTimeVisible = curServerTime >= playerLabel.visibleTime
|
|
|
|
return true, isTimeVisible, isConditionVisible
|
|
end
|
|
|
|
function BattlePassUtils.CheckLabelRedDot(labelId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local isValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckLabelVisible(labelId)
|
|
if not isValid or not isTimeVisible or not isConditionVisible then
|
|
return false
|
|
end
|
|
local isSubLabel, mainLabelEntry = Tables.battlePassTaskSubLabelMapTable:TryGetValue(labelId)
|
|
if isSubLabel then
|
|
local isParentLabelValid, isParentLabelTimeValid, isParentLabelConditionValid = BattlePassUtils.CheckLabelVisible(mainLabelEntry.parentLabelId)
|
|
if not isParentLabelValid or not isParentLabelTimeValid or not isParentLabelConditionValid then
|
|
return false
|
|
end
|
|
end
|
|
local hasRedDot = false
|
|
local redDotType = UIConst.RED_DOT_TYPE.Normal
|
|
local hasSubLabel, subLabelData = Tables.battlePassTaskLabelMapTable:TryGetValue(labelId)
|
|
if hasSubLabel then
|
|
for _, subLabelInfo in pairs(subLabelData.subLabels) do
|
|
local hasSubRedDot, subRedDotType = BattlePassUtils.CheckLabelRedDot(subLabelInfo.taskLabelID)
|
|
if hasSubRedDot and subRedDotType == UIConst.RED_DOT_TYPE.New then
|
|
hasRedDot = true
|
|
redDotType = UIConst.RED_DOT_TYPE.New
|
|
end
|
|
if hasSubRedDot and subRedDotType == UIConst.RED_DOT_TYPE.Normal then
|
|
hasRedDot = true
|
|
redDotType = (redDotType == UIConst.RED_DOT_TYPE.New) and UIConst.RED_DOT_TYPE.New or UIConst.RED_DOT_TYPE.Normal
|
|
end
|
|
end
|
|
else
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasLabel, labelInfo = bpSystem.taskData.taskLabels:TryGetValue(labelId)
|
|
if hasLabel then
|
|
for _, groupId in pairs(labelInfo.groupIds) do
|
|
local hasGroupRedDot, groupRedDotType = BattlePassUtils.CheckGroupRedDot(groupId)
|
|
if hasGroupRedDot and groupRedDotType == UIConst.RED_DOT_TYPE.New then
|
|
hasRedDot = true
|
|
redDotType = UIConst.RED_DOT_TYPE.New
|
|
end
|
|
if hasGroupRedDot and groupRedDotType == UIConst.RED_DOT_TYPE.Normal then
|
|
hasRedDot = true
|
|
redDotType = (redDotType == UIConst.RED_DOT_TYPE.New) and UIConst.RED_DOT_TYPE.New or UIConst.RED_DOT_TYPE.Normal
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if hasRedDot then
|
|
return true, redDotType
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckGroupVisible(groupId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasGroup, playerGroup = bpSystem.taskData.taskGroups:TryGetValue(groupId)
|
|
if not hasGroup then
|
|
return false
|
|
end
|
|
local hasTaskGroupData, taskGroupData = Tables.battlePassTaskGroupTable:TryGetValue(groupId)
|
|
if not hasTaskGroupData then
|
|
return false
|
|
end
|
|
if playerGroup.closeInfo ~= nil and playerGroup.closeInfo.isClose then
|
|
return false
|
|
end
|
|
local isConditionVisible = playerGroup.visibleConditions.Count <= 0 or playerGroup.visibleConditions:GetAndCondition()
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
local isTimeVisible = curServerTime >= playerGroup.visibleTime and curServerTime < playerGroup.disableTime
|
|
|
|
return true, isTimeVisible, isConditionVisible
|
|
end
|
|
|
|
function BattlePassUtils.CheckGroupEnable(groupId)
|
|
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasGroup, playerGroup = bpSystem.taskData.taskGroups:TryGetValue(groupId)
|
|
if not hasGroup then
|
|
return false
|
|
end
|
|
if playerGroup.closeInfo ~= nil and playerGroup.closeInfo.isClose then
|
|
return false
|
|
end
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
return curServerTime < playerGroup.disableTime
|
|
end
|
|
|
|
function BattlePassUtils.CheckGroupRedDot(groupId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local isValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckGroupVisible(groupId)
|
|
if not isValid or not isTimeVisible or not isConditionVisible then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasGroup, groupInfo = bpSystem.taskData.taskGroups:TryGetValue(groupId)
|
|
local hasRedDot = false
|
|
local redDotType = UIConst.RED_DOT_TYPE.Normal
|
|
if hasGroup then
|
|
for _, taskId in pairs(groupInfo.taskIds) do
|
|
if BattlePassUtils.CheckTaskUnread(taskId) then
|
|
hasRedDot = true
|
|
redDotType = UIConst.RED_DOT_TYPE.New
|
|
end
|
|
if BattlePassUtils.CheckTaskCompleted(taskId) then
|
|
hasRedDot = true
|
|
redDotType = (redDotType == UIConst.RED_DOT_TYPE.New) and UIConst.RED_DOT_TYPE.New or UIConst.RED_DOT_TYPE.Normal
|
|
end
|
|
end
|
|
end
|
|
if hasRedDot then
|
|
return true, redDotType
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckTaskCompleted(taskId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local isTaskValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckTaskVisible(taskId)
|
|
if not isTaskValid or not isTimeVisible or not isConditionVisible then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasTask, taskInfo = bpSystem.taskData.taskInfos:TryGetValue(taskId)
|
|
if hasTask then
|
|
return taskInfo.taskState == CS.Proto.BP_TASK_STATE.HasCompleted
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckTaskVisible(taskId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasTask, playerTask = bpSystem.taskData.taskInfos:TryGetValue(taskId)
|
|
if not hasTask then
|
|
return false
|
|
end
|
|
local hasTaskData, taskData = Tables.battlePassTaskTable:TryGetValue(taskId)
|
|
if not hasTaskData then
|
|
return false
|
|
end
|
|
if playerTask.closeInfo ~= nil and playerTask.closeInfo.isClose then
|
|
return false
|
|
end
|
|
if playerTask.taskState == CS.Proto.BP_TASK_STATE.Disable then
|
|
return false
|
|
end
|
|
local isConditionVisible = playerTask.visibleConditions.Count <= 0 or playerTask.visibleConditions:GetAndCondition()
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
local isTimeVisible = curServerTime >= playerTask.visibleTime
|
|
return true, isTimeVisible, isConditionVisible
|
|
end
|
|
|
|
function BattlePassUtils.CheckTaskUnread(taskId)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local isTaskValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckTaskVisible(taskId)
|
|
if not isTaskValid or not isTimeVisible or not isConditionVisible then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
return bpSystem:IsTaskUnread(taskId)
|
|
end
|
|
|
|
function BattlePassUtils.GetShowingTaskIds()
|
|
local taskIds = {}
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
for taskId, taskInfo in pairs(bpSystem.taskData.taskInfos) do
|
|
local isLabelValid = false
|
|
if taskInfo.hostLabel ~= nil then
|
|
local labelValid, labelTimeValid, labelConditionValid = BattlePassUtils.CheckLabelVisible(taskInfo.hostLabel.labelId)
|
|
isLabelValid = labelValid and labelTimeValid and labelConditionValid
|
|
local isSubLabel, mainLabelEntry = Tables.battlePassTaskSubLabelMapTable:TryGetValue(taskInfo.hostLabel.labelId)
|
|
if isSubLabel then
|
|
local isParentLabelValid, isParentLabelTimeValid, isParentLabelConditionValid = BattlePassUtils.CheckLabelVisible(mainLabelEntry.parentLabelId)
|
|
if not isParentLabelValid or not isParentLabelTimeValid or not isParentLabelConditionValid then
|
|
isLabelValid = false
|
|
end
|
|
end
|
|
end
|
|
local isGroupValid = false
|
|
if isLabelValid and taskInfo.hostGroup ~= nil then
|
|
local groupValid, groupTimeValid, groupConditionValid = BattlePassUtils.CheckGroupVisible(taskInfo.hostGroup.taskGroupId)
|
|
isGroupValid = groupValid and groupTimeValid and groupConditionValid
|
|
end
|
|
local isTaskValid = false
|
|
if isLabelValid and isGroupValid then
|
|
local valid, timeValid, conditionValid = BattlePassUtils.CheckTaskVisible(taskId)
|
|
isTaskValid = valid and timeValid and conditionValid
|
|
end
|
|
if isTaskValid then
|
|
table.insert(taskIds, taskId)
|
|
end
|
|
end
|
|
return taskIds
|
|
end
|
|
|
|
function BattlePassUtils.CheckIsRewardGained(trackType, level)
|
|
if not BattlePassUtils.CheckBattlePassSeasonValid() then
|
|
return false
|
|
end
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local hasSeason, seasonInfo = Tables.battlePassSeasonTable:TryGetValue(bpSystem.seasonData.seasonId)
|
|
if not hasSeason then
|
|
return false
|
|
end
|
|
local hasLevelGroup, levelGroup = Tables.battlePassLevelTable:TryGetValue(seasonInfo.levelGroupId)
|
|
if not hasLevelGroup then
|
|
return false
|
|
end
|
|
local hasLevel, levelInfo = levelGroup.levelInfos:TryGetValue(level)
|
|
if not hasLevel then
|
|
return false
|
|
end
|
|
local rewardId = ''
|
|
if trackType == GEnums.BPTrackType.FREE then
|
|
rewardId = levelInfo.freeRewardId
|
|
elseif trackType == GEnums.BPTrackType.ORIGINIUM then
|
|
rewardId = levelInfo.originiumRewardId
|
|
elseif trackType == GEnums.BPTrackType.PAY then
|
|
rewardId = levelInfo.payRewardId
|
|
end
|
|
local hasOverrideLevel, overrideLevelGroup = Tables.battlePassOverrideLevelTable:TryGetValue(seasonInfo.ovrLvRewardGroupId)
|
|
if hasOverrideLevel then
|
|
local hasOverrideLevel, overrideLevelInfo = overrideLevelGroup.levelInfos:TryGetValue(level)
|
|
if hasOverrideLevel then
|
|
if trackType == GEnums.BPTrackType.FREE then
|
|
rewardId = overrideLevelInfo.freeRewardId
|
|
elseif trackType == GEnums.BPTrackType.ORIGINIUM then
|
|
rewardId = overrideLevelInfo.originiumRewardId
|
|
elseif trackType == GEnums.BPTrackType.PAY then
|
|
rewardId = overrideLevelInfo.payRewardId
|
|
end
|
|
end
|
|
end
|
|
if string.isEmpty(rewardId) then
|
|
return false
|
|
end
|
|
local trackData = GameInstance.player.battlePassSystem.trackData
|
|
for trackId, playerTrack in pairs(trackData.trackRewards) do
|
|
local hasTrack, trackInfo = Tables.battlePassTrackTable:TryGetValue(trackId)
|
|
if hasTrack and trackInfo.trackType == trackType then
|
|
if levelInfo.isRecurring then
|
|
local isMaxLevel = bpSystem.levelData.currLevel >= seasonInfo.maxLevel
|
|
local recruitAllTime = (isMaxLevel and levelInfo.toNextExp > 0) and (bpSystem.levelData.currExp // levelInfo.toNextExp) or 0
|
|
local recruitTime = playerTrack.recurringTimes
|
|
return recruitAllTime <= recruitTime
|
|
else
|
|
return playerTrack.rewardGainedLevel:Contains(level)
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function BattlePassUtils.CheckOriginiumEnough(level)
|
|
local price = Tables.battlePassConst.buyLevelMoneyCnt
|
|
local count = level
|
|
local money = Utils.getItemCount(Tables.battlePassConst.buyOriginiumTrackMoneyID, false)
|
|
return money >= price * count
|
|
end
|
|
|
|
function BattlePassUtils.GetExpGap(level1,exp1,level2,exp2)
|
|
local gap = 0
|
|
local seasonId = GameInstance.player.battlePassSystem.seasonData.seasonId
|
|
local _, seasonData = Tables.battlePassSeasonTable:TryGetValue(seasonId)
|
|
local levelInfos = Tables.battlePassLevelTable[seasonData.levelGroupId].levelInfos
|
|
for i = level1 + 1,level2 do
|
|
gap = gap + levelInfos[i].levelExp
|
|
end
|
|
gap = gap - exp1 + exp2
|
|
return gap
|
|
end
|
|
|
|
function BattlePassUtils.GetOriginiumTrackInfo()
|
|
return Tables.battlePassTrackTable[Tables.battlePassTrackTypeToIDTable[GEnums.BPTrackType.ORIGINIUM].bpTrackID]
|
|
end
|
|
|
|
function BattlePassUtils.GetPayTrackInfo()
|
|
return Tables.battlePassTrackTable[Tables.battlePassTrackTypeToIDTable[GEnums.BPTrackType.PAY].bpTrackID]
|
|
end
|
|
|
|
function BattlePassUtils.CheckOriginiumTrackActive()
|
|
return GameInstance.player.battlePassSystem.trackData.trackRewards:ContainsKey(Tables.battlePassTrackTypeToIDTable[GEnums.BPTrackType.ORIGINIUM].bpTrackID)
|
|
end
|
|
|
|
function BattlePassUtils.CheckPayTrackActive()
|
|
return GameInstance.player.battlePassSystem.trackData.trackRewards:ContainsKey(Tables.battlePassTrackTypeToIDTable[GEnums.BPTrackType.PAY].bpTrackID)
|
|
end
|
|
|
|
function BattlePassUtils.GetOriginiumTrackRewardInfo()
|
|
local seasonId = GameInstance.player.battlePassSystem.seasonData.seasonId
|
|
local oriPreId = Tables.battlePassSeasonTable[seasonId].originiumPreviewGroupId
|
|
return Tables.battlePassRewardPreviewTable[oriPreId].rewardInfos
|
|
end
|
|
|
|
function BattlePassUtils.GetPayTrackRewardInfo()
|
|
local seasonId = GameInstance.player.battlePassSystem.seasonData.seasonId
|
|
local payPreId = Tables.battlePassSeasonTable[seasonId].payPreviewGroupId
|
|
return Tables.battlePassRewardPreviewTable[payPreId].rewardInfos
|
|
end
|
|
|
|
function BattlePassUtils.GetSeasonData()
|
|
local seasonId = GameInstance.player.battlePassSystem.seasonData.seasonId
|
|
local _, seasonData = Tables.battlePassSeasonTable:TryGetValue(seasonId)
|
|
return seasonData
|
|
end
|
|
|
|
function BattlePassUtils.TimeCloseToEnd()
|
|
local closeTime = GameInstance.player.battlePassSystem.seasonData.closeTime
|
|
local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
return closeTime - curServerTime < Tables.battlePassConst.timeCloseToEnd
|
|
end
|
|
|
|
function BattlePassUtils.BuyPayTrack(onClose)
|
|
if BattlePassUtils.CheckPayTrackActive() then
|
|
return
|
|
end
|
|
|
|
local trackId = Tables.battlePassConst.buyPayTrackCashGoodsId
|
|
local _, shopGroupData = Tables.cashShopGroupTable:TryGetValue(CashShopConst.CashShopCategoryType.Pack)
|
|
if not shopGroupData or shopGroupData.cashShopIds.Count == 0 then
|
|
logger.error("ShopRechargeCtrl.OnCreate no shop for id:", CashShopConst.CashShopCategoryType.Pack)
|
|
return
|
|
end
|
|
|
|
if BattlePassUtils.TimeCloseToEnd() then
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = string.format(Language.LUA_BATTLEPASS_BUY_TRACK_SUBTITLE, BattlePassUtils.GetSeasonLastDay()),
|
|
onConfirm = function()
|
|
UIManager:Close(PanelId.CommonPopUp)
|
|
CashShopUtils.createOrder(trackId, CashShopUtils.GetCashShopIdByGoodsId(trackId), 1)
|
|
end
|
|
})
|
|
else
|
|
CashShopUtils.createOrder(trackId, CashShopUtils.GetCashShopIdByGoodsId(trackId), 1)
|
|
end
|
|
|
|
if onClose then
|
|
onClose()
|
|
end
|
|
end
|
|
|
|
function BattlePassUtils.BuyOriginiumTrack()
|
|
if BattlePassUtils.CheckOriginiumTrackActive() then
|
|
return
|
|
end
|
|
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = Language.LUA_BATTLEPASS_ORI_TRACK_BUY_TITLE,
|
|
subContent = Language.LUA_BATTLEPASS_ORI_TRACK_BUY_SUBTITLE,
|
|
onConfirm = function()
|
|
UIManager:Close(PanelId.CommonPopUp)
|
|
|
|
if Utils.getItemCount(Tables.battlePassConst.buyOriginiumTrackMoneyID, false) >= Tables.battlePassConst.buyOriginiumTrackMoneyCnt then
|
|
if BattlePassUtils.TimeCloseToEnd() then
|
|
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = Language.LUA_BATTLEPASS_ORI_TRACK_BUY_TITLE,
|
|
subContent = string.format(Language.LUA_BATTLEPASS_BUY_TRACK_SUBTITLE, BattlePassUtils.GetSeasonLastDay()),
|
|
onConfirm = function()
|
|
UIManager:Close(PanelId.CommonPopUp)
|
|
GameInstance.player.battlePassSystem:SendBuyOriginiumTrack()
|
|
end
|
|
})
|
|
else
|
|
|
|
GameInstance.player.battlePassSystem:SendBuyOriginiumTrack()
|
|
end
|
|
else
|
|
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = Language.LUA_BATTLEPASS_ORIGINIUM_NOT_ENOUGH_TIPS,
|
|
onConfirm = function()
|
|
UIManager:Close(PanelId.CommonPopUp)
|
|
CashShopUtils.GotoCashShopRechargeTab()
|
|
end
|
|
})
|
|
end
|
|
end
|
|
})
|
|
end
|
|
|
|
function BattlePassUtils.AfterBuyPayTrack(ctrl, shouldClose, phaseId)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
local rewardPopupOpened = false
|
|
ctrl:_StartCoroutine(function()
|
|
while true do
|
|
|
|
coroutine.step()
|
|
if not rewardPopupOpened and UIManager:IsShow(PanelId.RewardsPopUpForSystem) then
|
|
rewardPopupOpened = true
|
|
elseif rewardPopupOpened and not UIManager:IsShow(PanelId.RewardsPopUpForSystem) then
|
|
|
|
BattlePassUtils.ShowTrackReward(GEnums.BPTrackType.PAY, true,function()
|
|
|
|
if not BattlePassUtils.CheckOriginiumTrackActive() then
|
|
|
|
BattlePassUtils.ShowOriPlan(function()
|
|
if shouldClose then
|
|
if phaseId ~= nil then
|
|
PhaseManager:PopPhase(phaseId)
|
|
else
|
|
ctrl:PlayAnimationOutAndClose()
|
|
end
|
|
end
|
|
end)
|
|
else
|
|
if shouldClose then
|
|
if phaseId ~= nil then
|
|
PhaseManager:PopPhase(phaseId)
|
|
else
|
|
ctrl:PlayAnimationOutAndClose()
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
break
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
function BattlePassUtils.ShowTrackReward(trackType, fromBuyPlan, onClose, onConfirm)
|
|
|
|
local bpSystem = GameInstance.player.battlePassSystem
|
|
local rewardBundle = {}
|
|
local bpInfo = Tables.battlePassSeasonTable[bpSystem.seasonData.seasonId]
|
|
local previewId = trackType == GEnums.BPTrackType.PAY and bpInfo.payPreviewGroupId or bpInfo.originiumPreviewGroupId
|
|
local infos = Tables.battlePassRewardPreviewTable[previewId].rewardInfos
|
|
for i = 1,#infos do
|
|
local info = infos[CSIndex(i)]
|
|
if info.finishLevel > 0 then
|
|
table.insert(rewardBundle,{
|
|
id = info.itemId,
|
|
count = info.count,
|
|
sortId = info.sortId,
|
|
})
|
|
end
|
|
end
|
|
table.sort(rewardBundle, Utils.genSortFunction({"sortId"}, true))
|
|
|
|
|
|
local trackName = trackType == GEnums.BPTrackType.PAY and BattlePassUtils.GetPayTrackInfo().name or BattlePassUtils.GetOriginiumTrackInfo().name
|
|
UIManager:Open(PanelId.BattlePassRecommend, {
|
|
rewardBundle = rewardBundle,
|
|
desc = string.format(Language.LUA_BATTLEPASS_AFTER_BUY_PAY_TRACK, trackName),
|
|
fromBuyPlan = fromBuyPlan,
|
|
onClose = function()
|
|
if onClose ~= nil then
|
|
onClose()
|
|
end
|
|
end,
|
|
onConfirm = function()
|
|
if onConfirm ~= nil then
|
|
onConfirm()
|
|
end
|
|
end
|
|
})
|
|
end
|
|
|
|
function BattlePassUtils.ShowOriPlan(onClose)
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = string.format(Language.LUA_BATTLE_PASS_AFTER_BUY_PRO_DOUBLE_CONFIRM_TEXT, Tables.battlePassConst.buyOriginiumTrackMoneyCnt),
|
|
onConfirm = function()
|
|
|
|
PhaseManager:GoToPhase(PhaseId.BattlePassBuyPlan,{
|
|
type = "Ori",
|
|
onClose = onClose,
|
|
})
|
|
end
|
|
})
|
|
end
|
|
|
|
function BattlePassUtils.GetBattlePassIntroVideoPath()
|
|
local battlePassIntroFileName = Tables.battlePassConst.bpIntroVideoId
|
|
return UIUtils.getUIVideoFullPath('BattlePass/' .. battlePassIntroFileName)
|
|
end
|
|
|
|
function BattlePassUtils.GetBattlePassOverrideLevelData(level, overrideLevelGroupId)
|
|
local hasOverride, overrideLevelGroupData = Tables.battlePassOverrideLevelTable:TryGetValue(overrideLevelGroupId)
|
|
if hasOverride then
|
|
local hasOverrideLevel, overrideLevelData = overrideLevelGroupData.levelInfos:TryGetValue(level)
|
|
if hasOverrideLevel then
|
|
return overrideLevelData
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
|
|
|
|
_G.BattlePassUtils = BattlePassUtils
|
|
return BattlePassUtils |