SL1900
760 lines
35 KiB
Lua
760 lines
35 KiB
Lua
local ActivityLevelsSelectCtrl = class("ActivityLevelsSelectCtrl", BaseCtrl)
|
|
local mapToggle = {
|
|
[1] = GameEnum.diffculty.Diffculty_1,
|
|
[2] = GameEnum.diffculty.Diffculty_2,
|
|
[3] = GameEnum.diffculty.Diffculty_3,
|
|
[4] = GameEnum.diffculty.Diffculty_4,
|
|
[5] = GameEnum.diffculty.Diffculty_5,
|
|
[6] = GameEnum.diffculty.Diffculty_6,
|
|
[7] = GameEnum.diffculty.Diffculty_7,
|
|
[8] = GameEnum.diffculty.Diffculty_8,
|
|
[9] = GameEnum.diffculty.Diffculty_9,
|
|
[10] = GameEnum.diffculty.Diffculty_10
|
|
}
|
|
local colorSelect = Color(1.0, 0.9882352941176471, 0.9568627450980393, 1)
|
|
local colorUnSelect = Color(0.4, 0.13333333333333333, 0.15294117647058825, 1)
|
|
local colorSelectLock = Color(0.9529411764705882, 0.8588235294117647, 0.7294117647058823, 1)
|
|
local colorUnSelectLock = Color(0.4, 0.13333333333333333, 0.15294117647058825, 1)
|
|
local colorSelectLockMask = Color(0.7137254901960784, 0.6431372549019608, 0.5411764705882353, 1)
|
|
local colorUnSelectLockMask = Color(0.2980392156862745, 0.09803921568627451, 0.11372549019607843, 1)
|
|
local timeUnLockColor = "fff7ca"
|
|
local colorConditionsUnLock = Color(1, 1, 1, 1)
|
|
local colorConditionsLock = Color(1, 1, 1, 0.5)
|
|
ActivityLevelsSelectCtrl._mapNodeConfig = {
|
|
TopBar = {
|
|
sNodeName = "TopBarPanel",
|
|
sCtrlName = "Game.UI.TopBarEx.TopBarCtrl"
|
|
},
|
|
goEnemyInfo = {
|
|
sCtrlName = "Game.UI.MainlineEx.MainlineMonsterInfoCtrl"
|
|
},
|
|
togTypeExplore = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnBtnClick_TogTypeExplore"
|
|
},
|
|
togTypeExploreCtrl = {
|
|
sNodeName = "togTypeExplore",
|
|
sCtrlName = "Game.UI.TemplateEx.TemplateToggleCtrl"
|
|
},
|
|
lockExplore = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnClick_BtnLockExplore"
|
|
},
|
|
redExplore = {},
|
|
togTypeAdventure = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnBtnClick_TogTypeAdventure"
|
|
},
|
|
togTypeAdventureCtrl = {
|
|
sNodeName = "togTypeAdventure",
|
|
sCtrlName = "Game.UI.TemplateEx.TemplateToggleCtrl"
|
|
},
|
|
lockAdventure = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnClick_BtnLockAdventure"
|
|
},
|
|
redAdventure = {},
|
|
togTypeHard = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnBtnClick_TogTypeHard"
|
|
},
|
|
togTypeHardCtrl = {
|
|
sNodeName = "togTypeHard",
|
|
sCtrlName = "Game.UI.TemplateEx.TemplateToggleCtrl"
|
|
},
|
|
lockHard = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnClick_BtnLockHard"
|
|
},
|
|
redHard = {},
|
|
rtToggles = {
|
|
sNodeName = "srToggle",
|
|
sComponentName = "UIScrollRect"
|
|
},
|
|
tog = {
|
|
sComponentName = "UIButton",
|
|
nCount = 10,
|
|
callback = "OnBtnClick_Tog"
|
|
},
|
|
togCtrl = {
|
|
sNodeName = "tog",
|
|
sCtrlName = "Game.UI.TemplateEx.TemplateToggleCtrl",
|
|
nCount = 10
|
|
},
|
|
togAniRoot = {sNodeName = "rt_Toggle", sComponentName = "Animator"},
|
|
txtRecommendLevel = {
|
|
sNodeName = "txtSuggestLevel",
|
|
sComponentName = "TMP_Text"
|
|
},
|
|
txtTitle = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "InfinityTower_Recommend_Lv"
|
|
},
|
|
txtBuildTitle = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "InfinityTower_Recommend_Construct"
|
|
},
|
|
imgBuild = {sComponentName = "Image"},
|
|
TMPName = {sComponentName = "TMP_Text"},
|
|
detailDesc = {sComponentName = "TMP_Text"},
|
|
btnEnemyInfo = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnBtnClick_EnemyInfo"
|
|
},
|
|
tex_EnemyInfo = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "Equipment_Instance_EnemyInfo"
|
|
},
|
|
txtTitleTarget = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "RogueBoss_Pause_Target"
|
|
},
|
|
txtReward = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "Level_Award"
|
|
},
|
|
Task = {sComponentName = "Transform", nCount = 3},
|
|
rewardRoot = {sComponentName = "Transform"},
|
|
btn_itemTemp = {},
|
|
btnListRoot = {},
|
|
btnRaid = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnClickBtnRaid"
|
|
},
|
|
imgRaidUnlockMask = {},
|
|
txtBtnRaid = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "Raid_Title_Raid"
|
|
},
|
|
TMPRaidUnlockHint = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "Raid_Btn_Cond"
|
|
},
|
|
btnGo = {
|
|
sComponentName = "UIButton",
|
|
callback = "OnClickBtnGo"
|
|
},
|
|
txtBtnGo = {
|
|
sComponentName = "TMP_Text",
|
|
sLanguageId = "Maninline_Btn_Go"
|
|
},
|
|
goCoin = {},
|
|
txtTicketsCount = {sComponentName = "TMP_Text"},
|
|
ListConditions = {},
|
|
ListConditionsObj = {
|
|
sNodeName = "Conditions_",
|
|
nCount = 2
|
|
}
|
|
}
|
|
ActivityLevelsSelectCtrl._mapEventConfig = {
|
|
[EventId.UpdateEnergy] = "OnEvent_UpdateEnergy"
|
|
}
|
|
ActivityLevelsSelectCtrl._mapRedDotConfig = {}
|
|
function ActivityLevelsSelectCtrl:Awake()
|
|
local param = self:GetPanelParam()
|
|
if type(param) == "table" then
|
|
self.nActId = param[1]
|
|
end
|
|
self.nLevelType = GameEnum.ActivityLevelType.Explore
|
|
self.tabRewardList = {}
|
|
self.AniRoot = self.gameObject:GetComponent("Animator")
|
|
local bInActGroup, nActGroupId = PlayerData.Activity:IsActivityInActivityGroup(self.nActId)
|
|
if bInActGroup then
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Explore, {nActGroupId}, self._mapNode.redExplore)
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Adventure, {nActGroupId}, self._mapNode.redAdventure)
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Hard, {nActGroupId}, self._mapNode.redHard)
|
|
end
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnEnable()
|
|
self.timeTab = {}
|
|
EventManager.Hit(EventId.SetTransition)
|
|
self.SelectTogPreLvLock = nil
|
|
self.AniRoot:Play("ActivityLevelsSelect_in")
|
|
self:Init()
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnDisable()
|
|
self.timeTab = {}
|
|
for i = 1, #self.tabRewardList do
|
|
local go = self.tabRewardList[i].gameObject
|
|
local btnSelect = self.tabRewardList[i].gameObject:GetComponent("UIButton")
|
|
btnSelect.onClick:RemoveAllListeners()
|
|
self:UnbindCtrlByNode(self.tabRewardList[i])
|
|
destroy(go)
|
|
end
|
|
self.tabRewardList = {}
|
|
self.SelectTogPreLvLock = nil
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnDestroy(...)
|
|
end
|
|
function ActivityLevelsSelectCtrl:Init()
|
|
self.activityLevelsData = PlayerData.Activity:GetActivityDataById(self.nActId)
|
|
self:RefreshTogTypeCount()
|
|
self:Refresh()
|
|
end
|
|
function ActivityLevelsSelectCtrl:Refresh()
|
|
self.nLevelType = self.activityLevelsData:GetDefaultSelectionType()
|
|
self:RefreshTogType(self.nLevelType)
|
|
local nDifficulty = self.activityLevelsData:GetDefaultSelectionDifficulty(self.nLevelType)
|
|
self:RefreshTogList(self.nLevelType, nDifficulty)
|
|
end
|
|
function ActivityLevelsSelectCtrl:RefreshTogTypeCount()
|
|
self._mapNode.togTypeExploreCtrl:SetText(ConfigTable.GetUIText("ActivityLevels_Explore"))
|
|
self._mapNode.togTypeAdventureCtrl:SetText(ConfigTable.GetUIText("ActivityLevels_Adventure"))
|
|
self._mapNode.togTypeHardCtrl:SetText(ConfigTable.GetUIText("ActivityLevels_HardCommon"))
|
|
self._mapNode.togTypeExploreCtrl:SetDefaultActivity(self.nLevelType == GameEnum.ActivityLevelType.Explore)
|
|
self._mapNode.togTypeAdventureCtrl:SetDefaultActivity(self.nLevelType == GameEnum.ActivityLevelType.Adventure)
|
|
self._mapNode.togTypeHardCtrl:SetDefaultActivity(self.nLevelType == GameEnum.ActivityLevelType.HARD)
|
|
local texExplore_SelectCount = self._mapNode.togTypeExplore.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount"):GetComponent("TMP_Text")
|
|
local texExplore_UnSelectCount = self._mapNode.togTypeExplore.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount"):GetComponent("TMP_Text")
|
|
local texAdventure_SelectCount = self._mapNode.togTypeAdventure.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount"):GetComponent("TMP_Text")
|
|
local texAdventure_UnSelectCount = self._mapNode.togTypeAdventure.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount"):GetComponent("TMP_Text")
|
|
local texHard_SelectCount = self._mapNode.togTypeHard.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount"):GetComponent("TMP_Text")
|
|
local texHard_UnSelectCount = self._mapNode.togTypeHard.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount"):GetComponent("TMP_Text")
|
|
local totalExplore, exploreCount = self.activityLevelsData:GetLevelStarMsg(GameEnum.ActivityLevelType.Explore)
|
|
local totalAdventure, adventureCount = self.activityLevelsData:GetLevelStarMsg(GameEnum.ActivityLevelType.Adventure)
|
|
local totalHard, hardCount = self.activityLevelsData:GetLevelStarMsg(GameEnum.ActivityLevelType.HARD)
|
|
local str = "%s/%s"
|
|
self.firstExploreLevel = self.activityLevelsData.levelTabExploreDifficulty[1]
|
|
local isOpenExplore = self.activityLevelsData:GetLevelDayOpen(GameEnum.ActivityLevelType.Explore, self.firstExploreLevel)
|
|
self._mapNode.lockExplore.gameObject:SetActive(not isOpenExplore)
|
|
if isOpenExplore then
|
|
NovaAPI.SetTMPText(texExplore_SelectCount, string.format(str, exploreCount, totalExplore))
|
|
NovaAPI.SetTMPText(texExplore_UnSelectCount, string.format(str, exploreCount, totalExplore))
|
|
else
|
|
NovaAPI.SetTMPText(texExplore_SelectCount, "")
|
|
NovaAPI.SetTMPText(texExplore_UnSelectCount, "")
|
|
end
|
|
self.firstAdventureLevel = self.activityLevelsData.levelTabAdventureDifficulty[1]
|
|
local isOpenAdventure = self.activityLevelsData:GetLevelDayOpen(GameEnum.ActivityLevelType.Adventure, self.firstAdventureLevel)
|
|
self._mapNode.lockAdventure.gameObject:SetActive(not isOpenAdventure)
|
|
if isOpenAdventure then
|
|
NovaAPI.SetTMPText(texAdventure_SelectCount, string.format(str, adventureCount, totalAdventure))
|
|
NovaAPI.SetTMPText(texAdventure_UnSelectCount, string.format(str, adventureCount, totalAdventure))
|
|
else
|
|
NovaAPI.SetTMPText(texAdventure_SelectCount, "")
|
|
NovaAPI.SetTMPText(texAdventure_UnSelectCount, "")
|
|
end
|
|
self.firstHardLevel = self.activityLevelsData.levelTabHardDifficulty[1]
|
|
local isOpenHard = self.activityLevelsData:GetLevelDayOpen(GameEnum.ActivityLevelType.HARD, self.firstHardLevel)
|
|
self._mapNode.lockHard.gameObject:SetActive(not isOpenHard)
|
|
if isOpenHard then
|
|
NovaAPI.SetTMPText(texHard_SelectCount, string.format(str, hardCount, totalHard))
|
|
NovaAPI.SetTMPText(texHard_UnSelectCount, string.format(str, hardCount, totalHard))
|
|
else
|
|
NovaAPI.SetTMPText(texHard_SelectCount, "")
|
|
NovaAPI.SetTMPText(texHard_UnSelectCount, "")
|
|
end
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnClick_BtnLockExplore()
|
|
self:FirstLevelLockTips(GameEnum.ActivityLevelType.Explore, self.firstExploreLevel)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnClick_BtnLockAdventure()
|
|
self:FirstLevelLockTips(GameEnum.ActivityLevelType.Adventure, self.firstAdventureLevel)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnClick_BtnLockHard()
|
|
self:FirstLevelLockTips(GameEnum.ActivityLevelType.HARD, self.firstHardLevel)
|
|
end
|
|
function ActivityLevelsSelectCtrl:FirstLevelLockTips(nType, nLevel)
|
|
local day = self.activityLevelsData:GetUnLockDay(nType, nLevel)
|
|
local strTips = ""
|
|
if day == 0 then
|
|
local hour, min, sec = self.activityLevelsData:GetUnLockHour(nType, nLevel)
|
|
if 0 < hour then
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Hour"), hour)
|
|
elseif 0 < min then
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Min"), min)
|
|
elseif 0 < sec then
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Sec"), sec)
|
|
end
|
|
else
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Day"), day)
|
|
end
|
|
EventManager.Hit(EventId.OpenMessageBox, strTips)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_TogTypeExplore()
|
|
if self.nLevelType == GameEnum.ActivityLevelType.Explore then
|
|
return
|
|
end
|
|
self:CloseAllTimer()
|
|
self.AniRoot:Play("ActivityLevelsSelect_in1")
|
|
self._mapNode.togAniRoot:Play("ActivityLevelsSelect_Toggle_in")
|
|
self.nLevelType = GameEnum.ActivityLevelType.Explore
|
|
self:RefreshTogType(self.nLevelType)
|
|
local nDifficulty = self.activityLevelsData:GetDefaultSelectionDifficulty(self.nLevelType)
|
|
self:RefreshTogList(self.nLevelType, nDifficulty)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_TogTypeAdventure()
|
|
if self.nLevelType == GameEnum.ActivityLevelType.Adventure then
|
|
return
|
|
end
|
|
self:CloseAllTimer()
|
|
self.AniRoot:Play("ActivityLevelsSelect_in1")
|
|
self._mapNode.togAniRoot:Play("ActivityLevelsSelect_Toggle_in")
|
|
self.nLevelType = GameEnum.ActivityLevelType.Adventure
|
|
self:RefreshTogType(self.nLevelType)
|
|
local nDifficulty = self.activityLevelsData:GetDefaultSelectionDifficulty(self.nLevelType)
|
|
self:RefreshTogList(self.nLevelType, nDifficulty)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_TogTypeHard()
|
|
if self.nLevelType == GameEnum.ActivityLevelType.HARD then
|
|
return
|
|
end
|
|
self:CloseAllTimer()
|
|
self.AniRoot:Play("ActivityLevelsSelect_in1")
|
|
self._mapNode.togAniRoot:Play("ActivityLevelsSelect_Toggle_in")
|
|
self.nLevelType = GameEnum.ActivityLevelType.HARD
|
|
self:RefreshTogType(self.nLevelType)
|
|
local nDifficulty = self.activityLevelsData:GetDefaultSelectionDifficulty(self.nLevelType)
|
|
self:RefreshTogList(self.nLevelType, nDifficulty)
|
|
end
|
|
function ActivityLevelsSelectCtrl:CloseAllTimer()
|
|
for i, v in pairs(self.timeTab) do
|
|
v:Pause(true)
|
|
end
|
|
self.timeTab = {}
|
|
end
|
|
function ActivityLevelsSelectCtrl:RefreshTogType(nType)
|
|
if self.SelectTogPreLvLock ~= nil then
|
|
NovaAPI.SetImageColor(self.SelectTogPreLvLock, colorUnSelectLock)
|
|
end
|
|
self._mapNode.togTypeExploreCtrl:SetTrigger(nType == GameEnum.ActivityLevelType.Explore)
|
|
self._mapNode.togTypeAdventureCtrl:SetTrigger(nType == GameEnum.ActivityLevelType.Adventure)
|
|
self._mapNode.togTypeHardCtrl:SetTrigger(nType == GameEnum.ActivityLevelType.HARD)
|
|
self._mapNode.togTypeExploreCtrl:SetDefaultActivity(nType == GameEnum.ActivityLevelType.Explore)
|
|
self._mapNode.togTypeAdventureCtrl:SetDefaultActivity(nType == GameEnum.ActivityLevelType.Adventure)
|
|
self._mapNode.togTypeHardCtrl:SetDefaultActivity(nType == GameEnum.ActivityLevelType.HARD)
|
|
local explore_SelectCount = self._mapNode.togTypeExplore.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount").gameObject
|
|
local explore_UnSelectCount = self._mapNode.togTypeExplore.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount").gameObject
|
|
local adventure_SelectCount = self._mapNode.togTypeAdventure.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount").gameObject
|
|
local adventure_UnSelectCount = self._mapNode.togTypeAdventure.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount").gameObject
|
|
local hard_SelectCount = self._mapNode.togTypeHard.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_SelectCount").gameObject
|
|
local hard_UnSelectCount = self._mapNode.togTypeHard.gameObject.transform:Find("AnimRoot/AnimSwitch/txt_unSelectCount").gameObject
|
|
explore_SelectCount:SetActive(nType == GameEnum.ActivityLevelType.Explore)
|
|
explore_UnSelectCount:SetActive(nType ~= GameEnum.ActivityLevelType.Explore)
|
|
adventure_SelectCount:SetActive(nType == GameEnum.ActivityLevelType.Adventure)
|
|
adventure_UnSelectCount:SetActive(nType ~= GameEnum.ActivityLevelType.Adventure)
|
|
hard_SelectCount:SetActive(nType == GameEnum.ActivityLevelType.HARD)
|
|
hard_UnSelectCount:SetActive(nType ~= GameEnum.ActivityLevelType.HARD)
|
|
end
|
|
function ActivityLevelsSelectCtrl:RefreshTogList(nType, nDifficulty)
|
|
local tabLevelInfo, tabLevelInfoDifficulty
|
|
local isOpenAdventure = self.activityLevelsData:GetLevelDayOpen(GameEnum.ActivityLevelType.Adventure, self.firstAdventureLevel)
|
|
local isOpenHard = self.activityLevelsData:GetLevelDayOpen(GameEnum.ActivityLevelType.HARD, self.firstHardLevel)
|
|
if nType == GameEnum.ActivityLevelType.Explore then
|
|
tabLevelInfo = self.activityLevelsData.levelTabExplore
|
|
tabLevelInfoDifficulty = self.activityLevelsData.levelTabExploreDifficulty
|
|
local tmpImageAdventure = self._mapNode.lockAdventure.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageAdventure, colorUnSelectLockMask)
|
|
local tmpImageHard = self._mapNode.lockHard.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageHard, colorUnSelectLockMask)
|
|
if not isOpenAdventure then
|
|
local tmpLockAdventure = self._mapNode.lockAdventure.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockAdventure, "10104/SpriteAtlas_1010401", "tab_spring_1")
|
|
tmpLockAdventure:SetNativeSize()
|
|
end
|
|
if not isOpenHard then
|
|
local tmpLockHard = self._mapNode.lockHard.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockHard, "10104/SpriteAtlas_1010401", "tab_spring_1")
|
|
tmpLockHard:SetNativeSize()
|
|
end
|
|
elseif nType == GameEnum.ActivityLevelType.Adventure then
|
|
tabLevelInfo = self.activityLevelsData.levelTabAdventure
|
|
tabLevelInfoDifficulty = self.activityLevelsData.levelTabAdventureDifficulty
|
|
local tmpImageAdventure = self._mapNode.lockAdventure.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageAdventure, colorSelectLockMask)
|
|
local tmpImageHard = self._mapNode.lockHard.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageHard, colorUnSelectLockMask)
|
|
if not isOpenAdventure then
|
|
local tmpLockAdventure = self._mapNode.lockAdventure.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockAdventure, "10104/SpriteAtlas_1010401", "tab_spring_1_slc")
|
|
tmpLockAdventure:SetNativeSize()
|
|
end
|
|
if not isOpenHard then
|
|
local tmpLockHard = self._mapNode.lockHard.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockHard, "10104/SpriteAtlas_1010401", "tab_spring_1")
|
|
tmpLockHard:SetNativeSize()
|
|
end
|
|
else
|
|
tabLevelInfo = self.activityLevelsData.levelTabHard
|
|
tabLevelInfoDifficulty = self.activityLevelsData.levelTabHardDifficulty
|
|
local tmpImageAdventure = self._mapNode.lockAdventure.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageAdventure, colorUnSelectLockMask)
|
|
local tmpImageHard = self._mapNode.lockHard.gameObject.transform:Find("Image"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpImageHard, colorSelectLockMask)
|
|
if not isOpenAdventure then
|
|
local tmpLockAdventure = self._mapNode.lockAdventure.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockAdventure, "10104/SpriteAtlas_1010401", "tab_spring_1")
|
|
tmpLockAdventure:SetNativeSize()
|
|
end
|
|
if not isOpenHard then
|
|
local tmpLockHard = self._mapNode.lockHard.gameObject:GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpLockHard, "10104/SpriteAtlas_1010401", "tab_spring_1_slc")
|
|
tmpLockHard:SetNativeSize()
|
|
end
|
|
end
|
|
for i = 1, 10 do
|
|
self._mapNode.tog[i].gameObject:SetActive(i <= #tabLevelInfoDifficulty)
|
|
end
|
|
for i = 1, #tabLevelInfoDifficulty do
|
|
local tmpId = tabLevelInfoDifficulty[i]
|
|
local tmpData = tabLevelInfo[tmpId]
|
|
self._mapNode.togCtrl[i]:SetText(tmpData.baseData.Name)
|
|
local isOpen = self.activityLevelsData:GetLevelDayOpen(nType, tmpData.baseData.Id)
|
|
local isLevelUnLock = self.activityLevelsData:GetLevelUnLock(nType, tmpData.baseData.Id)
|
|
local objTog = self._mapNode.tog[i].gameObject
|
|
local rt_Targets = objTog.transform:Find("AnimRoot/AnimSwitch/rt_Targets").gameObject
|
|
local rtLockInfo = objTog.transform:Find("AnimRoot/AnimSwitch/rtLockInfo").gameObject
|
|
local rtLockPreLv = objTog.transform:Find("AnimRoot/AnimSwitch/rtLockPreLv").gameObject
|
|
local rtLockPreLvSelect = rtLockPreLv.transform:Find("rtLockPreLvSelect"):GetComponent("Image")
|
|
if i == nDifficulty then
|
|
NovaAPI.SetImageColor(rtLockPreLvSelect, colorSelectLock)
|
|
self.SelectTogPreLvLock = rtLockPreLvSelect
|
|
else
|
|
NovaAPI.SetImageColor(rtLockPreLvSelect, colorUnSelectLock)
|
|
end
|
|
local strTips = ""
|
|
local redH = objTog.transform:Find("AnimRoot/AnimSwitch/redH").gameObject
|
|
local bInActGroup, nActGroupId = PlayerData.Activity:IsActivityInActivityGroup(self.nActId)
|
|
if bInActGroup then
|
|
if tmpData.baseData.Type == GameEnum.ActivityLevelType.Explore then
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Explore_Level, {
|
|
nActGroupId,
|
|
tmpData.baseData.Id
|
|
}, redH)
|
|
elseif tmpData.baseData.Type == GameEnum.ActivityLevelType.Adventure then
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Adventure_Level, {
|
|
nActGroupId,
|
|
tmpData.baseData.Id
|
|
}, redH)
|
|
elseif tmpData.baseData.Type == GameEnum.ActivityLevelType.HARD then
|
|
RedDotManager.RegisterNode(RedDotDefine.ActivityLevel_Hard_Level, {
|
|
nActGroupId,
|
|
tmpData.baseData.Id
|
|
}, redH)
|
|
end
|
|
end
|
|
if isOpen and isLevelUnLock then
|
|
rt_Targets:SetActive(true)
|
|
for j = 1, 3 do
|
|
local btnStar = rt_Targets.gameObject.transform:Find("btnTarget" .. j):GetComponent("Button")
|
|
btnStar.interactable = j <= tmpData.Star
|
|
end
|
|
rtLockInfo:SetActive(false)
|
|
rtLockPreLv:SetActive(false)
|
|
elseif isOpen and not isLevelUnLock then
|
|
rt_Targets:SetActive(false)
|
|
rtLockInfo:SetActive(false)
|
|
rtLockPreLv:SetActive(true)
|
|
elseif not isOpen then
|
|
rt_Targets:SetActive(false)
|
|
local day = self.activityLevelsData:GetUnLockDay(nType, tmpData.baseData.Id)
|
|
if day == 0 then
|
|
local rtLockInfoDay = rtLockInfo.gameObject.transform:Find("rtLockInfoDay").gameObject
|
|
local bgCondition = rtLockInfo.gameObject.transform:Find("bgCondition").gameObject
|
|
rtLockInfoDay:SetActive(false)
|
|
bgCondition:SetActive(true)
|
|
local txtLockCondition = rtLockInfo.gameObject.transform:Find("bgCondition/txtLockCondition"):GetComponent("TMP_Text")
|
|
local timerCount = function()
|
|
local hour, min, sec = self.activityLevelsData:GetUnLockHour(nType, tmpData.baseData.Id)
|
|
if 0 < hour then
|
|
NovaAPI.SetTMPText(txtLockCondition, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Hour_Color_Common"), timeUnLockColor, hour))
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Hour"), hour)
|
|
elseif 0 < min then
|
|
NovaAPI.SetTMPText(txtLockCondition, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Min_Color_Common"), timeUnLockColor, min))
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Min"), min)
|
|
elseif 0 < sec then
|
|
NovaAPI.SetTMPText(txtLockCondition, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Sec_Color_Common"), timeUnLockColor, sec))
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Sec"), sec)
|
|
end
|
|
end
|
|
timerCount()
|
|
self.timeTab[tmpData.baseData.Id] = self:AddTimer(0, 1, function()
|
|
timerCount()
|
|
end, true, true, false)
|
|
rtLockInfo:SetActive(true)
|
|
rtLockPreLv:SetActive(false)
|
|
else
|
|
rt_Targets:SetActive(false)
|
|
local rtLockInfoDay = rtLockInfo.gameObject.transform:Find("rtLockInfoDay").gameObject
|
|
local bgCondition = rtLockInfo.gameObject.transform:Find("bgCondition").gameObject
|
|
rtLockInfoDay:SetActive(true)
|
|
bgCondition:SetActive(false)
|
|
strTips = orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Day"), day)
|
|
local tmpLock = rtLockInfo.gameObject.transform:Find("rtLockInfoDay"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(tmpLock, colorUnSelectLockMask)
|
|
rtLockInfo:SetActive(true)
|
|
rtLockPreLv:SetActive(false)
|
|
end
|
|
end
|
|
local clickCb = function()
|
|
EventManager.Hit(EventId.OpenMessageBox, strTips)
|
|
end
|
|
if i == nDifficulty then
|
|
self:RefreshInstanceInfo(nType, nDifficulty, true, true)
|
|
end
|
|
end
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_Tog(btn)
|
|
local nHard = table.indexof(self._mapNode.tog, btn:GetComponent("UIButton"))
|
|
local togIdx = table.indexof(self._mapNode.tog, btn)
|
|
if nHard == nil then
|
|
return
|
|
end
|
|
if self.curSelectHard ~= nHard then
|
|
if self.SelectTogPreLvLock ~= nil then
|
|
NovaAPI.SetImageColor(self.SelectTogPreLvLock, colorUnSelectLock)
|
|
self.SelectTogPreLvLock = nil
|
|
end
|
|
for idx, value in pairs(mapToggle) do
|
|
if value == self.curSelectHard then
|
|
self._mapNode.togCtrl[idx]:SetDefaultActivity(false, colorSelect, colorUnSelect)
|
|
local tmpImage = self._mapNode.togCtrl[idx].gameObject.transform:Find("AnimRoot/AnimSwitch/rtLockInfo/imgLockMask"):GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpImage, "10104/SpriteAtlas_1010401", "btn_spring_3")
|
|
tmpImage:SetNativeSize()
|
|
break
|
|
end
|
|
end
|
|
self._mapNode.togCtrl[togIdx]:SetDefaultActivity(true, colorSelect, colorUnSelect)
|
|
local tmpImageSelect = self._mapNode.togCtrl[togIdx].gameObject.transform:Find("AnimRoot/AnimSwitch/rtLockInfo/imgLockMask"):GetComponent("Image")
|
|
self:SetActivityAtlasSprite_New(tmpImageSelect, "10104/SpriteAtlas_1010401", "btn_spring_4")
|
|
tmpImageSelect:SetNativeSize()
|
|
self.SelectTogPreLvLock = self._mapNode.togCtrl[togIdx].gameObject.transform:Find("AnimRoot/AnimSwitch/rtLockPreLv/rtLockPreLvSelect"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(self.SelectTogPreLvLock, colorSelectLock)
|
|
self:RefreshInstanceInfo(self.nLevelType, nHard, nil, false)
|
|
local levelId = 0
|
|
if self.nLevelType == GameEnum.ActivityLevelType.Explore then
|
|
levelId = self.activityLevelsData.levelTabExploreDifficulty[nHard]
|
|
elseif self.nLevelType == GameEnum.ActivityLevelType.Adventure then
|
|
levelId = self.activityLevelsData.levelTabAdventureDifficulty[nHard]
|
|
else
|
|
levelId = self.activityLevelsData.levelTabHardDifficulty[nHard]
|
|
end
|
|
self.activityLevelsData:ChangeRedDot(self.nLevelType, levelId)
|
|
self.AniRoot:Play("ActivityLevelsSelect_in1")
|
|
end
|
|
end
|
|
function ActivityLevelsSelectCtrl:RefreshInstanceInfo(nType, nHard, bLocation, bSetTog)
|
|
if bLocation then
|
|
local wait = function()
|
|
coroutine.yield(CS.UnityEngine.WaitForEndOfFrame())
|
|
NovaAPI.UIScrollRectScrollTo(self._mapNode.rtToggles, nHard + 1, true)
|
|
end
|
|
cs_coroutine.start(wait)
|
|
end
|
|
if bSetTog then
|
|
for i = 1, 10 do
|
|
self._mapNode.togCtrl[i]:SetDefaultActivity(i == nHard, colorSelect, colorUnSelect)
|
|
local tmpImageSelect = self._mapNode.togCtrl[i].gameObject.transform:Find("AnimRoot/AnimSwitch/rtLockInfo/imgLockMask"):GetComponent("Image")
|
|
if i == nHard then
|
|
self:SetActivityAtlasSprite_New(tmpImageSelect, "10104/SpriteAtlas_1010401", "btn_spring_4")
|
|
else
|
|
self:SetActivityAtlasSprite_New(tmpImageSelect, "10104/SpriteAtlas_1010401", "btn_spring_3")
|
|
end
|
|
tmpImageSelect:SetNativeSize()
|
|
end
|
|
end
|
|
self.curSelectHard = nHard
|
|
if self.tmpLockInfoDay ~= nil then
|
|
NovaAPI.SetImageColor(self.tmpLockInfoDay, colorUnSelectLockMask)
|
|
self.tmpLockInfoDay = nil
|
|
end
|
|
local levelId = 0
|
|
self.selectLevelData = nil
|
|
if nType == GameEnum.ActivityLevelType.Explore then
|
|
levelId = self.activityLevelsData.levelTabExploreDifficulty[nHard]
|
|
self.selectLevelData = self.activityLevelsData.levelTabExplore[levelId]
|
|
elseif nType == GameEnum.ActivityLevelType.Adventure then
|
|
levelId = self.activityLevelsData.levelTabAdventureDifficulty[nHard]
|
|
self.selectLevelData = self.activityLevelsData.levelTabAdventure[levelId]
|
|
else
|
|
levelId = self.activityLevelsData.levelTabHardDifficulty[nHard]
|
|
self.selectLevelData = self.activityLevelsData.levelTabHard[levelId]
|
|
end
|
|
NovaAPI.SetTMPText(self._mapNode.txtRecommendLevel, self.selectLevelData.baseData.SuggestedPower)
|
|
local sRank = "Icon/BuildRank/BuildRank_" .. self.selectLevelData.baseData.RecommendBuildRank
|
|
self:SetPngSprite(self._mapNode.imgBuild, sRank)
|
|
NovaAPI.SetTMPText(self._mapNode.TMPName, self.selectLevelData.baseData.Name)
|
|
NovaAPI.SetTMPText(self._mapNode.detailDesc, self.selectLevelData.baseData.Desc)
|
|
self.curStar = self.selectLevelData.Star
|
|
local tbCond = {
|
|
self.selectLevelData.baseData.OneStarDesc,
|
|
self.selectLevelData.baseData.TwoStarDesc,
|
|
self.selectLevelData.baseData.ThreeStarDesc
|
|
}
|
|
for i = 1, 3 do
|
|
local rtTask = self._mapNode.Task[i]
|
|
local goDone = rtTask:Find("imgDone").gameObject
|
|
local imgUnDone = rtTask:Find("imgUnDone").gameObject
|
|
local Text = rtTask:Find("Text"):GetComponent("TMP_Text")
|
|
goDone:SetActive(i <= self.curStar)
|
|
imgUnDone:SetActive(i > self.curStar)
|
|
local cond = tbCond[i]
|
|
if cond == nil then
|
|
rtTask.gameObject:SetActive(false)
|
|
return
|
|
else
|
|
rtTask.gameObject:SetActive(true)
|
|
NovaAPI.SetTMPText(Text, cond)
|
|
end
|
|
end
|
|
self.PreviewMonsterGroupId = self.selectLevelData.baseData.PreviewMonsterGroupId
|
|
local isOpen = self.activityLevelsData:GetLevelDayOpen(nType, self.selectLevelData.baseData.Id)
|
|
local isLevelUnLock = self.activityLevelsData:GetLevelUnLock(nType, self.selectLevelData.baseData.Id)
|
|
local isNeedEnergyConsume = true
|
|
if not self.selectLevelData.baseData.EnergyConsumeOnRetry and 0 < self.selectLevelData.Star then
|
|
isNeedEnergyConsume = false
|
|
end
|
|
if isOpen and isLevelUnLock then
|
|
self._mapNode.btnListRoot:SetActive(true)
|
|
self._mapNode.ListConditions:SetActive(false)
|
|
if self.selectLevelData.baseData.ThreeStarSweep then
|
|
self._mapNode.btnRaid.gameObject:SetActive(true)
|
|
self._mapNode.txtBtnRaid.gameObject:SetActive(self.curStar == 3)
|
|
self._mapNode.imgRaidUnlockMask.gameObject:SetActive(self.curStar ~= 3)
|
|
else
|
|
self._mapNode.btnRaid.gameObject:SetActive(false)
|
|
end
|
|
local nHas = PlayerData.Base:GetCurEnergy()
|
|
local nRequire = self.selectLevelData.baseData.EnergyConsume
|
|
if not isNeedEnergyConsume then
|
|
nRequire = 0
|
|
end
|
|
self.curRequireEnergy = nRequire
|
|
NovaAPI.SetTMPText(self._mapNode.txtTicketsCount, nRequire)
|
|
NovaAPI.SetTMPColor(self._mapNode.txtTicketsCount, nRequire > nHas.nEnergy and Red_Unable or Blue_Normal)
|
|
self._mapNode.goCoin:SetActive(isNeedEnergyConsume)
|
|
elseif isOpen and not isLevelUnLock then
|
|
self._mapNode.btnListRoot:SetActive(false)
|
|
self._mapNode.ListConditions:SetActive(true)
|
|
local preLevelId = self.selectLevelData.baseData.PreLevelId
|
|
if preLevelId ~= 0 then
|
|
local lvPreNeedStar = self.selectLevelData.baseData.PreLevelStar
|
|
local lvPreStar = self.activityLevelsData:GetPreLevelStar(nType, self.selectLevelData.baseData.Id)
|
|
local imgConditions_Lock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_Lock").gameObject
|
|
local imgConditions_UnLock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_UnLock").gameObject
|
|
local txt = self._mapNode.ListConditionsObj[1].transform:Find("tex_ConditionsTips"):GetComponent("TMP_Text")
|
|
local tmpData = ConfigTable.GetData("ActivityLevelsLevel", preLevelId)
|
|
imgConditions_Lock_1:SetActive(lvPreNeedStar > lvPreStar)
|
|
imgConditions_UnLock_1:SetActive(lvPreNeedStar <= lvPreStar)
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_PreLevel"), tmpData.Name))
|
|
NovaAPI.SetTMPColor(txt, lvPreNeedStar <= lvPreStar and colorConditionsUnLock or colorConditionsLock)
|
|
else
|
|
local imgConditions_Lock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_Lock").gameObject
|
|
local imgConditions_UnLock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_UnLock").gameObject
|
|
local txt = self._mapNode.ListConditionsObj[1].transform:Find("tex_ConditionsTips"):GetComponent("TMP_Text")
|
|
imgConditions_Lock_1:SetActive(true)
|
|
imgConditions_UnLock_1:SetActive(false)
|
|
NovaAPI.SetTMPText(txt, ConfigTable.GetUIText("Unlocked_By_PreLevel"))
|
|
NovaAPI.SetTMPColor(txt, colorConditionsUnLock)
|
|
end
|
|
local preActivityStory = self.selectLevelData.baseData.PreActivityStory
|
|
if preActivityStory ~= nil and preActivityStory[1] ~= nil then
|
|
local isRead = PlayerData.ActivityAvg:IsStoryReaded(preActivityStory[2])
|
|
local imgConditions_Lock_2 = self._mapNode.ListConditionsObj[2].transform:Find("imgConditions_Lock").gameObject
|
|
local imgConditions_UnLock_2 = self._mapNode.ListConditionsObj[2].transform:Find("imgConditions_UnLock").gameObject
|
|
local txt = self._mapNode.ListConditionsObj[2].transform:Find("tex_ConditionsTips"):GetComponent("TMP_Text")
|
|
imgConditions_Lock_2:SetActive(not isRead)
|
|
imgConditions_UnLock_2:SetActive(isRead)
|
|
local cfgdata = ConfigTable.GetData("ActivityStory", preActivityStory[2])
|
|
if cfgdata ~= nil then
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Avg"), cfgdata.Title))
|
|
self._mapNode.ListConditionsObj[2]:SetActive(true)
|
|
NovaAPI.SetTMPColor(txt, isRead and colorConditionsUnLock or colorConditionsLock)
|
|
else
|
|
self._mapNode.ListConditionsObj[2]:SetActive(false)
|
|
end
|
|
else
|
|
self._mapNode.ListConditionsObj[2]:SetActive(false)
|
|
end
|
|
elseif not isOpen then
|
|
self._mapNode.btnListRoot:SetActive(false)
|
|
self._mapNode.ListConditions:SetActive(true)
|
|
self._mapNode.ListConditionsObj[2]:SetActive(false)
|
|
local imgConditions_Lock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_Lock").gameObject
|
|
local imgConditions_UnLock_1 = self._mapNode.ListConditionsObj[1].transform:Find("imgConditions_UnLock").gameObject
|
|
imgConditions_Lock_1:SetActive(true)
|
|
imgConditions_UnLock_1:SetActive(false)
|
|
NovaAPI.SetTMPColor(txt, colorConditionsUnLock)
|
|
local txt = self._mapNode.ListConditionsObj[1].transform:Find("tex_ConditionsTips"):GetComponent("TMP_Text")
|
|
local day = self.activityLevelsData:GetUnLockDay(nType, self.selectLevelData.baseData.Id)
|
|
if day == 0 then
|
|
local hour, min, sec = self.activityLevelsData:GetUnLockHour(nType, self.selectLevelData.baseData.Id)
|
|
if 0 < hour then
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Hour"), hour))
|
|
elseif 0 < min then
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Min"), min))
|
|
elseif 0 < sec then
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_Min"), min))
|
|
end
|
|
else
|
|
local _day, _hour = self.activityLevelsData:GetUnLockDayHour(nType, self.selectLevelData.baseData.Id)
|
|
NovaAPI.SetTMPText(txt, orderedFormat(ConfigTable.GetUIText("ActivityLevels_Lock_DayHourOpen"), _day, _hour))
|
|
local objTog = self._mapNode.tog[nHard].gameObject
|
|
local rtLockInfo = objTog.transform:Find("AnimRoot/AnimSwitch/rtLockInfo").gameObject
|
|
self.tmpLockInfoDay = rtLockInfo.gameObject.transform:Find("rtLockInfoDay"):GetComponent("Image")
|
|
NovaAPI.SetImageColor(self.tmpLockInfoDay, colorSelectLockMask)
|
|
end
|
|
end
|
|
for i = 1, #self.tabRewardList do
|
|
self.tabRewardList[i].gameObject:SetActive(false)
|
|
end
|
|
local tbReward = decodeJson(self.selectLevelData.baseData.CompleteRewardPreview)
|
|
for i = 1, #tbReward do
|
|
if i > #self.tabRewardList then
|
|
local obj = instantiate(self._mapNode.btn_itemTemp, self._mapNode.rewardRoot)
|
|
self.tabRewardList[i] = self:BindCtrlByNode(obj, "Game.UI.TemplateEx.TemplateItemCtrl")
|
|
end
|
|
do
|
|
local itemCtrl = self.tabRewardList[i]
|
|
itemCtrl.gameObject:SetActive(true)
|
|
if tbReward[i] ~= nil then
|
|
local bReceived = 0 < self.selectLevelData.Star and tbReward[i][3] == 1
|
|
local bFirstPass = tbReward[i][3] == 1
|
|
itemCtrl:SetItem(tbReward[i][1], nil, UTILS.ParseRewardItemCount(tbReward[i]), nil, bReceived, bFirstPass, false, true)
|
|
local btnItem = itemCtrl.gameObject:GetComponent("UIButton")
|
|
btnItem.onClick:RemoveAllListeners()
|
|
local clickCb = function()
|
|
self:OnBtnClick_RewardItem(tbReward[i][1], btnItem.gameObject)
|
|
end
|
|
btnItem.onClick:AddListener(clickCb)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_RewardItem(nTid, btn)
|
|
local rtBtn = btn.transform
|
|
UTILS.ClickItemGridWithTips(nTid, rtBtn, false, true, false)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnClickBtnGo()
|
|
local nEnergy = PlayerData.Base:GetCurEnergy().nEnergy
|
|
if nEnergy < self.curRequireEnergy then
|
|
local callback = function()
|
|
EventManager.Hit(EventId.ClosePanel, PanelId.EnergyBuy)
|
|
end
|
|
EventManager.Hit(EventId.OpenPanel, PanelId.EnergyBuy, AllEnum.EnergyPanelType.Main, {}, true, callback)
|
|
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("MainlineData_Energy"))
|
|
return
|
|
end
|
|
self.activityLevelsData:ChangeRedDot(self.selectLevelData.baseData.Type, self.selectLevelData.baseData.Id)
|
|
PlayerData.Activity:SetActivityLevelActId(self.nActId)
|
|
EventManager.Hit(EventId.OpenPanel, PanelId.RegionBossFormation, AllEnum.RegionBossFormationType.ActivityLevels, self.selectLevelData.baseData.Id, {
|
|
self.nActId
|
|
})
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnClickBtnRaid()
|
|
if self.curStar ~= 3 then
|
|
EventManager.Hit(EventId.OpenMessageBox, ConfigTable.GetUIText("Raid_Lock"))
|
|
return
|
|
end
|
|
local nNeedEnergy = self.curRequireEnergy
|
|
EventManager.Hit(EventId.OpenPanel, PanelId.Raid, self.selectLevelData.baseData.Id, nNeedEnergy, 5, self.nActId)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnBtnClick_EnemyInfo()
|
|
EventManager.Hit("OpenActivityLevelsMonsterInfo", self.PreviewMonsterGroupId)
|
|
end
|
|
function ActivityLevelsSelectCtrl:OnEvent_UpdateEnergy()
|
|
local nHas = PlayerData.Base:GetCurEnergy()
|
|
NovaAPI.SetTMPColor(self._mapNode.txtTicketsCount, nHas.nEnergy < self.curRequireEnergy and Red_Unable or Blue_Normal)
|
|
end
|
|
return ActivityLevelsSelectCtrl
|