1210 lines
39 KiB
Lua
1210 lines
39 KiB
Lua
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
||
local PANEL_ID = PanelId.AdventureDungeon
|
||
|
||
local SeriesTableFilterItem = {
|
||
[GEnums.DungeonCategoryType.BasicResource] = {},
|
||
[GEnums.DungeonCategoryType.CharResource] = {},
|
||
[GEnums.DungeonCategoryType.BossRush] = {},
|
||
[GEnums.DungeonCategoryType.SpecialResource] = {},
|
||
}
|
||
|
||
local IsSeriesTableFiltered = false
|
||
|
||
local TabDataList = {
|
||
{
|
||
type = GEnums.DungeonCategoryType.CharResource,
|
||
tabName = "ui_AdventureDungeonPanel_title_charmaterial",
|
||
imgPath = "deco_adventure_d_material",
|
||
},
|
||
{
|
||
type = GEnums.DungeonCategoryType.BasicResource,
|
||
tabName = "ui_AdventureDungeonPanel_title_basematerial",
|
||
imgPath = "deco_adventure_d_currency",
|
||
},
|
||
{
|
||
type = GEnums.DungeonCategoryType.BossRush,
|
||
tabName = "ui_AdventureDungeonPanel_title_boss",
|
||
imgPath = "deco_adventure_d_leaderchallenge",
|
||
},
|
||
{
|
||
type = GEnums.DungeonCategoryType.SpecialResource,
|
||
tabName = "ui_AdventureDungeonPanel_title_specialResource",
|
||
imgPath = "deco_adventure_d_challengethis",
|
||
},
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl = HL.Class('AdventureDungeonCtrl', uiCtrl.UICtrl)
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.s_messages = HL.StaticField(HL.Table) << {
|
||
|
||
[MessageConst.ON_SCENE_GRADE_CHANGE_NOTIFY] = '_OnSceneGradeChangeNotify',
|
||
[MessageConst.ON_CHANGE_ADVENTURE_DUNGEON_TAB] = '_OnChangeTab',
|
||
[MessageConst.ON_ADVENTURE_BOOK_FOCUS_WALLET] = '_OnFocusWallet',
|
||
[MessageConst.ON_ADVENTURE_BOOK_NOT_FOCUS_WALLET] = '_OnNotFocusWallet',
|
||
[MessageConst.ON_PHASE_ADVENTURE_BOOK_BEHIND] = '_OnPhaseBehind',
|
||
}
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.m_genTabCells = HL.Field(HL.Forward("UIListCache"))
|
||
|
||
|
||
AdventureDungeonCtrl.m_genCategoryCells = HL.Field(HL.Function)
|
||
|
||
|
||
AdventureDungeonCtrl.m_genSingleCategoryCells = HL.Field(HL.Function)
|
||
|
||
|
||
AdventureDungeonCtrl.m_curTabIndex = HL.Field(HL.Number) << 1
|
||
|
||
|
||
AdventureDungeonCtrl.m_dungeonCategoryInfos = HL.Field(HL.Table)
|
||
|
||
|
||
AdventureDungeonCtrl.m_forbidResetTabIndex = HL.Field(HL.Boolean) << false
|
||
|
||
|
||
AdventureDungeonCtrl.m_onGotoDungeon = HL.Field(HL.Function)
|
||
|
||
|
||
AdventureDungeonCtrl.m_useDungeonList = HL.Field(HL.Boolean) << true
|
||
|
||
|
||
AdventureDungeonCtrl.m_naviOnLeft = HL.Field(HL.Boolean) << true
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.m_dropdownDomainIds = HL.Field(HL.Table)
|
||
|
||
|
||
AdventureDungeonCtrl.m_filterdInfos = HL.Field(HL.Table)
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
||
self.m_phase = arg.phase
|
||
self:_InitShortCut()
|
||
self:_InitData()
|
||
self:_UpdateData()
|
||
self:_InitUI()
|
||
self:_RefreshAllUI()
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.OnClose = HL.Override() << function(self)
|
||
|
||
if self.m_curTabIndex > 0 and self.m_curTabIndex <= self.m_genTabCells:GetCount() then
|
||
self:_ReadTabRedDot(self.m_curTabIndex)
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnChangeTab = HL.Method(HL.Any) << function(self, arg)
|
||
local dungeonTab = arg
|
||
local index = 1
|
||
for _, categoryInfo in pairs(self.m_dungeonCategoryInfos) do
|
||
if categoryInfo.tabJumpName == dungeonTab then
|
||
break
|
||
end
|
||
index = index + 1
|
||
end
|
||
if index > #self.m_dungeonCategoryInfos then
|
||
logger.error(ELogChannel.UI, "[AdventureDungeonCtrl._OnChangeTab] 跳转到指定dungeonTab失败，可能是没解锁或配置错，tabName:" .. dungeonTab)
|
||
index = 1
|
||
end
|
||
self.m_curTabIndex = math.min(index, #self.m_dungeonCategoryInfos)
|
||
local cell = self.m_genTabCells:Get(self.m_curTabIndex)
|
||
cell.toggle:SetIsOnWithoutNotify(true)
|
||
self:_OnClickTabToggle(self.m_curTabIndex, true)
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnFocusWallet = HL.Method(HL.Any) << function(self, arg)
|
||
logger.info("[adventure] AdventureDungeonCtrl._OnFocusWallet")
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, false)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, false)
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnNotFocusWallet = HL.Method(HL.Any) << function(self, arg)
|
||
logger.info("[adventure] AdventureDungeonCtrl._OnNotFocusWallet")
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, not self.m_naviOnLeft)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, self.m_naviOnLeft)
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._InitUI = HL.Method() << function(self)
|
||
|
||
self.m_genTabCells = UIUtils.genCellCache(self.view.tabTogCell)
|
||
|
||
self.m_genCategoryCells = UIUtils.genCachedCellFunction(self.view.dungeonCategoryList)
|
||
self.view.dungeonCategoryList.onUpdateCell:AddListener(function(obj, csIndex)
|
||
local cell = self.m_genCategoryCells(obj)
|
||
self:_UpdateDungeonCategory(cell, LuaIndex(csIndex))
|
||
end)
|
||
self.view.dungeonCategoryListNaviGroup.getDefaultSelectableFunc = function()
|
||
local firstCell = self.m_genCategoryCells(1)
|
||
if firstCell ~= nil then
|
||
return firstCell.view.naviDecorator
|
||
end
|
||
end
|
||
|
||
self.m_genSingleCategoryCells = UIUtils.genCachedCellFunction(self.view.singleCategoryNode.singleCategoryList)
|
||
self.view.singleCategoryNode.singleCategoryList.onUpdateCell:AddListener(function(obj, csIndex)
|
||
local cell = self.m_genSingleCategoryCells(obj)
|
||
self:_UpdateSingleDungeonCell(cell, LuaIndex(csIndex))
|
||
end)
|
||
self.view.singleCategoryNode.naviGroup.getDefaultSelectableFunc = function()
|
||
local firstCell = self.m_genSingleCategoryCells(1)
|
||
if firstCell ~= nil then
|
||
return firstCell.view.naviDecorator
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._InitData = HL.Method() << function(self)
|
||
|
||
if not IsSeriesTableFiltered then
|
||
IsSeriesTableFiltered = true
|
||
for _, item in pairs(Tables.dungeonSeriesTable) do
|
||
local category = item.dungeonCategory
|
||
if SeriesTableFilterItem[category] then
|
||
table.insert(SeriesTableFilterItem[category], item)
|
||
end
|
||
end
|
||
end
|
||
|
||
self.m_onGotoDungeon = function()
|
||
self.m_forbidResetTabIndex = true
|
||
end
|
||
|
||
self:_HandleStaminaDiscount()
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.OnShow = HL.Override() << function(self)
|
||
self.m_forbidResetTabIndex = false
|
||
local cell = self.m_genTabCells:Get(self.m_curTabIndex)
|
||
if cell then
|
||
InputManagerInst.controllerNaviManager:SetTarget(cell.toggle)
|
||
end
|
||
|
||
if not string.isEmpty(self.m_phase.m_dungeonTab) then
|
||
local dungeonTab = self.m_phase.m_dungeonTab
|
||
self.m_phase.m_dungeonTab = ""
|
||
self:_OnChangeTab(dungeonTab)
|
||
end
|
||
|
||
Notify(MessageConst.HIDE_ITEM_TIPS)
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.OnHide = HL.Override() << function(self)
|
||
if self.m_forbidResetTabIndex then
|
||
return
|
||
end
|
||
local count = self.m_genTabCells:GetCount()
|
||
if count > 0 then
|
||
local cell = self.m_genTabCells:Get(1)
|
||
cell.toggle.isOn = true
|
||
end
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnPhaseBehind = HL.Method() << function(self)
|
||
if self.view.gameObject.activeSelf then
|
||
self.m_forbidResetTabIndex = true
|
||
end
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._UpdateData = HL.Method() << function(self)
|
||
self.m_dungeonCategoryInfos = { }
|
||
for _, v in pairs(TabDataList) do
|
||
self:_InitDataCommonDungeon(v.type, v.tabName, v.imgPath)
|
||
end
|
||
self:_InitDataMonsterSpawnPoint()
|
||
|
||
self.m_curTabIndex = math.min(self.m_curTabIndex, #self.m_dungeonCategoryInfos)
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._RefreshAllUI = HL.Method() << function(self)
|
||
self.m_genTabCells:Refresh(#self.m_dungeonCategoryInfos, function(cell, luaIndex)
|
||
self:_RefreshUITabCell(cell, luaIndex)
|
||
end)
|
||
self:_OnClickTabToggle(self.m_curTabIndex, true)
|
||
local cell = self.m_genTabCells:Get(1)
|
||
if cell then
|
||
InputManagerInst.controllerNaviManager:SetTarget(cell.toggle)
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnSceneGradeChangeNotify = HL.Method(HL.Table) << function(self, args)
|
||
self:_UpdateData()
|
||
self:_RefreshAllUI()
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._InitShortCut = HL.Method() << function(self)
|
||
if not DeviceInfo.usingController then
|
||
return
|
||
end
|
||
|
||
self:BindInputPlayerAction("adventure_dungeon_right", function()
|
||
logger.info("adventure_dungeon_right")
|
||
self.m_naviOnLeft = false
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, true)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, false)
|
||
if self.m_useDungeonList then
|
||
self.view.dungeonCategoryListNaviGroup:NaviToThisGroup(true)
|
||
else
|
||
self.view.singleCategoryNode.naviGroup:NaviToThisGroup(true)
|
||
end
|
||
end, self.view.tabTogMonoTarget.groupId)
|
||
self:BindInputPlayerAction("adventure_dungeon_right_hint", function()
|
||
logger.info("adventure_dungeon_right")
|
||
self.m_naviOnLeft = false
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, true)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, false)
|
||
if self.m_useDungeonList then
|
||
self.view.dungeonCategoryListNaviGroup:NaviToThisGroup(true)
|
||
else
|
||
self.view.singleCategoryNode.naviGroup:NaviToThisGroup(true)
|
||
end
|
||
end, self.view.tabTogMonoTarget.groupId)
|
||
|
||
self:BindInputPlayerAction("adventure_dungeon_left", function()
|
||
logger.info("adventure_dungeon_left")
|
||
self.m_naviOnLeft = true
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, false)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, true)
|
||
self.view.tabNaviGroup:NaviToThisGroup()
|
||
end, self.view.slideNodeMonoTarget.groupId)
|
||
self:BindInputPlayerAction("adventure_dungeon_left_hint", function()
|
||
logger.info("adventure_dungeon_left")
|
||
self.m_naviOnLeft = true
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, false)
|
||
InputManagerInst:ToggleGroup(self.view.tabTogMonoTarget.groupId, true)
|
||
self.view.tabNaviGroup:NaviToThisGroup()
|
||
end, self.view.slideNodeMonoTarget.groupId)
|
||
|
||
InputManagerInst:ToggleGroup(self.view.slideNodeMonoTarget.groupId, false)
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._InitDataCommonDungeon = HL.Method(HL.Any, HL.String, HL.String)
|
||
<< function(self, categoryType, tabName, tabImg)
|
||
|
||
local isCategoryUnlocked = GameInstance.player.adventure:IsAdventureDungeonFirCategoryUnlock(categoryType)
|
||
|
||
if not isCategoryUnlocked then
|
||
return
|
||
end
|
||
|
||
local tableDataList = SeriesTableFilterItem[categoryType]
|
||
if (#tableDataList <= 0) then
|
||
return
|
||
end
|
||
|
||
local newCategoryInfo = {
|
||
tabName = tabName,
|
||
tabImgPath = tabImg,
|
||
tabJumpName = categoryType:ToString(),
|
||
dungeonInfosList = {},
|
||
subGameIds = {},
|
||
showRelief = false,
|
||
}
|
||
|
||
local tempTable = {}
|
||
for _, tableData in pairs(tableDataList) do
|
||
local isUnlocked = GameInstance.player.adventure:IsAdventureDungeonCategoryTypeUnlocked(tableData.id, tableData.dungeonCategory)
|
||
|
||
if isUnlocked then
|
||
local category2ndType = tableData.dungeonCategory2nd
|
||
local infosBundle = tempTable[category2ndType]
|
||
if not infosBundle then
|
||
local cfgExist, category2ndTypeCfg = Tables.DungeonCategory2ndTable:TryGetValue(category2ndType)
|
||
infosBundle = {
|
||
category2ndType = category2ndType:GetHashCode(),
|
||
name = cfgExist and category2ndTypeCfg.name or "",
|
||
infos = {},
|
||
}
|
||
tempTable[tableData.dungeonCategory2nd] = infosBundle
|
||
end
|
||
|
||
local info = self:_HandleAndCreateSeriesInfo(tableData, newCategoryInfo)
|
||
if info then
|
||
|
||
table.insert(infosBundle.infos, info)
|
||
end
|
||
if info.costStamina then
|
||
newCategoryInfo.showRelief = true
|
||
end
|
||
end
|
||
end
|
||
|
||
for _, v in pairs(tempTable) do
|
||
table.sort(v.infos, Utils.genSortFunction({ "sortId" }, true))
|
||
table.insert(newCategoryInfo.dungeonInfosList, v)
|
||
end
|
||
table.sort(newCategoryInfo.dungeonInfosList, Utils.genSortFunction({ "category2ndType" }, true))
|
||
|
||
table.insert(self.m_dungeonCategoryInfos, newCategoryInfo)
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._HandleAndCreateSeriesInfo = HL.Method(HL.Any, HL.Table).Return(HL.Table)
|
||
<< function(self, seriesCfg, categoryInfo)
|
||
|
||
local hasCfg, dungeonTypeCfg = Tables.dungeonTypeTable:TryGetValue(seriesCfg.gameCategory)
|
||
if hasCfg then
|
||
local dungeonCategory = seriesCfg.dungeonCategory
|
||
local seriesId = seriesCfg.id
|
||
local isActive = (
|
||
(dungeonCategory == GEnums.DungeonCategoryType.CharResource or
|
||
dungeonCategory == GEnums.DungeonCategoryType.BasicResource or
|
||
dungeonCategory == GEnums.DungeonCategoryType.SpecialResource or
|
||
dungeonCategory == GEnums.DungeonCategoryType.BossRush) and
|
||
(GameInstance.dungeonManager:IsDungeonInteractiveActive(seriesId) or
|
||
dungeonCategory == GEnums.DungeonCategoryType.BossRush)
|
||
)
|
||
local info = {
|
||
seriesId = seriesId,
|
||
sortId = seriesCfg.sortId,
|
||
mapMarkType = dungeonTypeCfg.mapMarkType,
|
||
dungeonImg = self:_GetDungeonImg(seriesCfg.includeDungeonIds),
|
||
dungeonRoleImg = seriesCfg.dungeonRoleImg,
|
||
dungeonName = seriesCfg.name,
|
||
dungeonCategory = dungeonCategory,
|
||
staminaTxt = "",
|
||
isActive = isActive,
|
||
rewardInfos = self:_ProcessDungeonSeriesRewards(seriesId,
|
||
(dungeonCategory == GEnums.DungeonCategoryType.CharResource or
|
||
dungeonCategory == GEnums.DungeonCategoryType.BasicResource)),
|
||
subGameIds = {},
|
||
onGotoDungeon = self.m_onGotoDungeon,
|
||
costStamina = false,
|
||
}
|
||
|
||
local minStaminaCost = math.maxinteger
|
||
local maxStaminaCost = math.mininteger
|
||
for _, subGameId in pairs(seriesCfg.includeDungeonIds) do
|
||
table.insert(info.subGameIds, subGameId)
|
||
table.insert(categoryInfo.subGameIds, subGameId)
|
||
local cfg = Utils.tryGetTableCfg(Tables.gameMechanicTable, subGameId)
|
||
local isUnlocked = GameInstance.dungeonManager:IsDungeonUnlocked(subGameId)
|
||
if cfg and isUnlocked then
|
||
minStaminaCost = ActivityUtils.getRealStaminaCost(math.min(minStaminaCost, cfg.costStamina))
|
||
maxStaminaCost = ActivityUtils.getRealStaminaCost(math.max(maxStaminaCost, cfg.costStamina))
|
||
if cfg.costStamina > 0 then
|
||
info.costStamina = true
|
||
end
|
||
end
|
||
end
|
||
|
||
local count = #info.subGameIds
|
||
if count <= 0 or maxStaminaCost <= 0 then
|
||
info.staminaTxt = ""
|
||
elseif count == 1 then
|
||
info.staminaTxt = tostring(maxStaminaCost)
|
||
info.staminaMin = maxStaminaCost
|
||
info.staminaMax = maxStaminaCost
|
||
else
|
||
info.staminaMin = minStaminaCost
|
||
info.staminaMax = maxStaminaCost
|
||
if info.staminaMin ~= info.staminaMax then
|
||
info.staminaTxt = info.staminaMin .. "~" .. info.staminaMax
|
||
else
|
||
info.staminaTxt = info.staminaMin
|
||
end
|
||
end
|
||
|
||
if dungeonCategory == GEnums.DungeonCategoryType.BossRush then
|
||
self:_ProcessDungeonBossInfo(seriesId, info)
|
||
end
|
||
if dungeonCategory == GEnums.DungeonCategoryType.SpecialResource then
|
||
self:_ProcessDungeonBossInfo(seriesId, info)
|
||
info.dungeonImg = seriesCfg.dungeonImg
|
||
end
|
||
|
||
return info
|
||
end
|
||
|
||
return nil
|
||
end
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._InitDataMonsterSpawnPoint = HL.Method() << function(self)
|
||
|
||
local newCategoryInfo = {
|
||
tabName = "ui_AdventureDungeonPanel_title_enemyspawner",
|
||
tabImgPath = "deco_adventure_d_brushingmonsters",
|
||
tabJumpName = "EnemySpawner",
|
||
dungeonInfosList = {},
|
||
subGameIds = {},
|
||
showRelief = GameInstance.player.worldEnergyPointSystem.isFull,
|
||
}
|
||
|
||
local infosBundle = {
|
||
category2ndType = GEnums.DungeonCategory2ndType.None:GetHashCode(),
|
||
name = "",
|
||
infos = {},
|
||
}
|
||
table.insert(newCategoryInfo.dungeonInfosList, infosBundle)
|
||
|
||
self.m_dropdownDomainIds = { "All" }
|
||
|
||
for groupId, tableData in pairs(Tables.worldEnergyPointGroupTable) do
|
||
local id = GameInstance.player.worldEnergyPointSystem:GetCurSubGameId(groupId)
|
||
local canShow = false
|
||
if GameInstance.player.subGameSys:IsGameMapMarkUnlock(groupId, GEnums.MarkType.EnemySpawner) and
|
||
GameInstance.player.subGameSys:IsGameUnlocked(id) and
|
||
AdventureBookUtils.CheckEnemySpawnerCanOpenMap(groupId) then
|
||
canShow = true
|
||
end
|
||
if canShow and id ~= nil then
|
||
local hasCfg, gameCfg = Tables.gameMechanicTable:TryGetValue(id)
|
||
if hasCfg then
|
||
local info = {
|
||
seriesId = groupId,
|
||
gameGroupId = groupId,
|
||
sortId = groupId,
|
||
mapMarkType = GEnums.MarkType.EnemySpawner,
|
||
dungeonRoleImg = tableData.icon,
|
||
dungeonName = gameCfg.gameName,
|
||
staminaTxt = gameCfg.costStamina == 0 and
|
||
"" or tostring(ActivityUtils.getRealStaminaCost(gameCfg.costStamina)),
|
||
isActive = true,
|
||
rewardInfos = AdventureDungeonCtrl._ProcessMonsterSpawnRewards(groupId, id),
|
||
subGameIds = { id },
|
||
onGotoDungeon = self.m_onGotoDungeon,
|
||
}
|
||
local gemRandId = tableData.gemRandId
|
||
local _, domainId = Tables.GemItemDomainTable:TryGetValue(gemRandId)
|
||
info.domainId = domainId
|
||
table.insert(infosBundle.infos, info)
|
||
table.insert(newCategoryInfo.subGameIds, id)
|
||
|
||
if (lume.find(self.m_dropdownDomainIds, domainId)) == nil then
|
||
table.insert(self.m_dropdownDomainIds, domainId)
|
||
end
|
||
else
|
||
logger.error("[Game Mechanic Table] missing, id = " .. id)
|
||
end
|
||
end
|
||
end
|
||
|
||
if #newCategoryInfo.subGameIds <= 0 then
|
||
return
|
||
end
|
||
table.sort(infosBundle.infos, Utils.genSortFunction({ "sortId" }, true))
|
||
table.insert(self.m_dungeonCategoryInfos, newCategoryInfo)
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._RefreshUITabCell = HL.Method(HL.Table, HL.Number) << function(self, cell, luaIndex)
|
||
local tabInfo = self.m_dungeonCategoryInfos[luaIndex]
|
||
|
||
cell.gameObject.name = luaIndex
|
||
|
||
cell.tabNameTxt.text = Language[tabInfo.tabName]
|
||
cell.tabImg:LoadSprite(UIConst.UI_SPRITE_ADVENTURE, tabInfo.tabImgPath)
|
||
cell.toggle.isOn = luaIndex == self.m_curTabIndex
|
||
|
||
cell.toggle.onValueChanged:RemoveAllListeners()
|
||
cell.toggle.onValueChanged:AddListener(function(isOn)
|
||
if isOn and self.m_curTabIndex ~= luaIndex then
|
||
self:_OnClickTabToggle(luaIndex)
|
||
end
|
||
end)
|
||
|
||
cell.toggle.onHoverChange:RemoveAllListeners()
|
||
cell.toggle.onHoverChange:AddListener(function(isHover)
|
||
if cell.toggle.isOn then
|
||
return
|
||
end
|
||
if isHover then
|
||
cell.aniWrap:Play("adventuredungeontabtogcell_hover")
|
||
else
|
||
cell.aniWrap:Play("adventuredungeontabtogcell_normal")
|
||
end
|
||
end)
|
||
|
||
cell.toggle.onIsNaviTargetChanged = function(isTarget, isGroupChanged)
|
||
if isTarget then
|
||
cell.toggle.isOn = true
|
||
end
|
||
end
|
||
|
||
cell.redDot:InitRedDot("AdventureDungeonTab", tabInfo.subGameIds)
|
||
|
||
cell.reliefTab.gameObject:SetActive(ActivityUtils.hasStaminaReduceCount() and tabInfo.showRelief)
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._OnClickTabToggle = HL.Method(HL.Number, HL.Opt(HL.Boolean)) << function(self, luaIndex, isInit)
|
||
local count = #self.m_dungeonCategoryInfos
|
||
if count < luaIndex or luaIndex < 1 then
|
||
return
|
||
end
|
||
self.view.reliefNode.gameObject:SetActive((ActivityUtils.hasStaminaReduceCount() and self.m_dungeonCategoryInfos[luaIndex].showRelief))
|
||
local preIndex = self.m_curTabIndex
|
||
if (preIndex ~= luaIndex) then
|
||
|
||
self:_ReadTabRedDot(preIndex)
|
||
end
|
||
|
||
if DeviceInfo.usingController and self.m_curTabIndex ~= luaIndex then
|
||
AudioAdapter.PostEvent("Au_UI_Toggle_Common_On")
|
||
end
|
||
self.m_curTabIndex = luaIndex
|
||
local dungeonInfosList = self.m_dungeonCategoryInfos[luaIndex].dungeonInfosList
|
||
local listCount = #dungeonInfosList
|
||
|
||
if listCount > 1 then
|
||
self.view.dungeonCategoryList.gameObject:SetActiveIfNecessary(true)
|
||
self.view.singleCategoryNode.gameObject:SetActiveIfNecessary(false)
|
||
|
||
self.view.dungeonCategoryList:UpdateCount(listCount, true)
|
||
self.m_useDungeonList = true
|
||
elseif listCount == 1 then
|
||
local singleCategoryNode = self.view.singleCategoryNode
|
||
singleCategoryNode.gameObject:SetActiveIfNecessary(true)
|
||
self.view.dungeonCategoryList.gameObject:SetActiveIfNecessary(false)
|
||
|
||
local infosBundle = dungeonInfosList[1]
|
||
infosBundle.hasRead = true
|
||
local category2ndType = GEnums.DungeonCategory2ndType.__CastFrom(infosBundle.category2ndType)
|
||
if (category2ndType == GEnums.DungeonCategory2ndType.None) then
|
||
singleCategoryNode.titleState:SetState("HideTitle")
|
||
else
|
||
singleCategoryNode.titleState:SetState("ShowTitle")
|
||
singleCategoryNode.titleTxt.text = infosBundle.name
|
||
end
|
||
self.m_filterdInfos = infosBundle.infos
|
||
local cellCount = #infosBundle.infos
|
||
self.view.singleCategoryNode.singleCategoryList:UpdateCount(cellCount, true)
|
||
self.m_useDungeonList = false
|
||
end
|
||
|
||
if listCount > 0 then
|
||
local infoBundle = dungeonInfosList[1]
|
||
if string.isEmpty(infoBundle.name) then
|
||
self.view.titleBgMask.gameObject:SetActiveIfNecessary(true)
|
||
else
|
||
self.view.titleBgMask.gameObject:SetActiveIfNecessary(false)
|
||
end
|
||
else
|
||
self.view.titleBgMask.gameObject:SetActiveIfNecessary(true)
|
||
end
|
||
|
||
if self.m_dungeonCategoryInfos[luaIndex].tabJumpName == "EnemySpawner" then
|
||
self.view.siltationPoint.gameObject:SetActive(true)
|
||
self.view.dropDown:ClearComponent()
|
||
self.view.dropDown:Init(
|
||
function(csIndex, option, _)
|
||
local domainId = self.m_dropdownDomainIds[csIndex + 1]
|
||
local textId = "LUA_ADVENTURE_DUNGEON_ENEMY_SPAWNER_DROPNDOWN_" .. tostring(domainId)
|
||
option:SetText(Language[textId])
|
||
end,
|
||
function(csIndex)
|
||
logger.info("[adventure] dropdown csIndex: " .. tostring(csIndex))
|
||
local infos = self.m_dungeonCategoryInfos[self.m_curTabIndex].dungeonInfosList[1].infos
|
||
local selectDomainId = self.m_dropdownDomainIds[csIndex + 1]
|
||
local filtered = lume.filter(infos, function(x)
|
||
if selectDomainId == "All" then
|
||
return true
|
||
end
|
||
return x.domainId == selectDomainId
|
||
end)
|
||
self.m_filterdInfos = filtered
|
||
self.view.singleCategoryNode.singleCategoryList:UpdateCount(#filtered, true)
|
||
end
|
||
)
|
||
self.view.dropDown:Refresh(#self.m_dropdownDomainIds, 0, false)
|
||
else
|
||
self.view.siltationPoint.gameObject:SetActive(false)
|
||
end
|
||
|
||
if not isInit then
|
||
local aniWrapper = self.animationWrapper
|
||
aniWrapper:Play("adventuredungeonnode_change")
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ReadTabRedDot = HL.Method(HL.Number) << function(self, luaIndex)
|
||
if luaIndex <= 0 or luaIndex > #self.m_dungeonCategoryInfos then
|
||
return
|
||
end
|
||
|
||
local subGameIds = {}
|
||
local categoryInfo = self.m_dungeonCategoryInfos[luaIndex]
|
||
for _, infosBundle in pairs(categoryInfo.dungeonInfosList) do
|
||
if infosBundle.hasRead then
|
||
for _, info in pairs(infosBundle.infos) do
|
||
if info.hasRead then
|
||
for _, id in pairs(info.subGameIds) do
|
||
table.insert(subGameIds, id)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
if (#subGameIds) > 0 then
|
||
GameInstance.player.subGameSys:SendSubGameListRead(subGameIds)
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._UpdateDungeonCategory = HL.Method(HL.Any, HL.Number) << function(self, cell, luaIndex)
|
||
local infosBundle = self.m_dungeonCategoryInfos[self.m_curTabIndex].dungeonInfosList[luaIndex]
|
||
cell:InitDungeonCategoryCell(infosBundle)
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._UpdateSingleDungeonCell = HL.Method(HL.Any, HL.Number) << function(self, cell, luaIndex)
|
||
local cellInfo = nil
|
||
if self.m_filterdInfos ~= nil then
|
||
cellInfo = self.m_filterdInfos[luaIndex]
|
||
else
|
||
local infosBundle = self.m_dungeonCategoryInfos[self.m_curTabIndex].dungeonInfosList[1]
|
||
cellInfo = infosBundle.infos[luaIndex]
|
||
end
|
||
|
||
cell:InitAdventureDungeonCell(cellInfo)
|
||
cellInfo.hasRead = true
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessDungeonSeriesRewards = HL.Method(HL.String, HL.Boolean).Return(HL.Table) << function(self, seriesId, checkUnlocked)
|
||
local dungeonSeriesCfg = Tables.dungeonSeriesTable[seriesId]
|
||
if not dungeonSeriesCfg then
|
||
return {}
|
||
end
|
||
|
||
local rewardList = {}
|
||
if dungeonSeriesCfg.dungeonCategory == GEnums.DungeonCategoryType.Challenge then
|
||
for _, v in pairs(dungeonSeriesCfg.includeDungeonIds) do
|
||
self:_ProcessDungeonRewardsNoMerge(v, rewardList)
|
||
end
|
||
elseif dungeonSeriesCfg.dungeonCategory == GEnums.DungeonCategoryType.BossRush or
|
||
dungeonSeriesCfg.dungeonCategory == GEnums.DungeonCategoryType.SpecialResource then
|
||
local dungeonIds = {}
|
||
for _, v in pairs(dungeonSeriesCfg.includeDungeonIds) do
|
||
table.insert(dungeonIds, v)
|
||
end
|
||
self:_ProcessDungeonRewardsBoss(dungeonIds, rewardList)
|
||
else
|
||
local rewards = {}
|
||
for _, v in pairs(dungeonSeriesCfg.includeDungeonIds) do
|
||
self:_ProcessDungeonRewards(v, rewards, checkUnlocked)
|
||
end
|
||
for _, v in pairs(rewards) do
|
||
table.insert(rewardList, v)
|
||
end
|
||
end
|
||
table.sort(rewardList, Utils.genSortFunction({ "gainedSortId", "rewardTypeSortId", "rarity", "type" }))
|
||
return rewardList
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessDungeonRewards = HL.Method(HL.String, HL.Table, HL.Boolean) << function(self, dungeonId, rewards, checkUnlocked)
|
||
if checkUnlocked and not GameInstance.dungeonManager:IsDungeonUnlocked(dungeonId) then
|
||
logger.info("[dungeon] 跳过了" .. tostring(dungeonId))
|
||
return
|
||
end
|
||
|
||
local gameMechanicCfg = Tables.gameMechanicTable[dungeonId]
|
||
|
||
local hasFirstReward = not string.isEmpty(gameMechanicCfg.firstPassRewardId)
|
||
local hasRecycleReward = not string.isEmpty(gameMechanicCfg.rewardId)
|
||
local hasExtraReward = not string.isEmpty(gameMechanicCfg.extraRewardId)
|
||
|
||
|
||
if hasFirstReward then
|
||
local succ, rewardsCfg = Tables.rewardTable:TryGetValue(gameMechanicCfg.firstPassRewardId)
|
||
if succ then
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemId = itemBundle.id
|
||
local reward = rewards[itemId]
|
||
if not reward then
|
||
local itemCfg = Tables.itemTable[itemId]
|
||
reward = {
|
||
id = itemId,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 3,
|
||
gained = false,
|
||
}
|
||
rewards[itemId] = reward
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
if hasRecycleReward then
|
||
local hasCfg, rewardsCfg = Tables.rewardTable:TryGetValue(gameMechanicCfg.rewardId)
|
||
if hasCfg then
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemId = itemBundle.id
|
||
local reward = rewards[itemId]
|
||
if not reward then
|
||
local itemCfg = Tables.itemTable[itemId]
|
||
reward = {
|
||
id = itemId,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 1,
|
||
gained = false,
|
||
}
|
||
rewards[itemId] = reward
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
if hasExtraReward then
|
||
local rewardsCfg = Tables.rewardTable[gameMechanicCfg.extraRewardId]
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemId = itemBundle.id
|
||
local reward = rewards[itemId]
|
||
if not reward then
|
||
local itemCfg = Tables.itemTable[itemId]
|
||
reward = {
|
||
id = itemId,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 2,
|
||
gained = false,
|
||
}
|
||
rewards[itemId] = reward
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessDungeonRewardsNoMerge = HL.Method(HL.String, HL.Table) << function(self, dungeonId, rewards)
|
||
local dungeonMgr = GameInstance.dungeonManager
|
||
local gameMechanicCfg = Tables.gameMechanicTable[dungeonId]
|
||
|
||
local hasFirstReward = not string.isEmpty(gameMechanicCfg.firstPassRewardId)
|
||
local hasRecycleReward = not string.isEmpty(gameMechanicCfg.rewardId)
|
||
local hasExtraReward = not string.isEmpty(gameMechanicCfg.extraRewardId)
|
||
|
||
|
||
if hasFirstReward then
|
||
local firstRewardGained = dungeonMgr:IsDungeonFirstPassRewardGained(dungeonId)
|
||
local hideFirstReward = firstRewardGained and hasRecycleReward
|
||
if not hideFirstReward then
|
||
local rewardsCfg = Tables.rewardTable[gameMechanicCfg.firstPassRewardId]
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemCfg = Tables.itemTable[itemBundle.id]
|
||
local reward = {
|
||
id = itemBundle.id,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = true,
|
||
isExtra = false,
|
||
gainedSortId = firstRewardGained and 1 or 2,
|
||
rewardTypeSortId = 3,
|
||
gained = firstRewardGained,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
if hasRecycleReward then
|
||
local rewardsCfg = Tables.rewardTable[gameMechanicCfg.rewardId]
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemCfg = Tables.itemTable[itemBundle.id]
|
||
local reward = {
|
||
id = itemBundle.id,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = false,
|
||
isExtra = false,
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 1,
|
||
gained = false,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
end
|
||
|
||
|
||
if hasExtraReward then
|
||
local extraRewardGained = dungeonMgr:IsDungeonExtraRewardGained(dungeonId)
|
||
local hideExtraReward = extraRewardGained and hasRecycleReward
|
||
if not hideExtraReward then
|
||
local rewardsCfg = Tables.rewardTable[gameMechanicCfg.extraRewardId]
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemCfg = Tables.itemTable[itemBundle.id]
|
||
local reward = {
|
||
id = itemBundle.id,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = false,
|
||
isExtra = true,
|
||
gainedSortId = extraRewardGained and 1 or 2,
|
||
rewardTypeSortId = 2,
|
||
gained = extraRewardGained,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessDungeonRewardsBoss = HL.Method(HL.Table, HL.Table) << function(self, dungeonIds, rewards)
|
||
local dungeonMgr = GameInstance.dungeonManager
|
||
|
||
local lastUnlockedDungeonId = ""
|
||
for _, dungeonId in ipairs(dungeonIds) do
|
||
if dungeonMgr:IsDungeonUnlocked(dungeonId) then
|
||
lastUnlockedDungeonId = dungeonId
|
||
end
|
||
end
|
||
if (lastUnlockedDungeonId == "") then
|
||
return
|
||
end
|
||
|
||
local gameMechanicCfg = Tables.gameMechanicTable[lastUnlockedDungeonId]
|
||
local dungeonCfg = Tables.dungeonTable[lastUnlockedDungeonId]
|
||
|
||
local hasFirstReward = not string.isEmpty(gameMechanicCfg.firstPassRewardId)
|
||
local hasHunterReward = not string.isEmpty(gameMechanicCfg.hunterModeRewardId)
|
||
|
||
|
||
if hasFirstReward then
|
||
local firstRewardGained = dungeonMgr:IsDungeonFirstPassRewardGained(lastUnlockedDungeonId)
|
||
local rewardsCfg = Tables.rewardTable[gameMechanicCfg.firstPassRewardId]
|
||
for _, itemBundle in pairs(rewardsCfg.itemBundles) do
|
||
local itemCfg = Tables.itemTable[itemBundle.id]
|
||
local reward = {
|
||
id = itemBundle.id,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = true,
|
||
isExtra = false,
|
||
gainedSortId = firstRewardGained and 1 or 2,
|
||
rewardTypeSortId = 3,
|
||
gained = firstRewardGained,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
end
|
||
|
||
|
||
if hasHunterReward then
|
||
local isHunterModeUnlocked = DungeonUtils.isHunterModeUnlocked()
|
||
|
||
for _, regularItemId in pairs(dungeonCfg.hunterModeRegularRewards) do
|
||
local itemCfg = Tables.itemTable[regularItemId]
|
||
local reward = {
|
||
id = regularItemId,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = false,
|
||
isExtra = false,
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 1,
|
||
gained = false,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
|
||
|
||
for _, randomItemId in pairs(dungeonCfg.hunterModeProbRewards) do
|
||
local succ, itemCfg = Tables.itemTable:TryGetValue(randomItemId)
|
||
if succ then
|
||
local reward = {
|
||
id = randomItemId,
|
||
rarity = itemCfg.rarity,
|
||
type = itemCfg.type:ToInt(),
|
||
|
||
isFirst = false,
|
||
isExtra = false,
|
||
gainedSortId = 1,
|
||
rewardTypeSortId = 1,
|
||
gained = false,
|
||
}
|
||
table.insert(rewards, reward)
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessDungeonBossInfo = HL.Method(HL.String, HL.Table) << function(self, seriesId, info)
|
||
local dungeonSeriesData = Tables.DungeonSeriesTable[seriesId]
|
||
|
||
local lastUnlockedDungeonId = ""
|
||
for _, dungeonId in pairs(dungeonSeriesData.includeDungeonIds) do
|
||
if GameInstance.dungeonManager:IsDungeonUnlocked(dungeonId) then
|
||
lastUnlockedDungeonId = dungeonId
|
||
end
|
||
end
|
||
if lastUnlockedDungeonId == "" then
|
||
return
|
||
end
|
||
|
||
info.isHunterMode = DungeonUtils.isDungeonHasHunterMode(lastUnlockedDungeonId) and
|
||
DungeonUtils.isHunterModeUnlocked()
|
||
local dungeonData = Tables.DungeonTable[lastUnlockedDungeonId]
|
||
if info.isHunterMode then
|
||
info.staminaTxt = tostring(ActivityUtils.getRealStaminaCost(dungeonData.hunterModeCostStamina))
|
||
if dungeonData.hunterModeCostStamina > 0 then
|
||
info.costStamina = true
|
||
end
|
||
end
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._GetDungeonImg = HL.Method(HL.Any).Return(HL.Opt(HL.String)) << function(self, dungeonIds)
|
||
local ret = nil
|
||
for _, dungeonId in pairs(dungeonIds) do
|
||
local unlocked = GameInstance.dungeonManager:IsDungeonUnlocked(dungeonId)
|
||
if unlocked then
|
||
local _, dungeonCfg = Tables.DungeonTable:TryGetValue(dungeonId)
|
||
if dungeonCfg then
|
||
ret = dungeonCfg.dungeonImg
|
||
end
|
||
end
|
||
end
|
||
return ret
|
||
end
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._ProcessMonsterSpawnRewards = HL.StaticMethod(HL.String, HL.String).Return(HL.Table) << function(groupId, gameId)
|
||
local rewards = {}
|
||
local rewardList = {}
|
||
|
||
local isFull = GameInstance.player.worldEnergyPointSystem.isFull
|
||
|
||
local wepGroupCfg = Tables.worldEnergyPointGroupTable[groupId]
|
||
local wepCfg = Tables.worldEnergyPointTable[gameId]
|
||
local firstRewardGained = GameInstance.player.worldEnergyPointSystem:IsGameGroupFirstPassRewardGained(groupId)
|
||
if not firstRewardGained or not isFull then
|
||
local firstPartRewards = {}
|
||
local rewardCfg = Tables.rewardTable[wepGroupCfg.firstPassRewardId]
|
||
for _, itemBundle in pairs(rewardCfg.itemBundles) do
|
||
local reward = AdventureDungeonCtrl._GenRewardInfo(DungeonConst.DUNGEON_REWARD_TAG_STATE.First, -1, firstRewardGained,
|
||
itemBundle.id, itemBundle.count)
|
||
table.insert(firstPartRewards, reward)
|
||
end
|
||
table.sort(firstPartRewards, Utils.genSortFunction(UIConst.COMMON_ITEM_SORT_KEYS))
|
||
for _, item in pairs(firstPartRewards) do
|
||
item.isFirst = true,
|
||
table.insert(rewardList, item)
|
||
end
|
||
end
|
||
|
||
if isFull then
|
||
local secondPartRewards = {}
|
||
for i = 0, wepCfg.probGemItemIds.Count - 1 do
|
||
local itemId = wepCfg.probGemItemIds[i]
|
||
local reward = AdventureDungeonCtrl._GenRewardInfo(DungeonConst.DUNGEON_REWARD_TAG_STATE.Random, -3, false, itemId)
|
||
table.insert(secondPartRewards, reward)
|
||
end
|
||
table.sort(secondPartRewards, Utils.genSortFunction(UIConst.COMMON_ITEM_SORT_KEYS))
|
||
|
||
for _, item in pairs(secondPartRewards) do
|
||
item.isFirst = false,
|
||
table.insert(rewardList, item)
|
||
end
|
||
end
|
||
|
||
return rewardList
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._GenRewardInfo = HL.StaticMethod(HL.String, HL.Number, HL.Boolean, HL.String, HL.Opt(HL.Number)).Return(HL.Table)
|
||
<< function(tagState, rewardTypeSortId, gained, itemId, itemCount)
|
||
local itemCfg = Tables.itemTable[itemId]
|
||
return {
|
||
id = itemId,
|
||
count = itemCount,
|
||
gained = gained,
|
||
tagState = tagState,
|
||
|
||
gainedSortId = gained and 0 or 1,
|
||
rewardTypeSortId = rewardTypeSortId,
|
||
sortId1 = itemCfg.sortId1,
|
||
sortId2 = itemCfg.sortId2,
|
||
}
|
||
end
|
||
|
||
|
||
|
||
|
||
|
||
AdventureDungeonCtrl.m_discount = HL.Field(HL.Number) << 0
|
||
|
||
|
||
|
||
AdventureDungeonCtrl._HandleStaminaDiscount = HL.Method() << function(self)
|
||
local totalCount = GameInstance.player.activitySystem.staminaTotalCount
|
||
local useCount = GameInstance.player.activitySystem.staminaReduceUsedCount
|
||
self.m_discount = GameInstance.player.activitySystem.staminaDiscount
|
||
|
||
|
||
self.view.blackNum.gameObject:SetActive(ActivityUtils.hasStaminaReduceCount())
|
||
self.view.blackNum.text = totalCount - useCount
|
||
self.view.redNum.gameObject:SetActive(not ActivityUtils.hasStaminaReduceCount())
|
||
self.view.redNum.text = totalCount - useCount
|
||
self.view.numTxt.text = string.format("/%d", totalCount)
|
||
end
|
||
|
||
|
||
HL.Commit(AdventureDungeonCtrl)
|