764 lines
22 KiB
Lua
764 lines
22 KiB
Lua
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.FacSquirter
|
|
|
|
local SoilState = {
|
|
None = 0,
|
|
Spraying = 1,
|
|
Paused = 2,
|
|
Invalid = 3,
|
|
Completed = 4,
|
|
Waiting = 5,
|
|
NotInStep = 6,
|
|
}
|
|
|
|
local OutState = {
|
|
None = "None",
|
|
Idle = "Idle",
|
|
Spraying = "Spraying",
|
|
Stopped = "Stopped",
|
|
}
|
|
|
|
local SMART_ALERT_FUNCTION_NAME_LIST = {
|
|
"_CheckAlertNoPowerCondition",
|
|
"_CheckAlertNoPowerWithDiffuserCondition",
|
|
"_CheckAlertNoPowerWithoutDiffuserCondition",
|
|
"_CheckAlertCanBeOpenedCondition",
|
|
"_CheckAlertLiquidTypeCannotDumpedCondition",
|
|
"_CheckAlertDiffTypeLiquidCannotSprayedCondition",
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl = HL.Class('FacSquirterCtrl', uiCtrl.UICtrl)
|
|
|
|
local SOIL_CELL_PROGRESS_TWEEN_DURATION = 0.25
|
|
local SQUIRTER_SPRITES_FOLDER_PATH = "Factory/Squirter"
|
|
local INVALID_ITEM_TEXT_ID = "ui_fac_squirter_different_liquid"
|
|
local INVALID_SOIL_NODES_TEXT_ID = "ui_fac_squirter_no_target_info"
|
|
|
|
|
|
FacSquirterCtrl.m_buildingInfo = HL.Field(CS.Beyond.Gameplay.RemoteFactory.BuildingUIInfo_FluidSpray)
|
|
|
|
|
|
FacSquirterCtrl.m_updateThread = HL.Field(HL.Thread)
|
|
|
|
|
|
FacSquirterCtrl.m_soilNodeDataList = HL.Field(HL.Table)
|
|
|
|
|
|
FacSquirterCtrl.m_needUpdateSoilNodes = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
FacSquirterCtrl.m_soilCellConfig = HL.Field(HL.Table)
|
|
|
|
|
|
FacSquirterCtrl.m_validLiquidIds = HL.Field(HL.Table)
|
|
|
|
|
|
FacSquirterCtrl.m_soilCellTweenList = HL.Field(HL.Table)
|
|
|
|
|
|
FacSquirterCtrl.m_soilCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
FacSquirterCtrl.m_outState = HL.Field(HL.String) << ""
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.m_buildingInfo = arg.uiInfo
|
|
|
|
self.view.inventoryArea:InitInventoryArea({
|
|
customOnUpdateCell = function(cell, itemBundle)
|
|
self:_RefreshInventoryItemCell(cell, itemBundle)
|
|
end,
|
|
customSetActionMenuArgs = function(actionMenuArgs)
|
|
actionMenuArgs.cacheRepo = self.view.facCacheRepository
|
|
end,
|
|
onStateChange = function()
|
|
self:_RefreshNaviGroupSwitcherInfos()
|
|
end,
|
|
isFluidOnlyMachine = true,
|
|
})
|
|
|
|
self.view.facCacheRepository:InitFacCacheRepository({
|
|
cache = self.m_buildingInfo.sprayCache,
|
|
isInCache = true,
|
|
isFluidCache = true,
|
|
cacheIndex = 1,
|
|
slotCount = 1,
|
|
})
|
|
|
|
self.view.facCachePipe:InitFacCachePipe(self.m_buildingInfo, {
|
|
useSinglePipe = true,
|
|
})
|
|
|
|
self.view.buildingCommon:InitBuildingCommon(self.m_buildingInfo, {
|
|
smartAlertFuncNameList = SMART_ALERT_FUNCTION_NAME_LIST,
|
|
targetCtrlInstance = self
|
|
})
|
|
|
|
GameInstance.remoteFactoryManager:RegisterInterestedUnitId(self.m_buildingInfo.nodeId)
|
|
|
|
self:_UpdateSmartAlertCache()
|
|
self:_InitSquirterStaticData()
|
|
self:_InitSquirterBasicContent()
|
|
self:_InitSquirterSoilCellColorConfig()
|
|
self:_InitSquirterSoilNodes()
|
|
self:_InitSquirterUpdateThread()
|
|
|
|
self:_InitFacMachineCrafterController()
|
|
self.view.facCacheRepository.view.repoNaviGroup:NaviToThisGroup()
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl.OnClose = HL.Override() << function(self)
|
|
self.view.buildingCommon:ClearSmartAlertUpdate()
|
|
GameInstance.remoteFactoryManager:UnregisterInterestedUnitId(self.m_buildingInfo.nodeId)
|
|
|
|
if self.m_soilCellTweenList ~= nil then
|
|
for _, tween in pairs(self.m_soilCellTweenList) do
|
|
if tween ~= nil then
|
|
tween:Kill(false)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitSquirterUpdateThread = HL.Method() << function(self)
|
|
self:_UpdateAndRefreshOutState()
|
|
self.m_updateThread = self:_StartCoroutine(function()
|
|
while true do
|
|
self:_RefreshSquirterSpeed()
|
|
self:_UpdateAndRefreshOutState()
|
|
self:_UpdateAndRefreshSquirterAllSoilNodesState()
|
|
coroutine.step()
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitSquirterStaticData = HL.Method() << function(self)
|
|
self.m_validLiquidIds = {}
|
|
local success, tableData = Tables.factoryFluidSprayTable:TryGetValue(self.m_buildingInfo.buildingId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
for index = 0, tableData.validItemIds.Count - 1 do
|
|
self.m_validLiquidIds[tableData.validItemIds[index]] = true
|
|
end
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitSquirterBasicContent = HL.Method() << function(self)
|
|
local success, tableData = Tables.factoryFluidSprayTable:TryGetValue(self.m_buildingInfo.buildingId)
|
|
if not success then
|
|
return
|
|
end
|
|
self.view.speedNode.maxSpeedText.text = string.format("%d", tableData.maximumSuply)
|
|
self:_RefreshSquirterSpeed()
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._RefreshSquirterSpeed = HL.Method() << function(self)
|
|
local speed = self.m_buildingInfo.fluidSpray.lastRoundSprayCount
|
|
self.view.speedNode.currSpeedText.text = string.format("%d", speed)
|
|
self.view.speedNode.currSpeedText.color = speed > 0 and self.view.config.NORMAL_COLOR or self.view.config.STOPPED_COLOR
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._IsCurrentCacheItemValid = HL.Method().Return(HL.Boolean) << function(self)
|
|
local cacheItemId = ""
|
|
for id, _ in cs_pairs(self.m_buildingInfo.sprayCache.items) do
|
|
if not string.isEmpty(id) then
|
|
cacheItemId = id
|
|
break
|
|
end
|
|
end
|
|
|
|
return string.isEmpty(cacheItemId) or self.m_validLiquidIds[cacheItemId] == true
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._UpdateAndRefreshOutState = HL.Method() << function(self)
|
|
local state = OutState.None
|
|
local isValidSoilNodes = #self.m_soilNodeDataList > 0
|
|
local isValidItem = self:_IsCurrentCacheItemValid()
|
|
if not isValidItem or not isValidSoilNodes then
|
|
state = OutState.Stopped
|
|
else
|
|
local speed = self.m_buildingInfo.fluidSpray.lastRoundSprayCount
|
|
state = speed > 0 and OutState.Spraying or OutState.Idle
|
|
end
|
|
if state == self.m_outState then
|
|
return
|
|
end
|
|
|
|
self.view.outNode.stateController:SetState(state)
|
|
|
|
local isStopped = state == OutState.Stopped
|
|
if isStopped then
|
|
local text = ""
|
|
if not isValidSoilNodes then
|
|
text = Language[INVALID_SOIL_NODES_TEXT_ID]
|
|
else
|
|
local cacheItemId = ""
|
|
for id, _ in cs_pairs(self.m_buildingInfo.sprayCache.items) do
|
|
if not string.isEmpty(id) then
|
|
cacheItemId = id
|
|
break
|
|
end
|
|
end
|
|
local canBeDischarge = FactoryUtils.getLiquidCanBeDischarge(cacheItemId)
|
|
if not canBeDischarge then
|
|
text = string.format(Language.LUA_LIQUID_CANT_DISCHARGE_IN_SQUIRTER, UIUtils.getItemName(cacheItemId))
|
|
else
|
|
text = Language[INVALID_ITEM_TEXT_ID]
|
|
end
|
|
end
|
|
self.view.tipsTextNode.tipsText.text = text
|
|
end
|
|
UIUtils.PlayAnimationAndToggleActive(self.view.tipsTextNode.animationWrapper, isStopped)
|
|
UIUtils.PlayAnimationAndToggleActive(self.view.outNode.blockedAnim, isStopped)
|
|
|
|
|
|
self.m_outState = state
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitSquirterSoilCellColorConfig = HL.Method() << function(self)
|
|
self.m_soilCellConfig = {
|
|
[SoilState.Spraying] = {
|
|
iconId = "icon_squirter_play",
|
|
iconColor = self.view.config.NORMAL_COLOR,
|
|
progressColor = self.view.config.NORMAL_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_spraying"],
|
|
},
|
|
[SoilState.Paused] = {
|
|
iconId = "icon_squirter_pause",
|
|
iconColor = self.view.config.PAUSED_COLOR,
|
|
progressColor = self.view.config.PAUSED_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_pause"],
|
|
},
|
|
[SoilState.Invalid] = {
|
|
iconId = "icon_squirter_error",
|
|
iconColor = self.view.config.INVALID_COLOR,
|
|
progressColor = self.view.config.INVALID_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_different"],
|
|
},
|
|
[SoilState.Completed] = {
|
|
iconId = "icon_squirter_select",
|
|
iconColor = self.view.config.COMPLETE_COLOR,
|
|
progressColor = self.view.config.NORMAL_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_complete"],
|
|
},
|
|
[SoilState.Waiting] = {
|
|
iconId = "icon_squirter_omit",
|
|
iconColor = self.view.config.PAUSED_COLOR,
|
|
progressColor = self.view.config.PAUSED_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_waiting"],
|
|
hideProgress = true,
|
|
},
|
|
[SoilState.NotInStep] = {
|
|
iconId = "icon_squirter_omit",
|
|
iconColor = self.view.config.PAUSED_COLOR,
|
|
progressColor = self.view.config.PAUSED_COLOR,
|
|
stateText = Language["ui_fac_squirter_soil_step_invalid"],
|
|
hideProgress = true,
|
|
},
|
|
}
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitSquirterSoilNodes = HL.Method() << function(self)
|
|
local soilNodes = self.m_buildingInfo:GetProcessingSoilNodes()
|
|
|
|
self.m_soilNodeDataList = {}
|
|
self.m_soilCellTweenList = {}
|
|
|
|
for _, soilNode in cs_pairs(soilNodes) do
|
|
local nodeHandler = FactoryUtils.getBuildingNodeHandler(soilNode)
|
|
if nodeHandler ~= nil then
|
|
local soilComponent = nodeHandler:GetComponentInPosition(GEnums.FCComponentPos.Soil:GetHashCode())
|
|
if soilComponent ~= nil and soilComponent.soil ~= nil then
|
|
table.insert(self.m_soilNodeDataList, {
|
|
nodeHandler = nodeHandler,
|
|
soilComponent = soilComponent.soil,
|
|
state = SoilState.None,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
if #self.m_soilNodeDataList == 0 then
|
|
self.view.targetNode.emptyNode.gameObject:SetActiveIfNecessary(true)
|
|
self.view.targetNode.soilList.gameObject:SetActiveIfNecessary(false)
|
|
self.m_needUpdateSoilNodes = false
|
|
return
|
|
end
|
|
|
|
self.m_soilCells = UIUtils.genCellCache(self.view.targetNode.soilCell)
|
|
self.m_soilCells:Refresh(#self.m_soilNodeDataList, function(cell, index)
|
|
self:_RefreshSquirterSoilNodeBasicContent(cell, index)
|
|
self:_UpdateAndRefreshSquirterSoilNodeState(cell, index, true)
|
|
end)
|
|
|
|
self.view.targetNode.emptyNode.gameObject:SetActiveIfNecessary(false)
|
|
self.view.targetNode.soilList.gameObject:SetActiveIfNecessary(true)
|
|
self.m_needUpdateSoilNodes = true
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._RefreshSquirterSoilNodeBasicContent = HL.Method(HL.Any, HL.Number) << function(self, cell, index)
|
|
if cell == nil then
|
|
return
|
|
end
|
|
|
|
local data = self.m_soilNodeDataList[index]
|
|
if data == nil then
|
|
return
|
|
end
|
|
|
|
local success, facBuildingData = Tables.factoryBuildingTable:TryGetValue(data.nodeHandler.templateId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
cell.titleNode.text.text = facBuildingData.name
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._UpdateAndRefreshSquirterAllSoilNodesState = HL.Method() << function(self)
|
|
if not self.m_needUpdateSoilNodes then
|
|
return
|
|
end
|
|
|
|
local cellCount = self.m_soilCells:GetCount()
|
|
for index = 1, cellCount do
|
|
local cell = self.m_soilCells:GetItem(index)
|
|
self:_UpdateAndRefreshSquirterSoilNodeState(cell, index, false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._UpdateAndRefreshSquirterSoilNodeState = HL.Method(HL.Any, HL.Number, HL.Boolean) << function(self, cell, index, firstRefresh)
|
|
if cell == nil then
|
|
return
|
|
end
|
|
|
|
local data = self.m_soilNodeDataList[index]
|
|
if data == nil then
|
|
return
|
|
end
|
|
|
|
local success, stepsData = Tables.plantingDataTable:TryGetValue(data.nodeHandler.templateId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
local state = SoilState.None
|
|
local step = data.soilComponent.stepCursor
|
|
local stepData = stepsData.plantingSteps[step]
|
|
local stepType = stepData.plantingStepType
|
|
local currProgress, totalProgress = data.soilComponent.waterGot, -1
|
|
if stepType ~= GEnums.PlantingStepType.Water then
|
|
if step == 0 then
|
|
state = SoilState.NotInStep
|
|
else
|
|
local lastStepType = stepsData.plantingSteps[step - 1].plantingStepType
|
|
local isCompleted = lastStepType == GEnums.PlantingStepType.Water
|
|
state = isCompleted and SoilState.Completed or SoilState.NotInStep
|
|
if isCompleted then
|
|
currProgress = totalProgress
|
|
end
|
|
end
|
|
else
|
|
local valueIntList = stepData.plantingStepParameter.valueIntList
|
|
totalProgress = valueIntList[valueIntList.Count - 1]
|
|
if currProgress == totalProgress then
|
|
state = SoilState.Completed
|
|
else
|
|
if not self:_IsCurrentCacheItemValid() then
|
|
state = SoilState.Invalid
|
|
else
|
|
if currProgress <= 0 then
|
|
state = SoilState.Waiting
|
|
else
|
|
local currSpeed = self.m_buildingInfo.fluidSpray.lastRoundSprayCount
|
|
state = currSpeed > 0 and SoilState.Spraying or SoilState.Paused
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if state == data.state and not firstRefresh and state ~= SoilState.Spraying then
|
|
return
|
|
end
|
|
|
|
local config = self.m_soilCellConfig[state]
|
|
if config == nil then
|
|
return
|
|
end
|
|
|
|
cell.stateNode.icon:LoadSprite(SQUIRTER_SPRITES_FOLDER_PATH, config.iconId)
|
|
cell.stateNode.icon.color = config.iconColor
|
|
cell.progressNode.progressBar.color = config.progressColor
|
|
cell.stateNode.text.text = config.stateText
|
|
if not config.hideProgress then
|
|
local targetAmount = currProgress / totalProgress
|
|
if firstRefresh then
|
|
cell.progressNode.progressBar.fillAmount = targetAmount
|
|
else
|
|
if self.m_soilCellTweenList[index] ~= nil then
|
|
self.m_soilCellTweenList[index]:Kill(false)
|
|
end
|
|
self.m_soilCellTweenList[index] = DOTween.To(function()
|
|
return cell.progressNode.progressBar.fillAmount
|
|
end, function(amount)
|
|
cell.progressNode.progressBar.fillAmount = amount
|
|
end, targetAmount, SOIL_CELL_PROGRESS_TWEEN_DURATION)
|
|
end
|
|
|
|
cell.progressNode.content.gameObject:SetActiveIfNecessary(true)
|
|
else
|
|
cell.progressNode.content.gameObject:SetActiveIfNecessary(false)
|
|
end
|
|
|
|
if firstRefresh then
|
|
if state == SoilState.Invalid then
|
|
self:_RefreshSquirterSoilNodeAnimState(cell, state)
|
|
end
|
|
else
|
|
if data.state ~= state then
|
|
self:_RefreshSquirterSoilNodeAnimState(cell, state)
|
|
end
|
|
end
|
|
|
|
data.state = state
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._RefreshSquirterSoilNodeAnimState = HL.Method(HL.Any, HL.Number) << function(self, cell, state)
|
|
local animName = "facsquirtersoil_change"
|
|
if state == SoilState.Invalid then
|
|
animName = "facsquirtersoil_loop"
|
|
elseif state == SoilState.Completed then
|
|
animName = "facsquirtersoil_done"
|
|
end
|
|
if cell.stateAnim.curStateName == animName then
|
|
return
|
|
end
|
|
|
|
cell.stateAnim:PlayWithTween(animName)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._RefreshInventoryItemCell = HL.Method(HL.Userdata, HL.Any) << function(self, cell, itemBundle)
|
|
if cell == nil or itemBundle == nil then
|
|
return
|
|
end
|
|
|
|
|
|
local itemId = itemBundle.id
|
|
local isEmptyBottle = Tables.emptyBottleTable:ContainsKey(itemId)
|
|
local isFullBottle = Tables.fullBottleTable:ContainsKey(itemId)
|
|
local isBottle = isEmptyBottle or isFullBottle
|
|
local isEmpty = string.isEmpty(itemBundle.id)
|
|
cell.view.forbiddenMask.gameObject:SetActiveIfNecessary(not isBottle and not isEmpty)
|
|
cell.view.dragItem.enabled = isBottle
|
|
cell.view.dropItem.enabled = isBottle or isEmpty
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl.m_naviGroupSwitcher = HL.Field(HL.Forward('NaviGroupSwitcher'))
|
|
|
|
|
|
|
|
FacSquirterCtrl._InitFacMachineCrafterController = HL.Method() << function(self)
|
|
local NaviGroupSwitcher = require_ex("Common/Utils/UI/NaviGroupSwitcher").NaviGroupSwitcher
|
|
self.m_naviGroupSwitcher = NaviGroupSwitcher(self.view.inputGroup.groupId, nil, true)
|
|
|
|
self:_RefreshNaviGroupSwitcherInfos()
|
|
end
|
|
|
|
|
|
|
|
FacSquirterCtrl._RefreshNaviGroupSwitcherInfos = HL.Method() << function(self)
|
|
if self.m_naviGroupSwitcher == nil then
|
|
return
|
|
end
|
|
|
|
local naviGroupInfos = {
|
|
{
|
|
naviGroup = self.view.facCacheRepository.view.repoNaviGroup,
|
|
text = Language.LUA_INV_NAVI_SWITCH_TO_MACHINE
|
|
}
|
|
}
|
|
self.view.inventoryArea:AddNaviGroupSwitchInfo(naviGroupInfos)
|
|
self.m_naviGroupSwitcher:ChangeGroupInfos(naviGroupInfos)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl.m_smartAlertTargetTransformCache = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
FacSquirterCtrl._UpdateSmartAlertCache = HL.Method() << function(self)
|
|
self.m_smartAlertTargetTransformCache = {}
|
|
|
|
self.m_smartAlertTargetTransformCache.state = self.view.buildingCommon.view.stateNode.transform
|
|
local list = self.view.facCacheRepository:GetRepositorySlotList()
|
|
if list[1] ~= nil then
|
|
self.m_smartAlertTargetTransformCache.fluidCache = list[1].transform
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertCanBeOpenedCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.Closed then
|
|
return false
|
|
end
|
|
local node = self.m_buildingInfo.nodeHandler
|
|
if node and node.power and node.power.powerCost then
|
|
local curCost = node.power.powerCost
|
|
local powerInfo = FactoryUtils.getCurRegionPowerInfo()
|
|
local powerCost = powerInfo.powerCost
|
|
local powerGen = powerInfo.powerGen
|
|
if powerCost + curCost <= powerGen then
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.CanBeOpened,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.state,
|
|
defaultOpen = checkOpen
|
|
}
|
|
return true, alertInfo
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertNoPowerWithoutDiffuserCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.NotInPowerNet then
|
|
return false
|
|
end
|
|
if self.m_buildingInfo.inPowerRangeDiffusers.Count <= 0 then
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.NoPowerWithoutDiffuser,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.state,
|
|
defaultOpen = checkOpen
|
|
}
|
|
return true, alertInfo
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertNoPowerWithDiffuserCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.NotInPowerNet then
|
|
return false
|
|
end
|
|
if self.m_buildingInfo.inPowerRangeDiffusers.Count > 0 then
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.NoPowerWithDiffuser,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.state,
|
|
defaultOpen = checkOpen
|
|
}
|
|
return true, alertInfo
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertNoPowerCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.NoPower then
|
|
return false
|
|
end
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.NoPower,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.state,
|
|
defaultOpen = checkOpen
|
|
}
|
|
return true, alertInfo
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertLiquidTypeCannotDumpedCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.Idle then
|
|
return false
|
|
end
|
|
local cacheItemId = ""
|
|
for id, _ in cs_pairs(self.m_buildingInfo.sprayCache.items) do
|
|
if not string.isEmpty(id) then
|
|
cacheItemId = id
|
|
break
|
|
end
|
|
end
|
|
if not string.isEmpty(cacheItemId) and not FactoryUtils.getLiquidCanBeDischarge(cacheItemId) then
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self.view.facCacheRepository.view.repoNaviGroup.IsTopLayer and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.LiquidTypeCannotDumped,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.fluidCache,
|
|
args = {},
|
|
checkRefresh = cacheItemId,
|
|
defaultOpen = checkOpen
|
|
}
|
|
table.insert(alertInfo.args, UIUtils.getItemName(cacheItemId))
|
|
table.insert(alertInfo.args, UIUtils.getItemName(cacheItemId))
|
|
return true, alertInfo
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
|
|
FacSquirterCtrl._CheckAlertDiffTypeLiquidCannotSprayedCondition = HL.Method(HL.Userdata).Return(HL.Boolean, HL.Opt(HL.Table)) << function(self, state)
|
|
if self.view.buildingCommon.smartAlertChangeCachePauseUpdate or state ~= GEnums.FacBuildingState.Idle then
|
|
return false
|
|
end
|
|
local cacheItemId = ""
|
|
for id, _ in cs_pairs(self.m_buildingInfo.sprayCache.items) do
|
|
if not string.isEmpty(id) then
|
|
cacheItemId = id
|
|
break
|
|
end
|
|
end
|
|
if not string.isEmpty(cacheItemId) and not self.m_validLiquidIds[cacheItemId] then
|
|
local checkOpen = DeviceInfo.usingController and
|
|
self.view.facCacheRepository.view.repoNaviGroup.IsTopLayer and
|
|
self:GetSortingOrder() >= UIManager:CurBlockKeyboardEventPanelOrder()
|
|
local alertInfo = {
|
|
condition = GEnums.FacSmartAlertType.DiffTypeLiquidCannotSprayed,
|
|
targetTransform = self.m_smartAlertTargetTransformCache.fluidCache,
|
|
args = {},
|
|
checkRefresh = cacheItemId,
|
|
defaultOpen = checkOpen
|
|
}
|
|
table.insert(alertInfo.args, UIUtils.getItemName(cacheItemId))
|
|
return true, alertInfo
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
HL.Commit(FacSquirterCtrl)
|