1070 lines
29 KiB
Lua
1070 lines
29 KiB
Lua
local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent = HL.Class('DepotContent', UIWidgetBase)
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent.canDrag = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.canPlace = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.canSplit = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.canClear = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_showEmptyChoice = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_showHistory = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.isIncremental = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.sortKeys = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_allItemInfoList = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_allItemInfoMap = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_curDropHighlightId = HL.Field(HL.String) << ''
|
|
|
|
|
|
DepotContent.m_customItemInfoListPreProcess = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_customOnUpdateCell = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_customSetActionMenuArgs = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_customItemInfoListPostProcess = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_insertCustomListData = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_beforeFindAndHighlightForDrop = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_itemCellExtraInfo = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_itemInfoCount = HL.Field(HL.Number) << 0
|
|
|
|
|
|
DepotContent.m_itemInfoList = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_onClickItemAction = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_valuableDepotType = HL.Field(GEnums.ItemValuableDepotType)
|
|
|
|
|
|
DepotContent.m_acceptDrop = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_acceptQuickDrop = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_disableAutoHighlightForDrop = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_isFactoryDepot = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_updateStopped = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
DepotContent.m_dragSourceType = HL.Field(HL.Number) << -1
|
|
|
|
|
|
DepotContent.dropHelper = HL.Field(HL.Forward('UIDropHelper'))
|
|
|
|
|
|
DepotContent.m_getCell = HL.Field(HL.Function)
|
|
|
|
|
|
DepotContent.m_itemIndexMap = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_nonValidShowTypes = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_showingTypes = HL.Field(HL.Table)
|
|
|
|
|
|
DepotContent.m_domainId = HL.Field(HL.String) << ""
|
|
|
|
|
|
DepotContent.m_missionItemIds = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._OnFirstTimeInit = HL.Override() << function(self)
|
|
self.m_itemIndexMap = {}
|
|
|
|
self.m_getCell = UIUtils.genCachedCellFunction(self.view.itemList, function(object)
|
|
return UIWidgetManager:Wrap(object)
|
|
end)
|
|
self.view.itemList.onUpdateCell:AddListener(function(object, csIndex)
|
|
self:_OnUpdateCell(object, LuaIndex(csIndex))
|
|
end)
|
|
self.view.itemList.onCellSelectedChanged:AddListener(function(obj, csIndex, isSelected)
|
|
local cell = self.m_getCell(obj)
|
|
if cell then
|
|
cell.item:SetSelected(isSelected)
|
|
end
|
|
end)
|
|
|
|
|
|
self.view.dropMask.gameObject:SetActive(false)
|
|
self.view.dragMask.gameObject:SetActive(false)
|
|
self:RegisterMessage(MessageConst.ON_START_UI_DRAG, function(dragHelper)
|
|
self:OnStartUiDrag(dragHelper)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_END_UI_DRAG, function(dragHelper)
|
|
self:OnEndUiDrag(dragHelper)
|
|
end)
|
|
|
|
|
|
self:RegisterMessage(MessageConst.ON_FACTORY_DEPOT_CHANGED, function(args)
|
|
if not self.m_isFactoryDepot then
|
|
return
|
|
end
|
|
local depotChange = unpack(args)
|
|
self:_OnDepotChanged(depotChange)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_VALUABLE_DEPOT_CHANGED, function(args)
|
|
if self.m_isFactoryDepot then
|
|
return
|
|
end
|
|
local valuableDepotType, depotChange = unpack(args)
|
|
if valuableDepotType == self.m_valuableDepotType then
|
|
self:_OnDepotChanged(depotChange)
|
|
end
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_SYNC_INVENTORY, function()
|
|
self:_OnDepotChanged(nil, true)
|
|
end)
|
|
|
|
self:RegisterMessage(MessageConst.ON_ITEM_BAG_MOVE_TO_FACTORY_DEPOT, function(args)
|
|
self:_PlayDropAnimation(args)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_FAC_MOVE_ITEM_CACHE_TO_DEPOT, function(args)
|
|
self:_PlayDropAnimation(args)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_FAC_MOVE_ITEM_GRID_BOX_TO_DEPOT, function(args)
|
|
self:_PlayDropAnimation(args)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
DepotContent._GetDepot = HL.Method().Return(CS.Beyond.Gameplay.InventorySystem.ItemDepot) << function(self)
|
|
if self.m_isFactoryDepot then
|
|
local factoryDepot = GameInstance.player.inventory.factoryDepot
|
|
local depotInChapter = factoryDepot:GetOrFallback(Utils.getCurrentScope())
|
|
local actualDepot = depotInChapter[Utils.getCurrentChapterId()]
|
|
if self.m_domainId ~= "" then
|
|
actualDepot = depotInChapter[ScopeUtil.ChapterIdStr2Int(self.m_domainId)]
|
|
end
|
|
return actualDepot
|
|
else
|
|
return GameInstance.player.inventory.valuableDepots[self.m_valuableDepotType]:GetOrFallback(Utils.getCurrentScope())
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent.InitDepotContent = HL.Method(GEnums.ItemValuableDepotType, HL.Opt(HL.Function, HL.Table)) <<
|
|
function(self, valuableDepotType, onClickItemAction, otherArgs)
|
|
self.m_valuableDepotType = valuableDepotType
|
|
self.m_isFactoryDepot = not valuableDepotType or valuableDepotType == GEnums.ItemValuableDepotType.Factory
|
|
if otherArgs.domainId ~= nil then
|
|
self.m_domainId = otherArgs.domainId
|
|
end
|
|
|
|
self:_FirstTimeInit()
|
|
|
|
self.m_readItemIds = {}
|
|
|
|
self.view.dropMask.onDropEvent:RemoveAllListeners()
|
|
self.view.dropMask.onToggleHighlight:RemoveAllListeners()
|
|
if self.m_isFactoryDepot then
|
|
self.m_dragSourceType = UIConst.UI_DRAG_DROP_SOURCE_TYPE.FactoryDepot
|
|
if Utils.isDepotManualInOutLocked() then
|
|
self.m_acceptDrop = false
|
|
self.m_acceptQuickDrop = false
|
|
self.canDrag = false
|
|
else
|
|
self.dropHelper = UIUtils.initUIDropHelper(self.view.dropMask, {
|
|
acceptTypes = UIConst.FACTORY_DEPOT_DROP_ACCEPT_INFO,
|
|
onDropItem = function(eventData, dragHelper)
|
|
self:OnDropItem(dragHelper)
|
|
end,
|
|
onToggleHighlight = function(active)
|
|
if active then
|
|
self:_FindAndHighlightForDrop()
|
|
else
|
|
self:_CancelDropHighlight()
|
|
end
|
|
end,
|
|
isDropArea = true,
|
|
quickDropCheckGameObject = self.gameObject,
|
|
})
|
|
self.m_acceptDrop = true
|
|
self.m_acceptQuickDrop = true
|
|
self.canDrag = not otherArgs.disableDrag
|
|
end
|
|
else
|
|
self.m_dragSourceType = nil
|
|
self.m_acceptDrop = false
|
|
self.m_acceptQuickDrop = false
|
|
self.canDrag = false
|
|
end
|
|
|
|
self.m_onClickItemAction = onClickItemAction
|
|
|
|
otherArgs = otherArgs or {}
|
|
self.m_showingTypes = otherArgs.showingTypes
|
|
self.m_customOnUpdateCell = otherArgs.customOnUpdateCell
|
|
self.m_customSetActionMenuArgs = otherArgs.customSetActionMenuArgs
|
|
self.m_customItemInfoListPreProcess = otherArgs.customItemInfoListPreProcess
|
|
self.m_customItemInfoListPostProcess = otherArgs.customItemInfoListPostProcess
|
|
self.m_insertCustomListData = otherArgs.insertCustomListData
|
|
self.m_beforeFindAndHighlightForDrop = otherArgs.beforeFindAndHighlightForDrop
|
|
self.m_disableAutoHighlightForDrop = otherArgs.disableAutoHighlightForDrop == true
|
|
self.m_showHistory = otherArgs.showHistory == true
|
|
if self.m_insertCustomListData and self.m_showHistory then
|
|
logger.error("showHistory 会导致 insertCustomListData æ— æ•ˆ", depotType)
|
|
end
|
|
self.m_showEmptyChoice = otherArgs.showEmptyChoice == true
|
|
self.canPlace = otherArgs.canPlace == true
|
|
self.canClear = otherArgs.canClear == true
|
|
self.canSplit = false
|
|
self.m_nonValidShowTypes = otherArgs.nonValidShowTypes
|
|
self.m_itemCellExtraInfo = otherArgs.itemCellExtraInfo
|
|
self.m_missionItemIds = otherArgs.missionItemIds or {}
|
|
|
|
self.isIncremental = otherArgs.isIncremental == nil and true or otherArgs.isIncremental
|
|
if otherArgs.sortKeys then
|
|
self.sortKeys = otherArgs.sortKeys
|
|
else
|
|
self.sortKeys = self.isIncremental and UIConst.FAC_DEPOT_SORT_OPTIONS[1].keys or UIConst.FAC_DEPOT_SORT_OPTIONS[1].reverseKeys
|
|
end
|
|
|
|
self.m_updateStopped = false
|
|
self:RefreshAll()
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.StopUpdate = HL.Method(HL.Boolean) << function(self, cacheAllCell)
|
|
self.m_updateStopped = true
|
|
if cacheAllCell then
|
|
|
|
|
|
|
|
self.view.itemList:UpdateCount(0)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
DepotContent.StartUpdate = HL.Method() << function(self)
|
|
if not self.m_updateStopped then
|
|
return
|
|
end
|
|
self.m_updateStopped = false
|
|
self:RefreshAll()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._CreateItemInfo = HL.Method(HL.String, HL.Opt(HL.Number, HL.Number, HL.Boolean)).Return(HL.Table) <<
|
|
function(self, id, count, instId, isInfinite)
|
|
local data = Tables.itemTable:GetValue(id)
|
|
local info = {
|
|
id = id,
|
|
instId = instId or 0,
|
|
isInst = instId ~= nil,
|
|
count = isInfinite and data.maxBackpackStackCount or count,
|
|
maxStackCount = data.maxBackpackStackCount,
|
|
data = data,
|
|
showingType = data.showingType,
|
|
rarity = data.rarity,
|
|
sortId1 = data.sortId1,
|
|
sortId1Neg = -data.sortId1,
|
|
sortId2 = data.sortId2,
|
|
isInfinite = isInfinite,
|
|
isMissionItem = self.m_missionItemIds[id] == true
|
|
}
|
|
info.missionSortId = info.isMissionItem and 0 or 1
|
|
info.missionReverseSortId = -info.missionSortId
|
|
return info
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._IsInfiniteItemInDepot = HL.Method(HL.String, HL.Any).Return(HL.Boolean) << function(self, itemId, depot)
|
|
if not self.m_isFactoryDepot then
|
|
return false
|
|
end
|
|
|
|
if depot == nil then
|
|
return false
|
|
end
|
|
|
|
local success, isInfinite = depot.infiniteItemIds:TryGetValue(itemId)
|
|
if not success then
|
|
return false
|
|
end
|
|
|
|
return isInfinite
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.ToggleAcceptDrop = HL.Method(HL.Boolean) << function(self, active)
|
|
self.m_acceptDrop = active
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.ToggleQuickAcceptDrop = HL.Method(HL.Boolean) << function(self, active)
|
|
self.m_acceptQuickDrop = active
|
|
end
|
|
|
|
|
|
DepotContent.m_curDraggingDragHelper = HL.Field(HL.Forward('UIDragHelper'))
|
|
|
|
|
|
|
|
|
|
DepotContent.OnStartUiDrag = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
|
|
if self.m_updateStopped then
|
|
return
|
|
end
|
|
if not self.m_isFactoryDepot then
|
|
return
|
|
end
|
|
if dragHelper.source == self.m_dragSourceType then
|
|
|
|
if self.view.itemListAutoScrollArea then
|
|
self.view.itemListAutoScrollArea.gameObject:SetActive(true)
|
|
end
|
|
return
|
|
end
|
|
|
|
if self.m_acceptDrop and self.m_acceptQuickDrop and self.dropHelper:Accept(dragHelper) then
|
|
self.m_curDraggingDragHelper = dragHelper
|
|
self.view.quickDropButton.onClick:RemoveAllListeners()
|
|
self.view.quickDropButton.onClick:AddListener(function()
|
|
self:OnDropItem(dragHelper)
|
|
end)
|
|
self.view.dropMask.gameObject:SetActive(true)
|
|
self.view.dropMask:ToggleHighlight(false)
|
|
self:_ShowMobileDragHelper(dragHelper)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.OnEndUiDrag = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
|
|
self.view.dragMask.gameObject:SetActive(false)
|
|
|
|
if self.m_updateStopped then
|
|
return
|
|
end
|
|
if not self.m_isFactoryDepot then
|
|
return
|
|
end
|
|
if dragHelper.source == self.m_dragSourceType then
|
|
if self.view.itemListAutoScrollArea then
|
|
self.view.itemListAutoScrollArea.gameObject:SetActive(false)
|
|
end
|
|
return
|
|
end
|
|
if self.m_acceptDrop and self.m_acceptQuickDrop and self.dropHelper:Accept(dragHelper) then
|
|
self.m_curDraggingDragHelper = nil
|
|
self.view.dropMask.gameObject:SetActive(false)
|
|
self:_CancelDropHighlight()
|
|
Notify(MessageConst.HIDE_ITEM_DRAG_HELPER)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent.RefreshAll = HL.Method(HL.Opt(HL.Boolean)) << function(self, skipGraduallyShow)
|
|
local allItemInfoList = {}
|
|
|
|
local depot = self:_GetDepot()
|
|
local processItem = function(id, count, instId, isInfinite)
|
|
local valid = true
|
|
if self.m_nonValidShowTypes then
|
|
local data = Tables.itemTable:GetValue(id)
|
|
valid = not lume.find(self.m_nonValidShowTypes, data.showingType)
|
|
end
|
|
if valid then
|
|
local info = self:_CreateItemInfo(id, count, instId, isInfinite)
|
|
table.insert(allItemInfoList, info)
|
|
end
|
|
end
|
|
for id, bundle in pairs(depot.normalItems) do
|
|
processItem(id, bundle.count, nil, self:_IsInfiniteItemInDepot(id, depot))
|
|
end
|
|
for instId, bundle in pairs(depot.instItems) do
|
|
processItem(bundle.id, bundle.count, instId)
|
|
end
|
|
if self.m_customItemInfoListPreProcess ~= nil then
|
|
self:m_customItemInfoListPreProcess(allItemInfoList, depot)
|
|
end
|
|
if self.m_showHistory then
|
|
for _, id in pairs(GameInstance.player.inventory.gotItems) do
|
|
local succ, itemData = Tables.itemTable:TryGetValue(id)
|
|
if succ then
|
|
local facFound, facItemData = Tables.factoryItemTable:TryGetValue(id)
|
|
local valid = true
|
|
valid = GameInstance.player.inventory:IsPlaceInBag(itemData.type)
|
|
if facFound then
|
|
valid = valid and facItemData ~= nil
|
|
end
|
|
if valid and self.m_nonValidShowTypes then
|
|
valid = not lume.find(self.m_nonValidShowTypes, itemData.showingType)
|
|
end
|
|
if valid then
|
|
if not depot.normalItems:ContainsKey(id) then
|
|
local info = self:_CreateItemInfo(id, 0)
|
|
table.insert(allItemInfoList, info)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
elseif self.m_insertCustomListData then
|
|
self.m_insertCustomListData(allItemInfoList, depot)
|
|
end
|
|
|
|
if self.m_customItemInfoListPostProcess ~= nil then
|
|
allItemInfoList = self.m_customItemInfoListPostProcess(allItemInfoList)
|
|
end
|
|
self.m_allItemInfoList = allItemInfoList
|
|
|
|
local allItemInfoMap = {}
|
|
for _, v in ipairs(allItemInfoList) do
|
|
allItemInfoMap[v.id] = v
|
|
end
|
|
self.m_allItemInfoMap = allItemInfoMap
|
|
|
|
self:ChangeShowingType(self.m_showingTypes, skipGraduallyShow)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent.ChangeShowingType = HL.Method(HL.Table, HL.Opt(HL.Boolean)) <<
|
|
function(self, showingTypes, skipGraduallyShow)
|
|
local itemInfoList = {}
|
|
self.m_showingTypes = showingTypes
|
|
for _, info in ipairs(self.m_allItemInfoList) do
|
|
if not showingTypes or lume.find(showingTypes, info.showingType) then
|
|
|
|
table.insert(itemInfoList, info)
|
|
end
|
|
end
|
|
|
|
self.m_itemInfoList = itemInfoList
|
|
self:OnSortChanged(skipGraduallyShow)
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.OnSortChanged = HL.Method(HL.Opt(HL.Boolean)) << function(self, skipGraduallyShow)
|
|
local list = self.m_itemInfoList
|
|
if list[1] and list[1].isEmptyChoice then
|
|
table.remove(list, 1)
|
|
end
|
|
|
|
table.sort(list, Utils.genSortFunction(self.sortKeys, self.isIncremental))
|
|
|
|
if self.m_showEmptyChoice or (DeviceInfo.usingController and next(list) == nil and self.config.SHOW_EMPTY_CHOICE_ON_CONTROLLER) then
|
|
table.insert(list, 1, { id = "", count = 0, extraOrder = 1, isEmptyChoice = true, })
|
|
end
|
|
|
|
self.m_itemIndexMap = {}
|
|
for index, info in ipairs(list) do
|
|
if info.instId and info.instId > 0 then
|
|
self.m_itemIndexMap[info.instId] = index
|
|
else
|
|
self.m_itemIndexMap[info.id] = index
|
|
end
|
|
end
|
|
|
|
self.m_itemInfoCount = #list
|
|
|
|
if string.isEmpty(self.m_curDropHighlightId) then
|
|
self.view.itemList:UpdateCount(self.m_itemInfoCount, false, false, false, skipGraduallyShow == true)
|
|
else
|
|
local index
|
|
for k, v in ipairs(self.m_itemInfoList) do
|
|
if v.id == self.m_curDropHighlightId then
|
|
index = k
|
|
break
|
|
end
|
|
end
|
|
if index then
|
|
self.view.itemList:UpdateCount(self.m_itemInfoCount, false, false, false, true)
|
|
else
|
|
self.view.itemList:UpdateCount(self.m_itemInfoCount + 1, false, false, false, true)
|
|
end
|
|
end
|
|
|
|
self.view.emptyTarget.gameObject:SetActive(self.m_itemInfoCount == 0)
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.GetItemIndex = HL.Method(HL.String).Return(HL.Opt(HL.Number)) << function(self, itemId)
|
|
return self.m_itemIndexMap[itemId]
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.GetItemCount = HL.Method(HL.String).Return(HL.Number) << function(self, itemId)
|
|
local index = self.m_itemIndexMap[itemId]
|
|
local info = self.m_itemInfoList[index]
|
|
return info.count
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.GetCell = HL.Method(HL.Any).Return(HL.Opt(HL.Forward("ItemSlot"))) << function(self, objOrIndex)
|
|
return self.m_getCell(objOrIndex)
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent.CheckAndNaviToTargetCell = HL.Method(HL.Function) << function(self, checkFunc)
|
|
local findTag = false
|
|
for index, itemBundle in ipairs(self.m_itemInfoList) do
|
|
if checkFunc(itemBundle.id) then
|
|
self.view.itemList:ScrollToIndex(CSIndex(index), true)
|
|
local slot = self.m_getCell(index)
|
|
slot:SetAsNaviTarget()
|
|
findTag = true
|
|
break
|
|
end
|
|
end
|
|
if not findTag then
|
|
self.view.itemList:ScrollToIndex(CSIndex(1), true)
|
|
local slot = self.m_getCell(1)
|
|
slot:SetAsNaviTarget()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
DepotContent.GetCurNaviTargetSlot = HL.Method().Return(HL.Number, HL.Opt(HL.Forward("ItemSlot"))) << function(self)
|
|
local count = self.view.itemList.count
|
|
for i = 1, count do
|
|
local object = self.view.itemList:Get(CSIndex(i))
|
|
if object then
|
|
local cell = self.m_getCell(object)
|
|
if cell.item.view.button.isNaviTarget then
|
|
return CSIndex(i), cell
|
|
end
|
|
end
|
|
end
|
|
return -1
|
|
end
|
|
|
|
|
|
|
|
DepotContent.GetAllItemInfo = HL.Method().Return(HL.Opt(HL.Table)) << function(self)
|
|
if self.m_allItemInfoList ~= nil then
|
|
return self.m_allItemInfoList
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._OnUpdateCell = HL.Method(GameObject, HL.Number) << function(self, object, luaIndex)
|
|
local cell = self.m_getCell(object)
|
|
|
|
if luaIndex > self.m_itemInfoCount then
|
|
|
|
cell:InitItemSlot()
|
|
cell.item:SetSelected(false)
|
|
cell:SetDropHighlighted(true)
|
|
cell.item.view.missionMark.gameObject:SetActive(false)
|
|
return
|
|
end
|
|
|
|
local info = self.m_itemInfoList[luaIndex]
|
|
if not string.isEmpty(info.id) and info.count <= 0 and cell.view.dragItem.inDragging then
|
|
|
|
|
|
cell.view.dragItem:OnEndDrag()
|
|
end
|
|
cell:InitItemSlot(info, function()
|
|
self:_OnClickItem(luaIndex)
|
|
end, nil, true)
|
|
cell.item.canPlace = self.canPlace
|
|
cell.item.canSplit = self.canSplit
|
|
cell.item.canClear = self.canClear
|
|
cell.item.fromDepot = true
|
|
cell.item.canUse = false
|
|
cell.supportQuickMovingHalfItem = true
|
|
|
|
local isDropHighlight = (not string.isEmpty(self.m_curDropHighlightId)) and (self.m_curDropHighlightId == info.id)
|
|
cell.item:SetSelected(cell.item.showingTips or cell.item.showingActionMenu)
|
|
cell:SetDropHighlighted(isDropHighlight)
|
|
|
|
if self.m_itemCellExtraInfo then
|
|
cell.item:SetExtraInfo(self.m_itemCellExtraInfo)
|
|
end
|
|
|
|
local isEmpty = string.isEmpty(info.id)
|
|
if isEmpty or not self.view.config.USE_ITEM_ID_NAME then
|
|
cell.gameObject.name = "Item__" .. CSIndex(luaIndex)
|
|
else
|
|
cell.gameObject.name = "Item_" .. info.id
|
|
cell.item.view.button.clickHintTextId = "virtual_mouse_hint_item_tips"
|
|
end
|
|
cell.item:ShowPickUpLogo(true)
|
|
cell.item:UpdateRedDot()
|
|
if cell.item.redDot.curIsActive then
|
|
self.m_readItemIds[info.id] = true
|
|
end
|
|
|
|
cell.item.view.missionMark.gameObject:SetActive(info.isMissionItem)
|
|
cell.item.redDot.gameObject:SetActive(not info.isMissionItem)
|
|
|
|
cell.item.actionMenuArgs = {
|
|
source = UIConst.UI_DRAG_DROP_SOURCE_TYPE.FactoryDepot,
|
|
moveCount = info.isInfinite and info.maxStackCount or math.min(info.count or 0, info.maxStackCount or 0),
|
|
}
|
|
|
|
cell.view.dropItem.enabled = false
|
|
if not isEmpty and self.canDrag and info.count > 0 then
|
|
cell.view.dragItem.enabled = true
|
|
local data = Tables.itemTable:GetValue(info.id)
|
|
local dragHelper = UIUtils.initUIDragHelper(cell.view.dragItem, {
|
|
source = self.m_dragSourceType,
|
|
type = data.type,
|
|
|
|
itemId = info.id,
|
|
instId = info.instId,
|
|
count = info.isInfinite and info.maxStackCount or math.min(info.count or 0, info.maxStackCount or 0),
|
|
|
|
onBeginDrag = function()
|
|
self.view.itemList:SetCellCanCache(CSIndex(luaIndex), false)
|
|
self.view.dragMask.gameObject:SetActive(true)
|
|
cell.item:Read()
|
|
end,
|
|
onEndDrag = function()
|
|
self.view.itemList:SetCellCanCache(CSIndex(luaIndex), true)
|
|
self.view.dragMask.gameObject:SetActive(false)
|
|
end,
|
|
})
|
|
cell:InitPressDrag()
|
|
|
|
cell.item.actionMenuArgs.dragHelper = dragHelper
|
|
|
|
if self.m_customSetActionMenuArgs ~= nil then
|
|
self.m_customSetActionMenuArgs(cell.item.actionMenuArgs)
|
|
end
|
|
else
|
|
cell.view.dragItem.enabled = false
|
|
cell.item.view.button.longPressHintTextId = ""
|
|
end
|
|
|
|
if self.m_customOnUpdateCell then
|
|
self.m_customOnUpdateCell(cell, info, luaIndex)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
DepotContent._OnClickItem = HL.Method(HL.Number) << function(self, luaIndex)
|
|
local item = self.m_itemInfoList[luaIndex]
|
|
local cell = self.m_getCell(luaIndex)
|
|
|
|
if self.m_onClickItemAction then
|
|
self.m_onClickItemAction(item.id, cell)
|
|
elseif not string.isEmpty(item.id) then
|
|
cell.item:ShowTips()
|
|
cell.item:Read()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent.OnDropItem = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
|
|
if Utils.isDepotManualInOutLocked() then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_DEPOT_MANUAL_IN_OUT_LOCKED)
|
|
return
|
|
end
|
|
|
|
local source = dragHelper.source
|
|
local dragInfo = dragHelper.info
|
|
local core = GameInstance.player.remoteFactory.core
|
|
local mode = dragHelper.isHalfDragging and CS.Proto.ITEM_MOVE_MODE.HalfGrid or CS.Proto.ITEM_MOVE_MODE.Normal
|
|
if source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Storage then
|
|
|
|
core:Message_OpMoveItemGridBoxToDepot(Utils.getCurrentChapterId(), dragInfo.storage.componentId, dragInfo.csIndex, mode)
|
|
elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Repository then
|
|
|
|
core:Message_OpMoveItemCacheToDepot(Utils.getCurrentChapterId(), dragInfo.repository.componentId, dragInfo.cacheGridIndex, mode)
|
|
elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.ItemBag then
|
|
|
|
GameInstance.player.inventory:ItemBagMoveToFactoryDepot(Utils.getCurrentScope(), Utils.getCurrentChapterId(), dragInfo.csIndex, mode)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._OnDepotChanged = HL.Method(HL.Opt(CS.Beyond.Gameplay.InventorySystem.DepotCachedChange, HL.Boolean)) <<
|
|
function(self, depotChange, refreshAll)
|
|
if self.m_updateStopped then
|
|
return
|
|
end
|
|
|
|
if refreshAll or depotChange.instIds.Count > 0 then
|
|
|
|
self:RefreshAll(true)
|
|
return
|
|
end
|
|
|
|
if not self.m_isFactoryDepot then
|
|
if depotChange.hasAdd or depotChange.hasRemove then
|
|
|
|
self:RefreshAll(true)
|
|
return
|
|
end
|
|
else
|
|
|
|
|
|
for _, itemId in pairs(depotChange.normalItemIds) do
|
|
if not self.m_itemIndexMap[itemId] then
|
|
|
|
self:RefreshAll(true)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
local depot = self:_GetDepot()
|
|
for _, itemId in pairs(depotChange.normalItemIds) do
|
|
local index = self.m_itemIndexMap[itemId]
|
|
self:_RefreshSingleItemCount(index, depot:GetCount(itemId))
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._RefreshSingleItemCount = HL.Method(HL.Number, HL.Number) << function(self, slotIndex, count)
|
|
|
|
local info = self.m_itemInfoList[slotIndex]
|
|
if info.instId == 0 then
|
|
if info.count == count then
|
|
return
|
|
end
|
|
info.count = count
|
|
end
|
|
|
|
local obj = self.view.itemList:Get(CSIndex(slotIndex))
|
|
if obj then
|
|
self:_OnUpdateCell(obj, slotIndex)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
DepotContent._FindAndHighlightForDrop = HL.Method() << function(self)
|
|
if self.m_disableAutoHighlightForDrop or not self.m_curDraggingDragHelper then
|
|
return
|
|
end
|
|
|
|
local id = self.m_curDraggingDragHelper:GetId()
|
|
self.m_curDropHighlightId = id
|
|
|
|
if self.m_beforeFindAndHighlightForDrop then
|
|
self.m_beforeFindAndHighlightForDrop(id)
|
|
end
|
|
|
|
local index = self.m_itemIndexMap[id]
|
|
if index then
|
|
local object = self.view.itemList:Get(CSIndex(index))
|
|
if object then
|
|
local cell = self.m_getCell(object)
|
|
cell:SetDropHighlighted(true)
|
|
end
|
|
else
|
|
index = self.m_itemInfoCount + 1
|
|
self.view.itemList:UpdateCount(index, false, false, true, true)
|
|
end
|
|
self.view.itemList:ScrollToIndex(CSIndex(index))
|
|
end
|
|
|
|
|
|
|
|
DepotContent._CancelDropHighlight = HL.Method() << function(self)
|
|
if self.m_disableAutoHighlightForDrop then
|
|
return
|
|
end
|
|
|
|
local id = self.m_curDropHighlightId
|
|
self.m_curDropHighlightId = ''
|
|
|
|
local index = self.m_itemIndexMap[id]
|
|
local needRefresh = false
|
|
if not index then
|
|
needRefresh = true
|
|
index = self.m_itemInfoCount + 1
|
|
end
|
|
local object = self.view.itemList:Get(CSIndex(index))
|
|
if object then
|
|
local cell = self.m_getCell(object)
|
|
cell.item:SetSelected(false)
|
|
cell:SetDropHighlighted(false)
|
|
end
|
|
if needRefresh then
|
|
self.view.itemList:UpdateCount(self.m_itemInfoCount, false, false, true, true)
|
|
end
|
|
end
|
|
|
|
|
|
DepotContent.m_readItemIds = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
DepotContent.ReadCurShowingItems = HL.Method() << function(self)
|
|
if not self.m_readItemIds or not next(self.m_readItemIds) then
|
|
return
|
|
end
|
|
local ids = {}
|
|
for k, _ in pairs(self.m_readItemIds) do
|
|
table.insert(ids, k)
|
|
end
|
|
self.m_readItemIds = {}
|
|
GameInstance.player.inventory:ReadNewItems(ids)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._ShowMobileDragHelper = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
|
|
if not DeviceInfo.usingTouch then
|
|
return
|
|
end
|
|
if not self.view.gameObject.activeInHierarchy then
|
|
return
|
|
end
|
|
if Utils.isDepotManualInOutLocked() then
|
|
return
|
|
end
|
|
|
|
local dragInfo = dragHelper.info
|
|
|
|
if Tables.liquidTable:ContainsKey(dragHelper:GetId()) then
|
|
return
|
|
end
|
|
|
|
local moveAct, canBatch
|
|
if dragHelper.source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.ItemBag then
|
|
moveAct = function(mode)
|
|
GameInstance.player.inventory:ItemBagMoveToFactoryDepot(Utils.getCurrentScope(), Utils.getCurrentChapterId(), dragInfo.csIndex, mode)
|
|
dragHelper.uiDragItem:OnEndDrag(nil)
|
|
end
|
|
canBatch = true
|
|
elseif dragHelper.source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Repository then
|
|
moveAct = function(mode)
|
|
GameInstance.player.remoteFactory.core:Message_OpMoveItemCacheToDepot(Utils.getCurrentChapterId(), dragInfo.repository.componentId, dragInfo.cacheGridIndex, mode)
|
|
dragHelper.uiDragItem:OnEndDrag(nil)
|
|
end
|
|
elseif dragHelper.source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Storage then
|
|
moveAct = function(mode)
|
|
GameInstance.player.remoteFactory.core:Message_OpMoveItemGridBoxToDepot(Utils.getCurrentChapterId(), dragInfo.storage.componentId, dragInfo.csIndex, mode)
|
|
dragHelper.uiDragItem:OnEndDrag(nil)
|
|
end
|
|
canBatch = true
|
|
else
|
|
return
|
|
end
|
|
|
|
local args = {
|
|
isLeft = self.view.config.IS_IN_SCREEN_LEFT,
|
|
actions = {
|
|
{
|
|
text = Language.LUA_MOBILE_ITEM_DRAG_GRID_TO_DEPOT,
|
|
icon = "icon_common_move_to_bag",
|
|
action = function()
|
|
moveAct(CS.Proto.ITEM_MOVE_MODE.Grid)
|
|
end
|
|
},
|
|
{
|
|
text = Language.LUA_MOBILE_ITEM_DRAG_HALF,
|
|
icon = "icon_common_move_half",
|
|
action = function()
|
|
moveAct(CS.Proto.ITEM_MOVE_MODE.HalfGrid)
|
|
end
|
|
},
|
|
}
|
|
}
|
|
|
|
if canBatch then
|
|
table.insert(args.actions, 2, {
|
|
text = Language.LUA_MOBILE_ITEM_DRAG_ALL,
|
|
icon = "icon_common_move_all",
|
|
action = function()
|
|
moveAct(CS.Proto.ITEM_MOVE_MODE.BatchItemId)
|
|
end
|
|
})
|
|
end
|
|
Notify(MessageConst.SHOW_ITEM_DRAG_HELPER, args)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
DepotContent._PlayDropAnimation = HL.Method(HL.Table) << function(self, args)
|
|
if self.m_updateStopped then
|
|
return
|
|
end
|
|
local itemId = args[1]
|
|
local index = self.m_itemIndexMap[itemId]
|
|
if not index then
|
|
|
|
|
|
self:RefreshAll(true)
|
|
index = self.m_itemIndexMap[itemId]
|
|
end
|
|
|
|
local cell = self.m_getCell(index)
|
|
if cell then
|
|
cell:PlayDropAnimation()
|
|
end
|
|
UIUtils.playItemDropAudio(itemId)
|
|
end
|
|
|
|
|
|
|
|
HL.Commit(DepotContent)
|
|
return DepotContent
|