842 lines
25 KiB
Lua
842 lines
25 KiB
Lua
local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot = HL.Class('Depot', UIWidgetBase)
|
|
|
|
|
|
|
|
|
|
|
|
Depot.depotContent = HL.Field(HL.Forward("DepotContent"))
|
|
|
|
|
|
Depot.m_extraArgs = HL.Field(HL.Table)
|
|
|
|
|
|
Depot.m_inInit = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
Depot.m_inited = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
Depot.m_curTypeIndex = HL.Field(HL.Number) << -1
|
|
|
|
|
|
Depot.m_itemShowingTypeInfos = HL.Field(HL.Table)
|
|
|
|
|
|
Depot.m_sortOptions = HL.Field(HL.Table)
|
|
|
|
|
|
Depot.m_nonValidShowTypes = HL.Field(HL.Table)
|
|
|
|
|
|
Depot.m_typeCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
Depot.m_valuableDepotType = HL.Field(GEnums.ItemValuableDepotType)
|
|
|
|
|
|
Depot.m_onClickItemAction = HL.Field(HL.Function)
|
|
|
|
|
|
Depot.m_onToggleDestroyMode = HL.Field(HL.Function)
|
|
|
|
|
|
Depot.m_onChangeTypeFunction = HL.Field(HL.Function)
|
|
|
|
|
|
Depot.m_oriPaddingBottom = HL.Field(HL.Number) << 0
|
|
|
|
|
|
Depot.m_waitInitNaviTarget = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot._OnFirstTimeInit = HL.Override() << function(self)
|
|
self.m_typeCells = UIUtils.genCellCache(self.view.typeCell)
|
|
self.depotContent = self.view.depotContent
|
|
|
|
local canDes = self.view.config.CAN_DESTROY
|
|
self.view.destroyBtn.gameObject:SetActive(canDes)
|
|
self.view.destroyNode.gameObject:SetActive(false)
|
|
if canDes then
|
|
self:_InitDestroyNode()
|
|
else
|
|
self.m_destroyInfo = {}
|
|
end
|
|
|
|
self.m_oriPaddingBottom = self.depotContent.view.itemList:GetPadding().bottom
|
|
|
|
|
|
self.view.sortNode:InitSortNode(self.m_sortOptions, function(optData, isIncremental)
|
|
self:_OnSortChanged(optData, isIncremental)
|
|
end, nil, nil, true)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot.InitDepot = HL.Method(GEnums.ItemValuableDepotType, HL.Opt(HL.Function, HL.Table)) << function(self, valuableDepotType, onClickItemAction, extraArgs)
|
|
self.m_sortOptions = extraArgs.sortOptions or UIConst.FAC_DEPOT_SORT_OPTIONS
|
|
self:_FirstTimeInit()
|
|
|
|
self.m_inInit = true
|
|
|
|
extraArgs = extraArgs or {}
|
|
self.m_extraArgs = extraArgs
|
|
self.m_nonValidShowTypes = extraArgs.nonValidShowTypes
|
|
|
|
self.m_valuableDepotType = valuableDepotType
|
|
self:_RefreshShowingTypeData()
|
|
local domainId = Utils.getCurDomainId()
|
|
if extraArgs.domainId ~= nil then
|
|
domainId = extraArgs.domainId
|
|
end
|
|
local succ, domainData = Tables.domainDataTable:TryGetValue(domainId)
|
|
if succ then
|
|
self.view.titleTxt.text = domainData.storageName
|
|
self.view.titleBg.color = UIUtils.getColorByString(domainData.domainColor)
|
|
else
|
|
|
|
self.view.titleTxt.text = Language.LUA_BLACK_BOX_DEPOT_NAME
|
|
self.view.titleBg.color = self.view.config.BLACK_BOX_TITLE_BG_COLOR
|
|
end
|
|
|
|
self.m_onClickItemAction = onClickItemAction
|
|
self.m_onToggleDestroyMode = extraArgs.onToggleDestroyMode
|
|
self.m_onChangeTypeFunction = extraArgs.onChangeTypeFunction
|
|
self.m_waitInitNaviTarget = extraArgs.needInitNaviTarget == true
|
|
extraArgs.showingTypes = self.m_itemShowingTypeInfos[self.m_curTypeIndex].types
|
|
extraArgs.isIncremental = self.view.sortNode.isIncremental
|
|
extraArgs.sortKeys = self.view.sortNode:GetCurSortKeys()
|
|
|
|
extraArgs.beforeFindAndHighlightForDrop = function(id)
|
|
local itemData = Tables.itemTable[id]
|
|
local showingTypes = self.m_itemShowingTypeInfos[self.m_curTypeIndex].types
|
|
if showingTypes and not lume.find(showingTypes, itemData.showingType) then
|
|
for k, info in ipairs(self.m_itemShowingTypeInfos) do
|
|
if info.types and lume.find(info.types, itemData.showingType) then
|
|
self.m_typeCells:Get(k).toggle.isOn = true
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local externalCustomOnUpdateCell = extraArgs.customOnUpdateCell
|
|
extraArgs.customOnUpdateCell = function(cell, info, luaIndex)
|
|
self:_CustomOnUpdateCell(cell, info, luaIndex)
|
|
if externalCustomOnUpdateCell then
|
|
externalCustomOnUpdateCell(cell, info, luaIndex)
|
|
end
|
|
end
|
|
|
|
self.depotContent:InitDepotContent(valuableDepotType, function(itemId, cell)
|
|
self:_OnClickItem(itemId, cell)
|
|
end, extraArgs)
|
|
self:_RefreshShowingTypeList(extraArgs.blockEmptyType)
|
|
|
|
self.m_inInit = false
|
|
self.m_inited = true
|
|
end
|
|
|
|
|
|
|
|
|
|
Depot._RefreshShowingTypeList = HL.Method(HL.Opt(HL.Boolean)) << function(self, blockEmptyType)
|
|
if blockEmptyType then
|
|
local allItemList = self.depotContent:GetAllItemInfo()
|
|
local typeMap = {}
|
|
for _, info in ipairs(allItemList) do
|
|
if not typeMap[info.showingType] then
|
|
typeMap[info.showingType] = true
|
|
end
|
|
end
|
|
local resultTypeInfos = {}
|
|
for _, info in ipairs(self.m_itemShowingTypeInfos) do
|
|
if info.types ~= nil then
|
|
for _, type in ipairs(info.types) do
|
|
if typeMap[type] == true then
|
|
table.insert(resultTypeInfos, info)
|
|
break
|
|
end
|
|
end
|
|
else
|
|
table.insert(resultTypeInfos, info)
|
|
end
|
|
end
|
|
self.m_itemShowingTypeInfos = resultTypeInfos
|
|
end
|
|
|
|
self.view.typesNode.gameObject:SetActive(false)
|
|
self.m_typeCells:Refresh(#self.m_itemShowingTypeInfos, function(cell, index)
|
|
local info = self.m_itemShowingTypeInfos[index]
|
|
|
|
cell.dimIcon:LoadSprite(UIConst.UI_SPRITE_INVENTORY, info.icon)
|
|
cell.lightIcon:LoadSprite(UIConst.UI_SPRITE_INVENTORY, info.icon)
|
|
|
|
if cell.name then
|
|
cell.name.text = info.name
|
|
end
|
|
|
|
local isSelected = index == self.m_curTypeIndex
|
|
cell.decoLine.gameObject:SetActive(not (isSelected or index == 1 or index == (self.m_curTypeIndex + 1)))
|
|
self:_RefreshTypeCellSelectedState(cell, isSelected)
|
|
|
|
cell.toggle.onValueChanged:RemoveAllListeners()
|
|
cell.toggle.isOn = isSelected
|
|
cell.toggle.onValueChanged:AddListener(function(isOn)
|
|
if isOn and self.m_curTypeIndex ~= index then
|
|
self.depotContent:ReadCurShowingItems()
|
|
self:_OnClickShowingType(cell, index)
|
|
end
|
|
end)
|
|
|
|
cell.gameObject.name = "TypeCell_" .. index
|
|
end)
|
|
self.view.typesNode.gameObject:SetActive(true)
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(self.view.typesNode.transform)
|
|
end
|
|
|
|
|
|
|
|
Depot._RefreshShowingTypeData = HL.Method() << function(self)
|
|
self.m_curTypeIndex = 1
|
|
self.m_itemShowingTypeInfos = {
|
|
{
|
|
name = Language.LUA_FAC_ALL,
|
|
icon = "icon_item_type_all",
|
|
}
|
|
}
|
|
local showingTypes = UIConst.FACTORY_DEPOT_SHOWING_TYPES
|
|
for _, v in ipairs(showingTypes) do
|
|
if not self.m_nonValidShowTypes or not lume.find(self.m_nonValidShowTypes, v) then
|
|
local data = Tables.itemShowingTypeTable:GetValue(v:ToInt())
|
|
table.insert(self.m_itemShowingTypeInfos, {
|
|
name = data.name,
|
|
icon = data.icon,
|
|
types = {data.type},
|
|
})
|
|
end
|
|
end
|
|
|
|
self:_RefreshShowingTypeTitle()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._OnClickShowingType = HL.Method(HL.Table, HL.Number) << function(self, typeCell, index)
|
|
if DeviceInfo.usingController and InputManagerInst.controllerNaviManager:IsTopLayer(self.depotContent.view.itemListSelectableNaviGroup) then
|
|
self.depotContent.view.itemList:ScrollToIndex(0, true)
|
|
self.m_waitInitNaviTarget = true
|
|
end
|
|
|
|
self.m_curTypeIndex = index
|
|
local showingTypes = self.m_itemShowingTypeInfos[index].types
|
|
self.depotContent:ChangeShowingType(showingTypes)
|
|
|
|
if self.m_onChangeTypeFunction ~= nil then
|
|
self.m_onChangeTypeFunction()
|
|
end
|
|
|
|
self.m_typeCells:Update(function(cell, k)
|
|
cell.decoLine.gameObject:SetActive(not (k == self.m_curTypeIndex or k == 1 or k == (self.m_curTypeIndex + 1)))
|
|
self:_RefreshTypeCellSelectedState(cell, k == index)
|
|
end)
|
|
|
|
self:_RefreshShowingTypeTitle()
|
|
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(self.view.typesNode.transform)
|
|
|
|
if DeviceInfo.usingController and self.view.typesScrollRect.enabled then
|
|
self.view.typesScrollRect:AutoScrollToRectTransform(typeCell.rectTransform)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._RefreshTypeCellSelectedState = HL.Method(HL.Any, HL.Boolean) << function(self, cell, isSelected)
|
|
if cell == nil then
|
|
return
|
|
end
|
|
|
|
cell.dimIcon.gameObject:SetActive(not isSelected)
|
|
cell.lightNode.gameObject:SetActive(isSelected)
|
|
end
|
|
|
|
|
|
|
|
Depot._RefreshShowingTypeTitle = HL.Method() << function(self, index)
|
|
local info = self.m_itemShowingTypeInfos[self.m_curTypeIndex]
|
|
if info == nil then
|
|
return
|
|
end
|
|
self.view.typeTitle.text = info.name
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._OnSortChanged = HL.Method(HL.Table, HL.Boolean) << function(self, optData, isIncremental)
|
|
if self.m_inInit then
|
|
return
|
|
end
|
|
self.depotContent.isIncremental = isIncremental
|
|
if optData.reverseKeys and not isIncremental then
|
|
self.depotContent.sortKeys = optData.reverseKeys
|
|
else
|
|
self.depotContent.sortKeys = optData.keys
|
|
end
|
|
self.depotContent:OnSortChanged()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot._OnClickItem = HL.Method(HL.String, HL.Opt(HL.Forward("ItemSlot"))) << function(self, itemId, cell)
|
|
if self.m_onClickItemAction then
|
|
self.m_onClickItemAction(itemId, cell)
|
|
return
|
|
end
|
|
|
|
if string.isEmpty(itemId) then
|
|
return
|
|
end
|
|
|
|
cell.item:Read()
|
|
if not self.m_inDestroyMode then
|
|
if DeviceInfo.usingController then
|
|
cell.item:ShowActionMenu()
|
|
return
|
|
elseif DeviceInfo.usingKeyboard and self.m_extraArgs.itemMoveTarget then
|
|
local mode = UIUtils.getMovingItemMode()
|
|
if mode then
|
|
if self.m_extraArgs.itemMoveTarget == UIConst.ITEM_MOVE_TARGET.ItemBag and not Utils.isDepotManualInOutLocked() then
|
|
GameInstance.player.inventory:FactoryDepotMoveToItemBag(Utils.getCurrentScope(), Utils.getCurrentChapterId(), itemId, mode)
|
|
return
|
|
elseif self.m_extraArgs.itemMoveTarget == UIConst.ITEM_MOVE_TARGET.FacMachine then
|
|
local dragHelper = cell.view.dragItem.luaTable
|
|
if dragHelper and cell.view.dragItem.enabled then
|
|
dragHelper = dragHelper[1]
|
|
local uiCtrl = self:GetUICtrl()
|
|
local facCacheArea = uiCtrl.view.cacheArea
|
|
local core = GameInstance.player.remoteFactory.core
|
|
if facCacheArea then
|
|
core:Message_OpMoveItemDepotToCache(Utils.getCurrentChapterId(), itemId, facCacheArea:GetDropToComponentId(dragHelper), 0, mode)
|
|
return
|
|
else
|
|
local storageContent = uiCtrl.view.storageContent
|
|
if storageContent then
|
|
core:Message_OpMoveItemDepotToGridBox(Utils.getCurrentChapterId(), itemId, storageContent.m_storage.componentId, 0, mode)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
cell.item.canPlace = true
|
|
cell.item:ShowTips()
|
|
return
|
|
end
|
|
|
|
local count = self.depotContent:GetItemCount(itemId)
|
|
if count == 0 then
|
|
if not DeviceInfo.usingController then
|
|
cell.item:ShowTips()
|
|
end
|
|
return
|
|
end
|
|
|
|
local showTips = not self.m_destroyInfo[itemId] and not DeviceInfo.usingController
|
|
self:_ClickItemInDestroyMode(itemId)
|
|
if showTips then
|
|
local posInfo = {
|
|
tipsPosType = UIConst.UI_TIPS_POS_TYPE.RightTop,
|
|
tipsPosTransform = self.view.transform,
|
|
safeArea = self.view.destroyNode.numberSelector.rectTransform,
|
|
isSideTips = true,
|
|
}
|
|
cell.item.canPlace = false
|
|
cell.item:ShowTips(posInfo, function()
|
|
if self.m_curSelectedItemIdInDesMode == itemId then
|
|
self.view.destroyNode.selectorNode:PlayOutAnimation()
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot.m_inDestroyMode = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
Depot.m_destroyInfo = HL.Field(HL.Table)
|
|
|
|
|
|
Depot.m_curSelectedItemIdInDesMode = HL.Field(HL.String) << ""
|
|
|
|
|
|
|
|
|
|
Depot._InitDestroyNode = HL.Method() << function(self)
|
|
self.view.destroyBtn.onClick:AddListener(function()
|
|
self:ToggleDestroyMode(true, false)
|
|
end)
|
|
|
|
local node = self.view.destroyNode
|
|
node.gameObject:SetActive(false)
|
|
node.backBtn.onClick:AddListener(function()
|
|
self:ToggleDestroyMode(false, false)
|
|
end)
|
|
node.confirmBtn.onClick:AddListener(function()
|
|
self:_ConfirmDestroy()
|
|
end)
|
|
self.m_destroyInfo = {}
|
|
self:ToggleDestroyMode(false, true)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot.ToggleDestroyMode = HL.Method(HL.Boolean, HL.Opt(HL.Boolean)) << function(self, active, noAnimation)
|
|
if not self.m_inited then
|
|
return
|
|
end
|
|
|
|
local node = self.view.destroyNode
|
|
local rootAni = self.view.content
|
|
if active then
|
|
if noAnimation then
|
|
rootAni:SampleToInAnimationEnd()
|
|
else
|
|
rootAni:PlayInAnimation()
|
|
end
|
|
else
|
|
if noAnimation then
|
|
rootAni:SampleToOutAnimationEnd()
|
|
else
|
|
rootAni:PlayOutAnimation()
|
|
end
|
|
end
|
|
|
|
self.depotContent.view.itemListSelectableNaviGroup.enablePartner = not active
|
|
self.depotContent.view.itemList:SetPaddingBottom(active and self.m_oriPaddingBottom + 100 or self.m_oriPaddingBottom)
|
|
|
|
self.m_typeCells:Update(function(cell, _)
|
|
if active then
|
|
cell.animation:PlayOutAnimation()
|
|
else
|
|
cell.animation:PlayInAnimation()
|
|
end
|
|
end)
|
|
|
|
self.m_inDestroyMode = active
|
|
local panelId = self:GetPanelId()
|
|
if not active then
|
|
local info = self.m_destroyInfo
|
|
self.m_destroyInfo = {}
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
if info then
|
|
for itemId, _ in pairs(info) do
|
|
self:_UpdateItemDestroySelect(itemId)
|
|
end
|
|
end
|
|
|
|
if DeviceInfo.usingController then
|
|
self:_RefreshShowingCellHoverTipsEnabledState()
|
|
|
|
Notify(MessageConst.CLOSE_CONTROLLER_SMALL_MENU, self.view.inputBindingGroupMonoTarget.groupId)
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
end
|
|
else
|
|
self.m_destroyInfo = {}
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
self.view.destroyNode.selectorNode:SampleToOutAnimationEnd()
|
|
|
|
self.view.destroyNode.confirmBtn.gameObject:SetActive(false)
|
|
|
|
if DeviceInfo.usingController then
|
|
self:_RefreshShowingCellHoverTipsEnabledState()
|
|
|
|
Notify(MessageConst.SHOW_AS_CONTROLLER_SMALL_MENU, {
|
|
panelId = panelId,
|
|
isGroup = true,
|
|
id = self.view.inputBindingGroupMonoTarget.groupId,
|
|
hintPlaceholder = self.view.destroyNode.controllerHintPlaceholder,
|
|
rectTransform = node.transform,
|
|
noHighlight = true,
|
|
})
|
|
|
|
self:SetAsNaviTarget()
|
|
end
|
|
end
|
|
|
|
|
|
local content = self.depotContent
|
|
content.view.itemList:UpdateShowingCells(function(csIndex, obj)
|
|
local cell = content.m_getCell(obj)
|
|
local info = content.m_itemInfoList[LuaIndex(csIndex)]
|
|
if info then
|
|
self:_UpdateItemBlockMask(cell, info)
|
|
end
|
|
end)
|
|
|
|
if self.m_onToggleDestroyMode then
|
|
self.m_onToggleDestroyMode(active)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._UpdateItemBlockMask = HL.Method(HL.Any, HL.Table) << function(self, cell, info)
|
|
cell.view.dragItem.disableDrag = self.m_inDestroyMode
|
|
local showMask = false
|
|
local id = info.id
|
|
local button = cell.item.view.button
|
|
if self.m_inDestroyMode then
|
|
local inventory = GameInstance.player.inventory
|
|
if not string.isEmpty(id) then
|
|
|
|
showMask = not inventory:CanDestroyItem(Utils.getCurrentScope(), id) or FactoryUtils.isItemInfiniteInFactoryDepot(id)
|
|
end
|
|
button.clickHintTextId = self.m_destroyInfo[id] and "key_hint_common_unselect" or "key_hint_common_select"
|
|
button.longPressHintTextId = nil
|
|
else
|
|
button.clickHintTextId = DeviceInfo.usingController and "key_hint_item_open_action_menu" or "key_hint_common_item_tips"
|
|
button.longPressHintTextId = "virtual_mouse_hint_drag"
|
|
cell.view.destroySelectNode.gameObject:SetActive(false)
|
|
end
|
|
InputManagerInst:SetBindingText(button.hoverConfirmBindingId, Language[button.clickHintTextId])
|
|
cell.view.blockMask.gameObject:SetActiveIfNecessary(showMask)
|
|
end
|
|
|
|
|
|
|
|
|
|
Depot._ClickItemInDestroyMode = HL.Method(HL.String) << function(self, itemId)
|
|
if self.m_destroyInfo[itemId] then
|
|
|
|
self.m_destroyInfo[itemId] = nil
|
|
self:_UpdateItemDestroySelect(itemId)
|
|
|
|
if not string.isEmpty(self.m_curSelectedItemIdInDesMode) then
|
|
self.view.destroyNode.selectorNode:PlayOutAnimation()
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
end
|
|
else
|
|
local inventory = GameInstance.player.inventory
|
|
if inventory:CanDestroyItem(Utils.getCurrentScope(), itemId) then
|
|
local count = self.depotContent:GetItemCount(itemId)
|
|
self.m_destroyInfo[itemId] = 1
|
|
self:_UpdateItemDestroySelect(itemId)
|
|
|
|
self.view.destroyNode.numberSelector:InitNumberSelector(1, 1, count, function(newCount)
|
|
self:_OnChangeItemDestroyCount(itemId, newCount)
|
|
end)
|
|
|
|
if string.isEmpty(self.m_curSelectedItemIdInDesMode) then
|
|
self.view.destroyNode.selectorNode:PlayInAnimation()
|
|
end
|
|
self.m_curSelectedItemIdInDesMode = itemId
|
|
else
|
|
if not string.isEmpty(self.m_curSelectedItemIdInDesMode) then
|
|
self.view.destroyNode.selectorNode:PlayOutAnimation()
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
end
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_ITEM_CANT_DESTROY_BECAUSE_TYPE)
|
|
end
|
|
end
|
|
|
|
self.view.destroyNode.confirmBtn.gameObject:SetActive(next(self.m_destroyInfo) ~= nil)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._UpdateItemDestroySelect = HL.Method(HL.String, HL.Opt(HL.Forward("ItemSlot"))) << function(self, itemId, cell)
|
|
local index = self.depotContent:GetItemIndex(itemId)
|
|
if not cell then
|
|
cell = self.depotContent:GetCell(index)
|
|
if not cell then
|
|
return
|
|
end
|
|
end
|
|
local totalCount = self.depotContent:GetItemCount(itemId)
|
|
local selectCount = self.m_destroyInfo[itemId]
|
|
if selectCount then
|
|
cell.view.destroySelectNode.gameObject:SetActive(true)
|
|
cell.item.view.count.text = string.format(UIConst.COLOR_STRING_FORMAT, UIConst.COUNT_RED_COLOR_STR, UIUtils.getNumString(selectCount))
|
|
cell.item.view.button.clickHintTextId = "virtual_mouse_hint_unselect"
|
|
else
|
|
cell.view.destroySelectNode.gameObject:SetActive(false)
|
|
cell.item:UpdateCount(totalCount)
|
|
cell.item.view.button.clickHintTextId = "virtual_mouse_hint_select"
|
|
end
|
|
InputManagerInst:SetBindingText(cell.item.view.button.hoverConfirmBindingId, Language[cell.item.view.button.clickHintTextId])
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._OnChangeItemDestroyCount = HL.Method(HL.String, HL.Number) << function(self, itemId, newCount)
|
|
self.m_destroyInfo[itemId] = newCount
|
|
self:_UpdateItemDestroySelect(itemId)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot._CustomOnUpdateCell = HL.Method(HL.Forward("ItemSlot"), HL.Table, HL.Number) << function(self, cell, info, luaIndex)
|
|
if DeviceInfo.usingController then
|
|
cell.item.view.button.onIsNaviTargetChanged = function(active)
|
|
if active then
|
|
self:_RefreshNaviTargetItemState(cell, info)
|
|
end
|
|
end
|
|
self:_TryDisableHoverBindingOnEmptyItem(cell, info)
|
|
|
|
|
|
if self.depotContent.view.config.IS_SET_TIPS_POS then
|
|
local tipsPosType = self.depotContent.view.config.IS_IN_SCREEN_LEFT
|
|
and UIConst.UI_TIPS_POS_TYPE.RightTop
|
|
or UIConst.UI_TIPS_POS_TYPE.LeftTop
|
|
cell.item:SetExtraInfo({
|
|
tipsPosType = tipsPosType,
|
|
tipsPosTransform = self.view.transform,
|
|
})
|
|
end
|
|
|
|
if luaIndex == 1 and self.m_waitInitNaviTarget then
|
|
cell:SetAsNaviTarget()
|
|
|
|
self:_RefreshNaviTargetItemState(cell, info)
|
|
self.m_waitInitNaviTarget = false
|
|
end
|
|
end
|
|
|
|
if self.view.config.CAN_DESTROY then
|
|
cell.item.canDestroy = true
|
|
if cell.item.actionMenuArgs then
|
|
cell.item.actionMenuArgs.extraButtons = { self.view.destroyBtn }
|
|
end
|
|
end
|
|
|
|
self:_UpdateItemBlockMask(cell, info)
|
|
if not self.m_inDestroyMode then
|
|
return
|
|
end
|
|
self:_UpdateItemDestroySelect(info.id, cell)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._TryDisableHoverBindingOnEmptyItem = HL.Method(HL.Forward("ItemSlot"), HL.Opt(HL.Any)) << function(self, cell, itemBundle)
|
|
if self.m_extraArgs.emptyItemClickable then
|
|
return
|
|
end
|
|
if itemBundle == nil or string.isEmpty(itemBundle.id) then
|
|
InputManagerInst:ToggleBinding(cell.item.view.button.hoverConfirmBindingId, false)
|
|
else
|
|
|
|
InputManagerInst:ToggleBinding(cell.item.view.button.hoverConfirmBindingId, cell.item.view.button.isNaviTarget)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
Depot._TryDisableItemHoverBindingOnDestroyMode = HL.Method(HL.Forward("ItemSlot")) << function(self, cell)
|
|
InputManagerInst:ToggleGroup(cell.item.view.button.hoverBindingGroupId, not self.m_inDestroyMode)
|
|
end
|
|
|
|
|
|
|
|
|
|
Depot._RefreshDestroySelectorNodeOnHover = HL.Method(HL.Any) << function(self, itemBundle)
|
|
local itemId = itemBundle ~= nil and itemBundle.id or ""
|
|
if self.m_destroyInfo[itemId] then
|
|
self.view.destroyNode.numberSelector:InitNumberSelector(self.m_destroyInfo[itemId], 1, itemBundle.count, function(newCount)
|
|
self:_OnChangeItemDestroyCount(itemId, newCount)
|
|
end)
|
|
|
|
if string.isEmpty(self.m_curSelectedItemIdInDesMode) then
|
|
self.view.destroyNode.selectorNode:PlayInAnimation()
|
|
end
|
|
self.m_curSelectedItemIdInDesMode = itemId
|
|
else
|
|
if not string.isEmpty(self.m_curSelectedItemIdInDesMode) then
|
|
self.view.destroyNode.selectorNode:PlayOutAnimation()
|
|
self.m_curSelectedItemIdInDesMode = ""
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
Depot._ShowTipsOnNaviTargetInDestroyMode = HL.Method(HL.Forward("ItemSlot"), HL.Opt(HL.Any)) << function(self, cell, itemBundle)
|
|
if not self.m_inDestroyMode then
|
|
return
|
|
end
|
|
|
|
local itemId = itemBundle ~= nil and itemBundle.id or ""
|
|
local showTips = not string.isEmpty(itemId)
|
|
if showTips then
|
|
if not cell.item.showingTips then
|
|
local posInfo = {
|
|
tipsPosType = UIConst.UI_TIPS_POS_TYPE.RightTop,
|
|
tipsPosTransform = self.view.transform,
|
|
safeArea = self.view.destroyNode.numberSelector.rectTransform,
|
|
isSideTips = true,
|
|
}
|
|
cell.item.canPlace = false
|
|
cell.item.canSplit = false
|
|
cell.item.canUse = false
|
|
cell.item.canClear = false
|
|
cell.item:ShowTips(posInfo)
|
|
end
|
|
else
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
Depot._ConfirmDestroy = HL.Method() << function(self)
|
|
local items = {}
|
|
for id, count in pairs(self.m_destroyInfo) do
|
|
table.insert(items, {
|
|
id = id,
|
|
count = count,
|
|
})
|
|
end
|
|
table.sort(items, Utils.genSortFunction({ "id" }, true))
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = Language.LUA_DESTROY_ITEM_CONFIRM_TEXT,
|
|
warningContent = Language.LUA_DESTROY_ITEM_CONFIRM_WARNING_TEXT,
|
|
items = items,
|
|
onConfirm = function()
|
|
GameInstance.player.inventory:DestroyInFactoryDepot(Utils.getCurrentScope(), Utils.getCurrentChapterId(), self.m_destroyInfo)
|
|
self:ToggleDestroyMode(false, false)
|
|
end,
|
|
})
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Depot._RefreshNaviTargetItemState = HL.Method(HL.Forward("ItemSlot"), HL.Table) << function(self, cell, info)
|
|
self:_TryDisableHoverBindingOnEmptyItem(cell, info)
|
|
self:_TryDisableItemHoverBindingOnDestroyMode(cell)
|
|
self:_ShowTipsOnNaviTargetInDestroyMode(cell, info)
|
|
self:_RefreshDestroySelectorNodeOnHover(info)
|
|
self:_RefreshCellHoverTipsEnabledState(cell)
|
|
end
|
|
|
|
|
|
|
|
Depot._RefreshShowingCellHoverTipsEnabledState = HL.Method() << function(self)
|
|
self.depotContent.view.itemList:UpdateShowingCells(function(csIndex, obj)
|
|
local cell = self.depotContent.m_getCell(obj)
|
|
self:_RefreshCellHoverTipsEnabledState(cell)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
Depot._RefreshCellHoverTipsEnabledState = HL.Method(HL.Forward("ItemSlot")) << function(self, cell)
|
|
cell.view.item:SetEnableHoverTips(not self.m_inDestroyMode)
|
|
end
|
|
|
|
|
|
|
|
Depot.SetAsNaviTarget = HL.Method() << function(self)
|
|
local cell = self.depotContent:GetCell(1)
|
|
if cell then
|
|
cell:SetAsNaviTarget()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
HL.Commit(Depot)
|
|
return Depot
|