579 lines
16 KiB
Lua
579 lines
16 KiB
Lua
|
|
local GEM_RECAST_TAB_TYPE = {
|
|
FORGE = 1,
|
|
RECAST = 2,
|
|
}
|
|
|
|
local GEM_RECAST_CTRL_TAB = {
|
|
[GEM_RECAST_TAB_TYPE.FORGE] = {
|
|
tabName = "tabForge",
|
|
nodeName = "forgeNode",
|
|
},
|
|
[GEM_RECAST_TAB_TYPE.RECAST] = {
|
|
tabName = "tabRecast",
|
|
nodeName = "recastNode",
|
|
}
|
|
}
|
|
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.GemRecast
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl = HL.Class('GemRecastCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.ON_GEM_RECAST] = "OnGemRecast",
|
|
[MessageConst.ON_ITEM_LOCKED_STATE_CHANGED] = '_OnItemLockedStateChanged',
|
|
[MessageConst.ON_GEM_DETACH] = 'OnGemDetach',
|
|
|
|
|
|
}
|
|
|
|
|
|
GemRecastCtrl.m_curTab = HL.Field(HL.Number) << GEM_RECAST_TAB_TYPE.FORGE
|
|
|
|
|
|
GemRecastCtrl.m_curSelectFormulaIndex = HL.Field(HL.Number) << -1
|
|
|
|
|
|
GemRecastCtrl.m_sortedFormulas = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
GemRecastCtrl.m_gemIngredientDict = HL.Field(HL.Table)
|
|
|
|
|
|
GemRecastCtrl.m_gemIngredientList = HL.Field(HL.Table)
|
|
|
|
|
|
GemRecastCtrl.m_starCellCache = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
GemRecastCtrl.m_rankCellCache = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
GemRecastCtrl.m_gemCellCache = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.m_curTab = GEM_RECAST_TAB_TYPE.FORGE
|
|
|
|
|
|
self.view.commonGemList.view.gameObject:SetActive(true)
|
|
self.view.commonGemList.view.gameObject:SetActive(false)
|
|
|
|
|
|
self:_InitActionEvent()
|
|
|
|
end
|
|
|
|
|
|
|
|
GemRecastCtrl._InitActionEvent = HL.Method() << function(self)
|
|
self.view.btnClose.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PhaseId.GemRecast)
|
|
end)
|
|
|
|
self.view.btnEmpty.onClick:AddListener(function()
|
|
self:_ToggleGemList(false)
|
|
end)
|
|
|
|
self.view.tabForge.button.onClick:AddListener(function()
|
|
self.m_curSelectFormulaIndex = -1
|
|
|
|
self:_RefreshMainPanel(GEM_RECAST_TAB_TYPE.FORGE)
|
|
end)
|
|
self.view.tabRecast.button.onClick:AddListener(function()
|
|
self.m_curSelectFormulaIndex = -1
|
|
|
|
self:_RefreshMainPanel(GEM_RECAST_TAB_TYPE.RECAST)
|
|
end)
|
|
self.view.btnAutoFill.onClick:AddListener(function()
|
|
local curFormula = self.m_sortedFormulas[self.m_curSelectFormulaIndex]
|
|
|
|
self:_AutoFill(curFormula)
|
|
end)
|
|
self.view.btnLevelUp.onClick:AddListener(function()
|
|
local curFormula = self.m_sortedFormulas[self.m_curSelectFormulaIndex]
|
|
|
|
local ingredients = {}
|
|
for instId, _ in pairs(self.m_gemIngredientDict) do
|
|
table.insert(ingredients, instId)
|
|
end
|
|
|
|
if #ingredients <= 0 then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_GEM_RECAST_GEM_EMPTY_TOAST)
|
|
return
|
|
end
|
|
|
|
if #ingredients < curFormula.costGemNum then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_GEM_RECAST_GEM_EMPTY_TOAST)
|
|
return
|
|
end
|
|
|
|
if curFormula.costItemNum > 0 then
|
|
local inventoryCount = Utils.getItemCount(curFormula.costItemId, true)
|
|
if inventoryCount < curFormula.costItemNum then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_GEM_RECAST_COST_EMPTY_TOAST)
|
|
return
|
|
end
|
|
end
|
|
|
|
GameInstance.player.inventory:RecastGem(curFormula.formulaId, 1, ingredients)
|
|
end)
|
|
|
|
self.m_starCellCache = UIUtils.genCellCache(self.view.starCell)
|
|
self.m_rankCellCache = UIUtils.genCellCache(self.view.forgeNode.rankCell)
|
|
self.m_gemCellCache = UIUtils.genCellCache(self.view.listCellGemRecastSmaller)
|
|
end
|
|
|
|
|
|
|
|
GemRecastCtrl.OnShow = HL.Override() << function(self)
|
|
self:_RefreshMainPanel(self.m_curTab)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshMainPanel = HL.Method(HL.Number) << function(self, curSelectTab)
|
|
self.view.btnEmpty.gameObject:SetActive(false)
|
|
|
|
self.m_curTab = curSelectTab
|
|
|
|
for tabType, cfg in pairs(GEM_RECAST_CTRL_TAB) do
|
|
self.view[cfg.tabName].selected.gameObject:SetActive(tabType == curSelectTab)
|
|
self.view[cfg.tabName].default.gameObject:SetActive(tabType ~= curSelectTab)
|
|
|
|
self.view[cfg.nodeName].gameObject:SetActive(tabType == curSelectTab)
|
|
end
|
|
|
|
self:_InitCommonNode(curSelectTab)
|
|
self:_ToggleGemList(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._InitCommonNode = HL.Method(HL.Number) << function(self, curSelectTab)
|
|
local firstUnlockIndex = nil
|
|
local sortedFormulas = {}
|
|
for i, cfg in pairs(Tables.gemRecastTable) do
|
|
if curSelectTab == GEM_RECAST_TAB_TYPE.FORGE then
|
|
if cfg.formulaType == GEnums.GemForgeFormulaType.Forge then
|
|
table.insert(sortedFormulas, cfg)
|
|
end
|
|
elseif curSelectTab == GEM_RECAST_TAB_TYPE.RECAST then
|
|
if cfg.formulaType == GEnums.GemForgeFormulaType.Recast then
|
|
table.insert(sortedFormulas, cfg)
|
|
end
|
|
end
|
|
end
|
|
table.sort(sortedFormulas, Utils.genSortFunction({"order"}, true))
|
|
|
|
|
|
for index, cfg in ipairs(sortedFormulas) do
|
|
local isLocked = not UIUtils.checkIfReachAdventureLv(cfg.adventureLevel)
|
|
|
|
if not isLocked and firstUnlockIndex == nil then
|
|
firstUnlockIndex = index
|
|
end
|
|
end
|
|
|
|
if firstUnlockIndex <= 0 then
|
|
logger.error("GemRecast->No recast formula unlocked")
|
|
return
|
|
end
|
|
|
|
self.m_sortedFormulas = sortedFormulas
|
|
if self.m_curSelectFormulaIndex < 0 then
|
|
self.m_curSelectFormulaIndex = firstUnlockIndex
|
|
end
|
|
self.m_gemIngredientDict = {}
|
|
self.m_gemIngredientList = {}
|
|
self:_RefreshForgeRankCellCache(sortedFormulas)
|
|
self:_RefreshForgeNode(sortedFormulas[self.m_curSelectFormulaIndex])
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshForgeRankCellCache = HL.Method(HL.Table) << function(self, sortedFormulas)
|
|
self.m_rankCellCache:Refresh(#sortedFormulas, function(cell, index)
|
|
local formula = sortedFormulas[index]
|
|
local isLocked = not UIUtils.checkIfReachAdventureLv(formula.adventureLevel)
|
|
|
|
local showProductItemId = formula.showProductItemId
|
|
local outputGemItemCfg = Tables.itemTable[showProductItemId]
|
|
|
|
cell.locked.gameObject:SetActive(isLocked)
|
|
local isSelected = index == self.m_curSelectFormulaIndex
|
|
cell.default.gameObject:SetActive(not isLocked and not isSelected)
|
|
if not isLocked then
|
|
if isSelected then
|
|
cell.selected.gameObject:SetActive(true)
|
|
else
|
|
cell.selectedAniWrp:PlayOutAnimation(function()
|
|
cell.selected.gameObject:SetActive(false)
|
|
end)
|
|
end
|
|
else
|
|
cell.selected.gameObject:SetActive(false)
|
|
end
|
|
|
|
cell.rank.text = outputGemItemCfg.rarity
|
|
cell.colorLine.color = UIUtils.getItemRarityColor(outputGemItemCfg.rarity)
|
|
|
|
|
|
cell.button.onClick:RemoveAllListeners()
|
|
cell.button.onClick:AddListener(function()
|
|
if isLocked then
|
|
Notify(MessageConst.SHOW_TOAST, string.format(Language.LUA_GEM_FORMULA_LOCKED_WITH_LV_TOAST, formula.adventureLevel))
|
|
return
|
|
end
|
|
|
|
self.m_curSelectFormulaIndex = index
|
|
|
|
self.m_gemIngredientDict = {}
|
|
self.m_gemIngredientList = {}
|
|
self:_RefreshForgeNode(formula)
|
|
self:_RefreshForgeRankCellCache(self.m_sortedFormulas)
|
|
end)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshForgeNode = HL.Method(HL.Userdata) << function(self, formula)
|
|
self.view.rightBarAniWrp:PlayInAnimation()
|
|
local outputGemId = formula.showProductItemId
|
|
local outputGemItemCfg = Tables.itemTable[outputGemId]
|
|
|
|
self.m_starCellCache:Refresh(outputGemItemCfg.rarity)
|
|
self.view.gemName.text = outputGemItemCfg.name
|
|
self.view.gemIconColor.color = UIUtils.getItemRarityColor(outputGemItemCfg.rarity)
|
|
|
|
local hasCostItem = formula.costItemId ~= nil and formula.costItemNum > 0
|
|
|
|
self.view.itemCostNode.gameObject:SetActive(hasCostItem)
|
|
self.view.itemCostNodeEmpty.gameObject:SetActive(not hasCostItem)
|
|
|
|
self.view.formulaHint:SetAndResolveTextStyle(formula.formulaHint)
|
|
|
|
self.view.costItem:InitItem({
|
|
id = formula.costItemId,
|
|
count = formula.costItemNum,
|
|
}, true)
|
|
local inventoryCount = Utils.getItemCount(formula.costItemId, true)
|
|
self.view.storageNode:InitStorageNode(inventoryCount, formula.costItemNum, true)
|
|
self.view.commonGemList:InitCommonItemList({
|
|
listType = UIConst.COMMON_ITEM_LIST_TYPE.GEM_RECAST,
|
|
refreshItemAddOn = function(cell, itemInfo)
|
|
self:_RefreshGemRecastCellAddOn(cell, itemInfo)
|
|
end,
|
|
onClickItem = function(args)
|
|
local itemInfo = args.itemInfo
|
|
|
|
args.nextCell.item:ShowTips()
|
|
|
|
self:_AddIngredient(itemInfo)
|
|
end,
|
|
filter_rarity = formula.costGemQuality
|
|
})
|
|
self:_RefreshGemCellCache(formula)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshCommonNode = HL.Method(HL.Userdata) << function(self, formula)
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshGemCellCache = HL.Method(HL.Userdata) << function(self, formula)
|
|
self.m_gemCellCache:Refresh(formula.costGemNum, function(cell, index)
|
|
local itemInfo = self.m_gemIngredientList[index]
|
|
|
|
if itemInfo then
|
|
local gemInst = CharInfoUtils.getGemByInstId(itemInfo.instId)
|
|
cell.item:InitItem({
|
|
id = gemInst.templateId,
|
|
instId = gemInst.instId,
|
|
}, true)
|
|
cell.item.view.button.onClick:RemoveAllListeners()
|
|
cell.item.view.button.onClick:AddListener(function()
|
|
self:_ToggleGemList(true)
|
|
end)
|
|
end
|
|
|
|
self:_RefreshGemRecastCellAddOn(cell, itemInfo)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._ToggleGemList = HL.Method(HL.Boolean) << function(self, isOn)
|
|
if isOn then
|
|
self.view.btnEmpty.gameObject:SetActive(true)
|
|
self.view.commonGemList.gameObject:SetActive(true)
|
|
else
|
|
self.view.commonGemList.view.animationWrapper:PlayOutAnimation(function()
|
|
self.view.btnEmpty.gameObject:SetActive(false)
|
|
self.view.commonGemList.gameObject:SetActive(false)
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RefreshGemRecastCellAddOn = HL.Method(HL.Table, HL.Opt(HL.Table, HL.Function)) << function(self, cell, itemInfo, onClick)
|
|
local isEmpty = itemInfo == nil
|
|
cell.btnEmpty.gameObject:SetActive(isEmpty)
|
|
cell.item.gameObject:SetActive(not isEmpty)
|
|
cell.currentSelected.gameObject:SetActive(not isEmpty)
|
|
cell.equipped.gameObject:SetActive(not isEmpty)
|
|
cell.btnDelete.gameObject:SetActive(not isEmpty)
|
|
cell.disableMask.gameObject:SetActive(false)
|
|
|
|
cell.btnEmpty.onClick:RemoveAllListeners()
|
|
cell.btnEmpty.onClick:AddListener(function()
|
|
self:_ToggleGemList(true)
|
|
end)
|
|
|
|
if isEmpty then
|
|
return
|
|
end
|
|
|
|
local instId = itemInfo.instId
|
|
local gemInst = CharInfoUtils.getGemByInstId(instId)
|
|
local isEquipped = gemInst.weaponInstId and gemInst.weaponInstId > 0
|
|
|
|
cell.equipped.gameObject:SetActive(isEquipped)
|
|
cell.btnDelete.onClick:RemoveAllListeners()
|
|
cell.btnDelete.onClick:AddListener(function()
|
|
self:_RemoveIngredient(itemInfo)
|
|
end)
|
|
|
|
local isSelected = self.m_gemIngredientDict[instId] ~= nil
|
|
cell.btnDelete.gameObject:SetActive(isSelected)
|
|
cell.currentSelected.gameObject:SetActive(isSelected)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._AddIngredient = HL.Method(HL.Table) << function(self, itemInfo)
|
|
local instId = itemInfo.instId
|
|
local curFormula = self.m_sortedFormulas[self.m_curSelectFormulaIndex]
|
|
if #self.m_gemIngredientList >= curFormula.costGemNum then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_GEM_FORMULA_ITEM_FULL_TOAST)
|
|
return
|
|
end
|
|
|
|
local isLock = GameInstance.player.inventory:IsItemLocked(Utils.getCurrentScope(), itemInfo.itemInst.templateId, itemInfo.itemInst.instId)
|
|
if isLock then
|
|
self:Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_EXHIBIT_UPGRADE_WEAPON_LOCKED)
|
|
return
|
|
end
|
|
|
|
local gemInst = CharInfoUtils.getGemByInstId(instId)
|
|
local isEquipped = gemInst.weaponInstId > 0
|
|
|
|
if isEquipped then
|
|
local weaponInst = CharInfoUtils.getWeaponByInstId(gemInst.weaponInstId)
|
|
local weaponItemCfg = Tables.itemTable[weaponInst.templateId]
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = string.format(Language.LUA_GEM_RECAST_GEM_EQUIPPED, weaponItemCfg.name),
|
|
onConfirm = function()
|
|
GameInstance.player.charBag:DetachGem(weaponInst.instId)
|
|
end,
|
|
onCancel = function()
|
|
end
|
|
})
|
|
return
|
|
end
|
|
|
|
|
|
self.m_gemIngredientDict[itemInfo.instId] = itemInfo
|
|
self.m_gemIngredientList = self:_GenerateIngredientList(self.m_gemIngredientDict)
|
|
|
|
self.view.commonGemList:RefreshCellById(instId)
|
|
self:_RefreshGemCellCache(curFormula)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._RemoveIngredient = HL.Method(HL.Table) << function(self, itemInfo)
|
|
local instId = itemInfo.instId
|
|
local curFormula = self.m_sortedFormulas[self.m_curSelectFormulaIndex]
|
|
local newGemList = {}
|
|
self.m_gemIngredientDict[instId] = nil
|
|
|
|
for instId, itemInfo in ipairs(self.m_gemIngredientDict) do
|
|
table.insert(newGemList, itemInfo)
|
|
end
|
|
|
|
self.m_gemIngredientList = self:_GenerateIngredientList(self.m_gemIngredientDict)
|
|
self.view.commonGemList:RefreshCellById(instId)
|
|
self:_RefreshGemCellCache(curFormula)
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._GenerateIngredientList = HL.Method(HL.Table).Return(HL.Table) << function(self, ingredientDict)
|
|
local ingredientList = {}
|
|
for instId, itemInfo in pairs(ingredientDict) do
|
|
table.insert(ingredientList, itemInfo)
|
|
end
|
|
|
|
local defaultSortKeys = UIConst.WEAPON_GEM_SORT_OPTION[1].keys
|
|
table.sort(ingredientList, Utils.genSortFunction(defaultSortKeys))
|
|
|
|
return ingredientList
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._AutoFill = HL.Method(HL.Userdata) << function(self, formula)
|
|
local newDict = {}
|
|
local newList = {}
|
|
|
|
local depotList = self.view.commonGemList.m_filteredInfoList
|
|
local needCount = formula.costGemNum
|
|
local collectCount = 0
|
|
for _, itemInfo in ipairs(depotList) do
|
|
local gemInst = CharInfoUtils.getGemByInstId(itemInfo.instId)
|
|
local hadEquipped = gemInst.weaponInstId and gemInst.weaponInstId > 0
|
|
local isLock = GameInstance.player.inventory:IsItemLocked(Utils.getCurrentScope(), itemInfo.itemInst.templateId, itemInfo.itemInst.instId)
|
|
|
|
if (not isLock) and (not hadEquipped) then
|
|
newDict[itemInfo.instId] = itemInfo
|
|
table.insert(newList, itemInfo)
|
|
collectCount = collectCount + 1
|
|
end
|
|
if collectCount >= needCount then
|
|
break
|
|
end
|
|
end
|
|
|
|
self.m_gemIngredientDict = newDict
|
|
self.m_gemIngredientList = newList
|
|
|
|
self:_RefreshGemCellCache(formula)
|
|
self.view.commonGemList:RefreshAllCells()
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl._OnItemLockedStateChanged = HL.Method(HL.Table) << function(self, arg)
|
|
local itemId, instId, isLock = unpack(arg)
|
|
if not isLock then
|
|
return
|
|
end
|
|
|
|
if not instId or instId <= 0 then
|
|
return
|
|
end
|
|
|
|
if self.m_gemIngredientDict[instId] then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_EXHIBIT_ITEM_LOCK_TOAST)
|
|
self:_RemoveIngredient(self.m_gemIngredientDict[instId])
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl.OnGemDetach = HL.Method(HL.Table) << function(self, arg)
|
|
self.view.commonGemList:RefreshAllCells()
|
|
end
|
|
|
|
|
|
|
|
|
|
GemRecastCtrl.OnGemRecast = HL.Method(HL.Table) << function(self, arg)
|
|
local title
|
|
if self.m_curTab == GEM_RECAST_TAB_TYPE.FORGE then
|
|
title = Language.LUA_GEM_FORGE_REWARD_TITLE
|
|
else
|
|
title = Language.LUA_GEM_RECAST_REWARD_TITLE
|
|
end
|
|
|
|
local gemInstIds = unpack(arg)
|
|
local items = {}
|
|
for _, v in pairs(gemInstIds) do
|
|
local gemInst = CharInfoUtils.getGemByInstId(v)
|
|
if gemInst ~= nil then
|
|
table.insert(items, {
|
|
id = gemInst.templateId,
|
|
instId = v,
|
|
count = 1,
|
|
})
|
|
end
|
|
end
|
|
|
|
if #items <= 0 then
|
|
return
|
|
end
|
|
|
|
Notify(MessageConst.SHOW_SYSTEM_REWARDS, {
|
|
title = title,
|
|
items = items,
|
|
})
|
|
|
|
self:_RefreshMainPanel(self.m_curTab)
|
|
end
|
|
|
|
|
|
HL.Commit(GemRecastCtrl)
|