771 lines
21 KiB
Lua
771 lines
21 KiB
Lua
local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt = HL.Class('FacCacheBelt', UIWidgetBase)
|
|
|
|
local MAX_VIEW_PORT_COUNT = 6
|
|
local LUT_COLOR_IN_START_ID = 0
|
|
local LUT_COLOR_OUT_START_ID = 3
|
|
local MESSAGE_ITEM_INDEX = 0
|
|
|
|
|
|
FacCacheBelt.m_buildingNodeId = HL.Field(HL.Number) << -1
|
|
|
|
|
|
FacCacheBelt.m_buildingNode = HL.Field(HL.Any)
|
|
|
|
|
|
FacCacheBelt.m_buildingId = HL.Field(HL.String) << ""
|
|
|
|
|
|
FacCacheBelt.m_inBeltList = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
FacCacheBelt.m_outBeltList = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
FacCacheBelt.m_inBindingBeltDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_outBindingBeltDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_inBeltInfoList = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_outBeltInfoList = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_cachedSprite = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_isInSingleState = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
FacCacheBelt.m_onInitializeFinished = HL.Field(HL.Function)
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._OnFirstTimeInit = HL.Override() << function(self)
|
|
self.m_inBeltList = UIUtils.genCellCache(self.view.inBeltCell)
|
|
self.m_outBeltList = UIUtils.genCellCache(self.view.outBeltCell)
|
|
|
|
self:RegisterMessage(MessageConst.ON_CONVEYOR_CHANGE, function(args)
|
|
local bindingNodeId, componentId, isIn, itemList = unpack(args)
|
|
local itemId = (itemList ~= nil and itemList.Count > 0) and itemList[MESSAGE_ITEM_INDEX] or ""
|
|
self:_RefreshBeltCellConveyorAnimation(isIn, bindingNodeId, componentId, itemId)
|
|
end)
|
|
|
|
self:RegisterMessage(MessageConst.ON_PORT_BLOCK_STATE_CHANGE, function(args)
|
|
local buildingNodeId = unpack(args)
|
|
self:_RefreshBeltCellBlockState(buildingNodeId)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
FacCacheBelt._OnDestroy = HL.Override() << function(self)
|
|
self:_UnRegisterInterested()
|
|
self.m_cachedSprite = nil
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt.InitFacCacheBelt = HL.Method(HL.Userdata, HL.Table) << function(self, buildingInfo, customInfo)
|
|
self:_FirstTimeInit()
|
|
|
|
if buildingInfo == nil then
|
|
return
|
|
end
|
|
self.m_buildingNodeId = buildingInfo.nodeId
|
|
self.m_buildingNode = buildingInfo.nodeHandler
|
|
self.m_buildingId = buildingInfo.buildingId
|
|
self.m_cachedSprite = {}
|
|
self.m_inBindingBeltDataMap = {}
|
|
self.m_outBindingBeltDataMap = {}
|
|
self:_ParseCustomInfo(customInfo)
|
|
|
|
self:_RefreshCacheBelt(true)
|
|
if self.m_onInitializeFinished ~= nil then
|
|
self.m_onInitializeFinished()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshCacheBelt = HL.Method(HL.Opt(HL.Boolean)) << function(self, needDelayRefresh)
|
|
self:_GetBeltInfoList()
|
|
|
|
if needDelayRefresh then
|
|
self:_StartCoroutine(function()
|
|
coroutine.step()
|
|
end)
|
|
end
|
|
self:_InitInBeltList()
|
|
self:_InitOutBeltList()
|
|
self:_RefreshBeltShownState()
|
|
self:_RegisterInterested()
|
|
end
|
|
|
|
|
|
|
|
FacCacheBelt._GetBeltInfoList = HL.Method() << function(self)
|
|
self.m_inBeltInfoList, self.m_outBeltInfoList = FactoryUtils.getBuildingPortState(self.m_buildingNodeId, false)
|
|
|
|
|
|
local inIndexList, outIndexList = self.m_inIndexList, self.m_outIndexList
|
|
if #inIndexList > 0 or #outIndexList > 0 then
|
|
self.m_inBeltInfoList = self:_FilterBeltInfoList(self.m_inBeltInfoList, inIndexList)
|
|
self.m_outBeltInfoList = self:_FilterBeltInfoList(self.m_outBeltInfoList, outIndexList)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._GetItemSprite = HL.Method(HL.String).Return(HL.Userdata) << function(self, itemId)
|
|
local itemSprite = self.m_cachedSprite[itemId]
|
|
if itemSprite == nil then
|
|
local success, itemData = Tables.itemTable:TryGetValue(itemId)
|
|
if success then
|
|
itemSprite = self:LoadSprite(UIConst.UI_SPRITE_ITEM, itemData.iconId)
|
|
self.m_cachedSprite[itemId] = itemSprite
|
|
end
|
|
end
|
|
return itemSprite
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._GetIsBeltBlocked = HL.Method(HL.Number, HL.Boolean).Return(HL.Boolean) << function(self, nodeId, isIn)
|
|
local infoList = isIn and self.m_inBeltInfoList or self.m_outBeltInfoList
|
|
if infoList == nil then
|
|
return false
|
|
end
|
|
for _, info in pairs(infoList) do
|
|
if info ~= nil and info.touchNodeId == nodeId then
|
|
return info.isBlock
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._GetBeltHeightAndSpaceByPortCount = HL.Method(HL.Number).Return(HL.Number, HL.Number) << function(self, portCount)
|
|
local config = self.view.config
|
|
if portCount == 2 then
|
|
return config.TWO_PORTS_BELT_HEIGHT, config.TWO_PORTS_BELT_SPACING
|
|
elseif portCount == 3 then
|
|
return config.THREE_PORTS_BELT_HEIGHT, config.THREE_PORTS_BELT_SPACING
|
|
elseif portCount == 4 then
|
|
return config.FOUR_PORTS_BELT_HEIGHT, config.FOUR_PORTS_BELT_SPACING
|
|
elseif portCount == 5 then
|
|
return config.FIVE_PORTS_BELT_HEIGHT, config.FIVE_PORTS_BELT_SPACING
|
|
elseif portCount == 6 then
|
|
return config.SIX_PORTS_BELT_HEIGHT, config.SIX_PORTS_BELT_SPACING
|
|
else
|
|
return config.SINGLE_PORT_BELT_HEIGHT, 0
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._FilterBeltInfoList = HL.Method(HL.Table, HL.Table).Return(HL.Table) << function(self, resource, filter)
|
|
filter = lume.invert(filter)
|
|
local result = {}
|
|
for _, info in ipairs(resource) do
|
|
if filter[LuaIndex(info.index)] ~= nil then
|
|
table.insert(result, info)
|
|
end
|
|
end
|
|
|
|
return result
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._InitInBeltList = HL.Method() << function(self)
|
|
local inPortCount = #self.m_inBeltInfoList
|
|
self.m_inBindingBeltDataMap = {}
|
|
self.m_inEndSlotGroup = self.m_inEndSlotGroupGetter() or {}
|
|
|
|
if inPortCount == 0 then
|
|
return
|
|
end
|
|
|
|
local inBeltHeight, inBeltSpacing = self:_GetBeltHeightAndSpaceByPortCount(inPortCount)
|
|
self.view.inBeltLayoutGroup.spacing = inBeltSpacing
|
|
|
|
self.m_inBeltList:Refresh(inPortCount, function(cell, index)
|
|
local info = self.m_inBeltInfoList[index]
|
|
self:_RefreshBeltCellState(cell, info)
|
|
UIUtils.setSizeDeltaY(cell.rectTransform, inBeltHeight)
|
|
cell.gameObject.name = "Belt_"..info.index
|
|
|
|
if info.isBinding then
|
|
self.m_inBindingBeltDataMap[info.touchNodeId] = {
|
|
beltCell = cell,
|
|
beltInfo = info,
|
|
touchCompId = info.touchCompId,
|
|
}
|
|
end
|
|
end)
|
|
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(self.view.inBeltGroup)
|
|
|
|
self:_InitBeltGroupLine(true)
|
|
end
|
|
|
|
|
|
|
|
FacCacheBelt._InitOutBeltList = HL.Method() << function(self)
|
|
local outPortCount = #self.m_outBeltInfoList
|
|
self.m_outBindingBeltDataMap = {}
|
|
self.m_outEndSlotGroup = self.m_outEndSlotGroupGetter() or {}
|
|
|
|
if outPortCount == 0 then
|
|
return
|
|
end
|
|
|
|
local outBeltHeight, outBeltSpacing = self:_GetBeltHeightAndSpaceByPortCount(outPortCount)
|
|
self.view.outBeltLayoutGroup.spacing = outBeltSpacing
|
|
|
|
self.m_outBeltList:Refresh(outPortCount, function(cell, index)
|
|
local info = self.m_outBeltInfoList[index]
|
|
self:_RefreshBeltCellState(cell, info)
|
|
UIUtils.setSizeDeltaY(cell.rectTransform, outBeltHeight)
|
|
cell.gameObject.name = "Belt_"..info.index
|
|
|
|
if info.isBinding then
|
|
self.m_outBindingBeltDataMap[info.touchNodeId] = {
|
|
beltCell = cell,
|
|
beltInfo = info,
|
|
touchCompId = info.touchCompId,
|
|
}
|
|
end
|
|
end)
|
|
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(self.view.outBeltGroup)
|
|
|
|
self:_InitBeltGroupLine(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._InitBeltGroupLine = HL.Method(HL.Boolean) << function(self, isIn)
|
|
local endLineGroup = self:_GetEndLineGroup(isIn)
|
|
local colorStartId = isIn and LUT_COLOR_IN_START_ID or LUT_COLOR_OUT_START_ID
|
|
local beltList = isIn and self.m_inBeltList or self.m_outBeltList
|
|
local infoList = isIn and self.m_inBeltInfoList or self.m_outBeltInfoList
|
|
local bindingMap = isIn and self.m_inBindingBeltDataMap or self.m_outBindingBeltDataMap
|
|
local drawer = isIn and self.view.inFacLineDrawer or self.view.outFacLineDrawer
|
|
if self.m_noGroup then
|
|
|
|
local portColor = CSFactoryUtil.GetPedestalLUTColor(colorStartId)
|
|
for index, beltInfo in ipairs(infoList) do
|
|
local beltCell = beltList:GetItem(index)
|
|
local bindingData = bindingMap[beltInfo.touchNodeId]
|
|
self:_RefreshBeltCellColor(beltCell, portColor)
|
|
self:_DrawBeltGroupLine({
|
|
drawer = drawer,
|
|
startLine = beltCell.facLineCell,
|
|
endLineList = endLineGroup[1],
|
|
color = portColor,
|
|
bindingData = bindingData,
|
|
})
|
|
end
|
|
return
|
|
end
|
|
|
|
local layoutData = FactoryUtils.getMachineCraftCacheLayoutData(self.m_buildingNodeId)
|
|
if layoutData == nil then
|
|
return
|
|
end
|
|
|
|
local caches = isIn and layoutData.normalIncomeCaches or layoutData.normalOutcomeCaches
|
|
if caches == nil then
|
|
return
|
|
end
|
|
|
|
local slotGroup = isIn and self.m_inEndSlotGroup or self.m_outEndSlotGroup
|
|
for index, cache in ipairs(caches) do
|
|
local portColor = CSFactoryUtil.GetPedestalLUTColor(colorStartId + index - 1)
|
|
if cache.ports.Count == #infoList then
|
|
for i = 0, cache.ports.Count - 1 do
|
|
local portIndex = cache.ports[i]
|
|
local beltCell = beltList:GetItem(LuaIndex(portIndex))
|
|
local beltInfo = infoList[LuaIndex(portIndex)]
|
|
local bindingData = bindingMap[beltInfo.touchNodeId]
|
|
self:_RefreshBeltCellColor(beltCell, portColor)
|
|
self:_DrawBeltGroupLine({
|
|
drawer = drawer,
|
|
startLine = beltCell.facLineCell,
|
|
endLineList = endLineGroup[index],
|
|
color = portColor,
|
|
bindingData = bindingData,
|
|
})
|
|
if bindingData ~= nil then
|
|
bindingData.slotList = slotGroup[index]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._DrawBeltGroupLine = HL.Method(HL.Table) << function(self, drawInfo)
|
|
local drawer = drawInfo.drawer
|
|
local startLine = drawInfo.startLine
|
|
local endLineList = drawInfo.endLineList
|
|
local color = drawInfo.color
|
|
local bindingData = drawInfo.bindingData
|
|
local beltLineInfo = {}
|
|
local lineIdList = {}
|
|
|
|
beltLineInfo.drawer = drawer
|
|
for _, endLine in ipairs(endLineList) do
|
|
local lineId = drawer:DrawLine(startLine, endLine)
|
|
table.insert(lineIdList, lineId)
|
|
drawer:PlayLineAnimation(lineId, "fac_cache_line_default")
|
|
drawer:ChangeLineColor(lineId, color)
|
|
startLine.gameObject:SetActive(false)
|
|
endLine.gameObject:SetActive(false)
|
|
end
|
|
beltLineInfo.lineIdList = lineIdList
|
|
|
|
|
|
if bindingData ~= nil then
|
|
bindingData.beltLineInfo = beltLineInfo
|
|
end
|
|
end
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshBeltShownState = HL.Method() << function(self)
|
|
|
|
local needShow = GameInstance.remoteFactoryManager.unlockSystem.systemUnlockedBelt and
|
|
GameInstance.remoteFactoryManager:IsFacNodeInMainRegion(
|
|
self.m_buildingNode.belongChapter.chapterId,
|
|
self.m_buildingNodeId
|
|
)
|
|
|
|
self.view.gameObject:SetActiveIfNecessary(needShow)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
local DELAY_ANIM_SLOT_PLAY_DURATION = 0.35
|
|
local DELAY_ANIM_LINE_PLAY_DURATION = 0.45
|
|
local DELAY_ANIM_ITEM_PUT_PLAY_DURATION = 0.55
|
|
|
|
local DELAY_ANIM_SLOT_PLAY_TIMER = "timerItemPut"
|
|
local DELAY_ANIM_LINE_PLAY_TIMER = "timerItemPut"
|
|
local DELAY_ANIM_ITEM_PUT_PLAY_TIMER = "timerItemPut"
|
|
|
|
|
|
FacCacheBelt.m_noGroup = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
FacCacheBelt.m_inEndSlotGroup = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_inEndSlotGroupGetter = HL.Field(HL.Function)
|
|
|
|
|
|
FacCacheBelt.m_outEndSlotGroup = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_outEndSlotGroupGetter = HL.Field(HL.Function)
|
|
|
|
|
|
FacCacheBelt.m_inIndexList = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_outIndexList = HL.Field(HL.Table)
|
|
|
|
|
|
FacCacheBelt.m_stateRefreshCallback = HL.Field(HL.Function)
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._ParseCustomInfo = HL.Method(HL.Table) << function(self, customInfo)
|
|
if customInfo == nil then
|
|
return
|
|
end
|
|
|
|
self.m_noGroup = customInfo.noGroup
|
|
self.m_inEndSlotGroupGetter = customInfo.inEndSlotGroupGetter or function()end
|
|
self.m_outEndSlotGroupGetter = customInfo.outEndSlotGroupGetter or function()end
|
|
self.m_inIndexList = customInfo.inIndexList or {}
|
|
self.m_outIndexList = customInfo.outIndexList or {}
|
|
self.m_stateRefreshCallback = customInfo.stateRefreshCallback or function()end
|
|
self.m_onInitializeFinished = customInfo.onInitializeFinished or function()end
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._GetEndLineGroup = HL.Method(HL.Boolean).Return(HL.Table) << function(self, isIn)
|
|
if self.m_noGroup then
|
|
local singleLineCell = isIn and self.view.inEndLineCell or self.view.outEndLineCell
|
|
return { {singleLineCell} }
|
|
else
|
|
local slotGroup = isIn and self.m_inEndSlotGroup or self.m_outEndSlotGroup
|
|
local lineGroup = {}
|
|
for _, slotList in ipairs(slotGroup) do
|
|
local lineList = {}
|
|
for _, slot in ipairs(slotList) do
|
|
table.insert(lineList, slot:GetNormalSlotLine())
|
|
end
|
|
table.insert(lineGroup, lineList)
|
|
end
|
|
return lineGroup
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt.m_registered = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
FacCacheBelt._RegisterInterested = HL.Method() << function(self)
|
|
if self.m_registered then
|
|
self:_UnRegisterInterested()
|
|
end
|
|
|
|
if self.m_inBindingBeltDataMap ~= nil then
|
|
for nodeId, _ in pairs(self.m_inBindingBeltDataMap) do
|
|
GameInstance.remoteFactoryManager:RegisterInterestedUnitId(nodeId)
|
|
end
|
|
end
|
|
|
|
if self.m_outBindingBeltDataMap ~= nil then
|
|
for nodeId, _ in pairs(self.m_outBindingBeltDataMap) do
|
|
GameInstance.remoteFactoryManager:RegisterInterestedUnitId(nodeId)
|
|
end
|
|
end
|
|
|
|
self.m_registered = true
|
|
end
|
|
|
|
|
|
|
|
FacCacheBelt._UnRegisterInterested = HL.Method() << function(self)
|
|
if not self.m_registered then
|
|
return
|
|
end
|
|
|
|
if self.m_inBindingBeltDataMap ~= nil then
|
|
for nodeId, _ in pairs(self.m_inBindingBeltDataMap) do
|
|
GameInstance.remoteFactoryManager:UnregisterInterestedUnitId(nodeId)
|
|
end
|
|
end
|
|
|
|
if self.m_outBindingBeltDataMap ~= nil then
|
|
for nodeId, _ in pairs(self.m_outBindingBeltDataMap) do
|
|
GameInstance.remoteFactoryManager:UnregisterInterestedUnitId(nodeId)
|
|
end
|
|
end
|
|
|
|
self.m_registered = false
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshBeltCellColor = HL.Method(HL.Any, HL.Any) << function(self, cell, color)
|
|
if cell == nil or color == nil then
|
|
return
|
|
end
|
|
|
|
cell.decoLine.color = color
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshBeltCellState = HL.Method(HL.Any, HL.Table) << function(self, cell, info)
|
|
if cell == nil or info == nil then
|
|
return
|
|
end
|
|
|
|
cell.normalBG.gameObject:SetActiveIfNecessary(not info.isBlock)
|
|
cell.blockItemNode.gameObject:SetActiveIfNecessary(info.isBlock)
|
|
|
|
local animName = info.isBlock and "inbeltcell_default" or "inbeltcell_loop"
|
|
cell.animationWrapper:PlayWithTween(animName)
|
|
|
|
cell.bg.gameObject:SetActiveIfNecessary(info.isBinding)
|
|
|
|
|
|
if self.m_stateRefreshCallback ~= nil then
|
|
self.m_stateRefreshCallback(info)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshBeltCellConveyorAnimation = HL.Method(HL.Boolean, HL.Number, HL.Number, HL.String) << function(
|
|
self, isIn, nodeId, compId, itemId)
|
|
if self.m_isInSingleState then
|
|
return
|
|
end
|
|
|
|
local beltMap = isIn and self.m_outBindingBeltDataMap or self.m_inBindingBeltDataMap
|
|
if beltMap == nil then
|
|
return
|
|
end
|
|
|
|
local beltData = beltMap[nodeId]
|
|
if beltData == nil then
|
|
return
|
|
end
|
|
|
|
if beltData.touchCompId ~= compId then
|
|
return
|
|
end
|
|
|
|
if self:_GetIsBeltBlocked(nodeId, not isIn) then
|
|
return
|
|
end
|
|
|
|
local cell, info = beltData.beltCell, beltData.beltLineInfo
|
|
if cell == nil or info == nil then
|
|
return
|
|
end
|
|
|
|
local animName = isIn and "conveyorbelt_itemright_changed" or "conveyorbelt_item_changed"
|
|
|
|
local itemSprite = self:_GetItemSprite(itemId)
|
|
cell.putInItemImage.sprite = itemSprite
|
|
cell.blockItemIcon.sprite = itemSprite
|
|
cell.blockItemIcon.gameObject:SetActiveIfNecessary(true)
|
|
|
|
local fullSuccess, fullBottleData = Tables.fullBottleTable:TryGetValue(itemId)
|
|
if fullSuccess then
|
|
local liquidItemId = fullBottleData.liquidId
|
|
local liquidSprite = self:_GetItemSprite(liquidItemId)
|
|
cell.liquidIcon.sprite = liquidSprite
|
|
cell.liquidIcon.gameObject:SetActive(true)
|
|
else
|
|
cell.liquidIcon.gameObject:SetActive(false)
|
|
end
|
|
|
|
local targetLineIndex = 1
|
|
if self.m_noGroup then
|
|
if not isIn then
|
|
|
|
cell.putInItemAnimation:PlayWithTween(animName)
|
|
info[DELAY_ANIM_SLOT_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_ITEM_PUT_PLAY_DURATION, function()
|
|
info.drawer:PlayLineAnimation(info.lineIdList[targetLineIndex], "fac_cache_line_in")
|
|
info[DELAY_ANIM_SLOT_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_SLOT_PLAY_TIMER])
|
|
end)
|
|
else
|
|
info.drawer:PlayLineAnimation(info.lineIdList[targetLineIndex], "fac_cache_line_in")
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_LINE_PLAY_DURATION, function()
|
|
cell.putInItemAnimation:PlayWithTween(animName)
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_LINE_PLAY_TIMER])
|
|
end)
|
|
end
|
|
else
|
|
|
|
local slotList = beltData.slotList
|
|
for index, slot in ipairs(slotList) do
|
|
if slot:GetCurrentNormalSlotItemId() == itemId then
|
|
targetLineIndex = index
|
|
break
|
|
end
|
|
end
|
|
|
|
local targetSlot
|
|
targetSlot = slotList[targetLineIndex]
|
|
if not isIn then
|
|
|
|
cell.putInItemAnimation:PlayWithTween(animName)
|
|
info[DELAY_ANIM_ITEM_PUT_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_ITEM_PUT_PLAY_DURATION, function()
|
|
info.drawer:PlayLineAnimation(info.lineIdList[targetLineIndex], "fac_cache_line_in")
|
|
info[DELAY_ANIM_ITEM_PUT_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_ITEM_PUT_PLAY_TIMER])
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_LINE_PLAY_DURATION, function()
|
|
info.drawer:PlayPortLineDecoAnimation(info.lineIdList[targetLineIndex], "itemslot_fac_deco_in", false)
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_LINE_PLAY_TIMER])
|
|
end)
|
|
end)
|
|
else
|
|
|
|
info.drawer:PlayPortLineDecoAnimation(info.lineIdList[targetLineIndex], "itemslot_fac_deco_in", false)
|
|
info[DELAY_ANIM_SLOT_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_SLOT_PLAY_DURATION, function()
|
|
info.drawer:PlayLineAnimation(info.lineIdList[targetLineIndex], "fac_cache_line_in")
|
|
info[DELAY_ANIM_SLOT_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_SLOT_PLAY_TIMER])
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_StartTimer(DELAY_ANIM_LINE_PLAY_DURATION, function()
|
|
cell.putInItemAnimation:PlayWithTween(animName)
|
|
info[DELAY_ANIM_LINE_PLAY_TIMER] = self:_ClearTimer(info[DELAY_ANIM_LINE_PLAY_TIMER])
|
|
end)
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt._RefreshBeltCellBlockState = HL.Method(HL.Number) << function(self, buildingNodeId)
|
|
if self.m_buildingNodeId ~= buildingNodeId then
|
|
return
|
|
end
|
|
|
|
self:_GetBeltInfoList()
|
|
|
|
local inBeltCount = self.m_inBeltList:GetCount()
|
|
for index = 1, inBeltCount do
|
|
local cell = self.m_inBeltList:GetItem(index)
|
|
self:_RefreshBeltCellState(cell, self.m_inBeltInfoList[index])
|
|
end
|
|
|
|
local outBeltCount = self.m_outBeltList:GetCount()
|
|
for index = 1, outBeltCount do
|
|
local cell = self.m_outBeltList:GetItem(index)
|
|
self:_RefreshBeltCellState(cell, self.m_outBeltInfoList[index])
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacCacheBelt.RefreshCacheBelt = HL.Method() << function(self)
|
|
self.view.inFacLineDrawer:ClearDrawer()
|
|
self.view.outFacLineDrawer:ClearDrawer()
|
|
self:_RefreshCacheBelt()
|
|
end
|
|
|
|
|
|
|
|
|
|
FacCacheBelt.SetCacheBeltSingleState = HL.Method(HL.Boolean) << function(self, useSingleState)
|
|
|
|
|
|
local inBeltCount = self.m_inBeltList:GetCount()
|
|
for index = 1, inBeltCount do
|
|
local cell = self.m_inBeltList:GetItem(index)
|
|
self:_RefreshBeltCellState(cell, self.m_inBeltInfoList[index])
|
|
cell.blockNode.gameObject:SetActiveIfNecessary(not useSingleState)
|
|
cell.itemNode.gameObject:SetActiveIfNecessary(not useSingleState)
|
|
end
|
|
|
|
local outBeltCount = self.m_outBeltList:GetCount()
|
|
for index = 1, outBeltCount do
|
|
local cell = self.m_outBeltList:GetItem(index)
|
|
self:_RefreshBeltCellState(cell, self.m_outBeltInfoList[index])
|
|
cell.blockNode.gameObject:SetActiveIfNecessary(not useSingleState)
|
|
cell.itemNode.gameObject:SetActiveIfNecessary(not useSingleState)
|
|
end
|
|
|
|
self.m_isInSingleState = useSingleState
|
|
end
|
|
|
|
|
|
|
|
|
|
HL.Commit(FacCacheBelt)
|
|
return FacCacheBelt
|
|
|