779 lines
24 KiB
Lua
779 lines
24 KiB
Lua
|
|
|
|
local FluidContainerInfo = CS.Beyond.Gameplay.Factory.FactoryUtil.FluidContainerInfo
|
|
local ActionOnSetNaviTarget = CS.Beyond.Input.ActionOnSetNaviTarget
|
|
local GeneralAbilityType = GEnums.GeneralAbilityType
|
|
local AbilityState = CS.Beyond.Gameplay.GeneralAbilitySystem.AbilityState
|
|
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.LiquidPool
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl = HL.Class('LiquidPoolCtrl', uiCtrl.UICtrl)
|
|
|
|
local ItemAnimType = {
|
|
None = 1,
|
|
Init = 2,
|
|
Update = 3,
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.ON_GENERAL_ABILITY_STATE_CHANGE] = "_OnGeneralAbilityStateChange",
|
|
}
|
|
|
|
|
|
|
|
LiquidPoolCtrl.m_nodeId = HL.Field(HL.Number) << -1
|
|
|
|
|
|
LiquidPoolCtrl.m_isFilling = HL.Field(HL.Boolean) << true
|
|
|
|
|
|
LiquidPoolCtrl.m_selectedItemList = HL.Field(HL.Table)
|
|
|
|
|
|
LiquidPoolCtrl.m_selectedItemMap = HL.Field(HL.Table)
|
|
|
|
|
|
LiquidPoolCtrl.m_csInfo = HL.Field(CS.Beyond.Gameplay.Factory.FactoryUtil.FluidContainerInfo)
|
|
|
|
|
|
LiquidPoolCtrl.m_selectTargetLiquidId = HL.Field(HL.Any)
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.closeBtn.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PhaseId.LiquidPool)
|
|
end)
|
|
|
|
self.view.confirmBtn.onClick:AddListener(function()
|
|
self:_OnConfirmAction()
|
|
end)
|
|
|
|
self.view.actionTypeToggle.onValueChanged:AddListener(function(isOn)
|
|
self:_ToggleContent(isOn)
|
|
end)
|
|
|
|
local bagItemScrollRect = self.view.bagNode.itemScrollRect
|
|
bagItemScrollRect.OnScrollStart:AddListener(function()
|
|
self:_TryHideItemTips()
|
|
end)
|
|
bagItemScrollRect.onValueChanged:AddListener(function()
|
|
if bagItemScrollRect.dragging then
|
|
self:_TryHideItemTips()
|
|
end
|
|
end)
|
|
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({ self.view.inputGroup.groupId })
|
|
|
|
local nodeId = arg.nodeId
|
|
local tableIndex = arg.tableIndex
|
|
local ignoreAbility = arg.ignoreAbility
|
|
|
|
self.m_nodeId = nodeId
|
|
self.m_selectedItemList = {}
|
|
self.m_selectedItemMap = {}
|
|
self.m_selectedBottleLiquidCapacity = 0
|
|
|
|
self:_ToggleBag(false, true)
|
|
self.view.actionTypeToggle:SetIsOnWithoutNotify(tableIndex == 0)
|
|
self:_ToggleContent(tableIndex == 0)
|
|
|
|
if not ignoreAbility then
|
|
self:_HideLiquidPanelIfForbidden()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl.OnClose = HL.Override() << function(self)
|
|
if self:_IsBagActive() then
|
|
Notify(MessageConst.CLOSE_CONTROLLER_SMALL_MENU, self.view.bagNode.inputGroup.groupId)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._ToggleContent = HL.Method(HL.Boolean) << function(self, isFilling)
|
|
self.m_isFilling = isFilling
|
|
|
|
local node = isFilling and self.view.fillContent or self.view.dumpContent
|
|
|
|
node.animationWrapper:PlayWithTween(isFilling and "liquidpool_fill_change" or "liquidpool_dump_change")
|
|
|
|
self.m_csInfo = CSFactoryUtil.GetFluidContainerInfo(self.m_nodeId)
|
|
self.m_selectedBottleLiquidCapacity = 0
|
|
self.m_selectedItemList = {}
|
|
self.m_selectedItemMap = {}
|
|
self.m_bagNodeSelectedIndex = 1
|
|
|
|
self:_UpdatePoolNode(node)
|
|
self:_UpdateItemNode(node, ItemAnimType.Init)
|
|
self:_UpdateBottomNode()
|
|
|
|
self.view.confirmBtn.text = isFilling and Language["ui_fac_liquid_op_fill_button"] or Language["ui_fac_liquid_op_dump_button"]
|
|
self:_UpdateActionTypeToggleBinding()
|
|
|
|
if not isFilling then
|
|
CS.Beyond.Gameplay.Conditions.OnLiquidInteractInDumpMode.Trigger()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdateActionTypeToggleBinding = HL.Method() << function(self)
|
|
local actionTypeToggleBindingId = self.view.actionTypeToggle.toggleBindingId
|
|
local textId = self.m_isFilling and "key_hint_liquid_pool_switch_to_dump" or "key_hint_liquid_pool_switch_to_fill"
|
|
InputManagerInst:SetBindingText(actionTypeToggleBindingId, Language[textId])
|
|
end
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdatePoolNode = HL.Method(HL.Table) << function(self, contentNode)
|
|
local node = contentNode.poolNode
|
|
local info = self.m_csInfo
|
|
node.nameTxt.text = info.name
|
|
local isEmpty = string.isEmpty(info.itemId)
|
|
if isEmpty then
|
|
node.content:PlayOutAnimation()
|
|
else
|
|
node.content:PlayInAnimation()
|
|
node.item:InitItem({ id = info.itemId }, true)
|
|
end
|
|
|
|
node.storageTxt.text = info.isInfinite and Language.LUA_LIQUID_POOL_INFINITE_COUNT or string.format(Language.LUA_LIQUID_STORAGE_FORMAT, info.itemCount, info.maxAmount)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdateItemNode = HL.Method(HL.Table, HL.Number) << function(self, contentNode, animType)
|
|
local node = contentNode.itemNode
|
|
local info = self.m_csInfo
|
|
if not self.m_isFilling and
|
|
not string.isEmpty(info.itemId) and
|
|
not FactoryUtils.getLiquidCanBeDischarge(info.itemId) then
|
|
node.content.gameObject:SetActiveIfNecessary(false)
|
|
node.forbidContent.gameObject:SetActiveIfNecessary(true)
|
|
node.forbidTxt.text = string.format(Language.LUA_LIQUID_CANT_DISCHARGE_IN_POOL_DUMP, UIUtils.getItemName(info.itemId))
|
|
return
|
|
end
|
|
node.content.gameObject:SetActiveIfNecessary(true)
|
|
node.forbidContent.gameObject:SetActiveIfNecessary(false)
|
|
if not node.m_getCell then
|
|
node.m_getCell = UIUtils.genCachedCellFunction(node.scrollList)
|
|
node.scrollList.onUpdateCell:AddListener(function(obj, csIndex)
|
|
self:_OnUpdateCell(node.m_getCell(obj), LuaIndex(csIndex))
|
|
end)
|
|
node.content.onClick:AddListener(function()
|
|
self:_ToggleBag(true)
|
|
end)
|
|
node.emptyAddBtn.onClick:AddListener(function()
|
|
self:_ToggleBag(true)
|
|
end)
|
|
end
|
|
local count = #self.m_selectedItemList
|
|
local isEmpty = count == 0
|
|
node.deco1.gameObject:SetActive(isEmpty)
|
|
node.deco2.gameObject:SetActive(isEmpty)
|
|
node.emptyAddBtn.gameObject:SetActive(isEmpty)
|
|
node.scrollList.gameObject:SetActive(not isEmpty)
|
|
node.scrollList:UpdateCount(count)
|
|
self:_UpdateSelectItemBinding()
|
|
local animName = isEmpty and "liquidpoolarrow_black" or "liquidpoolarrow_blue"
|
|
if animType == ItemAnimType.Init then
|
|
contentNode.arrowNode:SampleClipAtPercent(animName, 1)
|
|
elseif animType == ItemAnimType.Update then
|
|
contentNode.arrowNode:Play(animName)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdateSelectItemBinding = HL.Method() << function(self)
|
|
local contentNode = self.m_isFilling and self.view.fillContent or self.view.dumpContent
|
|
local isEmpty = #self.m_selectedItemList == 0
|
|
local textId = isEmpty and "key_hint_liquid_pool_select_item" or "key_hint_liquid_pool_change_item"
|
|
local text = Language[textId]
|
|
contentNode.itemNode.content.customBindingViewLabelText = text
|
|
contentNode.itemNode.keyHint:SetText(text)
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdateBottomNode = HL.Method() << function(self)
|
|
local count = #self.m_selectedItemList
|
|
local isEmpty = count == 0
|
|
self.view.emptyHint.gameObject:SetActive(isEmpty)
|
|
self.view.confirmBtn.gameObject:SetActive(not isEmpty)
|
|
|
|
local info = self.m_csInfo
|
|
local liquidId
|
|
if string.isEmpty(info.itemId) then
|
|
if not self.m_isFilling and not isEmpty then
|
|
liquidId = self.m_selectTargetLiquidId
|
|
end
|
|
else
|
|
liquidId = info.itemId
|
|
end
|
|
if liquidId then
|
|
local itemData = Tables.itemTable[liquidId]
|
|
self.view.liquidNameTxt.text = itemData.name
|
|
self.view.liquidNumTxt.text = self.m_selectedBottleLiquidCapacity
|
|
UIUtils.setItemRarityImage(self.view.liquidRarity, itemData.rarity)
|
|
self.view.countNode.gameObject:SetActive(true)
|
|
else
|
|
self.view.countNode.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnUpdateCell = HL.Method(HL.Forward('Item'), HL.Number) << function(self, cell, index)
|
|
local info = self.m_selectedItemList[index]
|
|
cell:InitItem(info, true)
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnConfirmAction = HL.Method() << function(self)
|
|
self:_SendActionMsg()
|
|
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._SendActionMsg = HL.Method() << function(self)
|
|
local idList = {}
|
|
local countList = {}
|
|
for k, v in ipairs(self.m_selectedItemList) do
|
|
idList[k] = v.id
|
|
countList[k] = v.count
|
|
end
|
|
if self.m_isFilling then
|
|
AudioManager.PostEvent("Au_UI_Event_WaterUp")
|
|
GameInstance.player.remoteFactory.core:Message_TakeOutFluidFromLiquidBody(Utils.getCurrentChapterId(), self.m_csInfo.waterKey, idList, countList, function(op, opRet)
|
|
self:_OnActionReturn(true, op, opRet)
|
|
end)
|
|
else
|
|
AudioManager.PostEvent("Au_UI_Event_WaterDown")
|
|
GameInstance.player.remoteFactory.core:Message_PutInFluidToLiquidBody(Utils.getCurrentChapterId(), self.m_csInfo.waterKey, idList, countList, function(op, opRet)
|
|
self:_OnActionReturn(false, op, opRet)
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnActionReturn = HL.Method(HL.Boolean, CS.Proto.CS_FACTORY_OP, CS.Proto.SC_FACTORY_OP_RET) << function(self, isFilling, op, opRet)
|
|
if opRet.RetCode ~= CS.Proto.FACTORY_OP_RET_CODE.Ok then
|
|
self:_ToggleContent(self.m_isFilling)
|
|
return
|
|
end
|
|
|
|
local retType = isFilling and opRet.TakeOutFluidFromLiquidBody.Ret or opRet.PutInFluidToLiquidBody.Ret
|
|
|
|
if retType == CS.Proto.RET_FLUID_WITH_LIQUID_BODY.None then
|
|
if isFilling then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_FAIL_FILL_NONE)
|
|
else
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_FAIL_DUMP_NONE)
|
|
end
|
|
self:_ToggleContent(self.m_isFilling)
|
|
return
|
|
end
|
|
local node = self.m_isFilling and self.view.fillContent or self.view.dumpContent
|
|
local anim = self.m_isFilling and "liquid_pool_filling" or "liquid_pool_dumpping"
|
|
Notify(MessageConst.SHOW_BLOCK_INPUT_PANEL, node.animationWrapper:GetClipLength(anim))
|
|
node.animationWrapper:PlayWithTween(anim, function()
|
|
self:_StartTimer(0, function()
|
|
|
|
node.animationWrapper:PlayWithTween("liquid_pool_normal")
|
|
end)
|
|
self:_ShowReward(isFilling, opRet, retType)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._ShowReward = HL.Method(HL.Boolean, CS.Proto.SC_FACTORY_OP_RET, CS.Proto.RET_FLUID_WITH_LIQUID_BODY) << function(self, isFilling, opRet, retType)
|
|
if retType == CS.Proto.RET_FLUID_WITH_LIQUID_BODY.PartialByBag then
|
|
if isFilling then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_FILL_PARTIAL_BY_BAG)
|
|
else
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_DUMP_PARTIAL_BY_BAG)
|
|
end
|
|
elseif retType == CS.Proto.RET_FLUID_WITH_LIQUID_BODY.PartialByLiquidBody then
|
|
if isFilling then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_FILL_PARTIAL_BY_LIQUID_BODY)
|
|
else
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_ACTION_DUMP_PARTIAL_BY_LIQUID_BODY)
|
|
end
|
|
end
|
|
local protoItems, liquidAmount
|
|
if isFilling then
|
|
local body = opRet.TakeOutFluidFromLiquidBody
|
|
protoItems = body.GainBottleWaterItems
|
|
liquidAmount = body.CostLiquid
|
|
else
|
|
local body = opRet.PutInFluidToLiquidBody
|
|
protoItems = body.GainBottleItems
|
|
liquidAmount = body.GainLiquid
|
|
end
|
|
local liquidId
|
|
if isFilling then
|
|
liquidId = self.m_csInfo.itemId
|
|
else
|
|
local bottleId = opRet.PutInFluidToLiquidBody.CostBottleWaterItems[0].Id
|
|
local data = Tables.fullBottleTable[bottleId]
|
|
liquidId = data.liquidId
|
|
end
|
|
local itemList = {}
|
|
for k = 0, protoItems.Count - 1 do
|
|
local bundle = protoItems[k]
|
|
table.insert(itemList, { id = bundle.Id, count = bundle.Count })
|
|
end
|
|
local itemData = Tables.itemTable[liquidId]
|
|
Notify(MessageConst.SHOW_SYSTEM_REWARDS, {
|
|
title = isFilling and Language.LUA_LIQUID_FILL_SUCCESS or Language.LUA_LIQUID_DUMP_SUCCESS,
|
|
subTitle = string.format(isFilling and Language.LUA_LIQUID_FILL_RESULT or Language.LUA_LIQUID_DUMP_RESULT, liquidAmount, itemData.name),
|
|
icon = isFilling and "icon_liquid_0" or "icon_liquid_1",
|
|
items = itemList,
|
|
|
|
|
|
})
|
|
self:_ToggleContent(self.m_isFilling)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl.m_bagNodeItemInfos = HL.Field(HL.Table)
|
|
|
|
|
|
LiquidPoolCtrl.m_bagNodeSelectedIndex = HL.Field(HL.Number) << 1
|
|
|
|
|
|
LiquidPoolCtrl.m_selectedBottleLiquidCapacity = HL.Field(HL.Number) << 0
|
|
|
|
|
|
LiquidPoolCtrl.m_getBagNodeItemCell = HL.Field(HL.Function)
|
|
|
|
|
|
LiquidPoolCtrl.m_bagNodeSelectTargetLiquidId = HL.Field(HL.Any)
|
|
|
|
|
|
|
|
LiquidPoolCtrl._IsBagActive = HL.Method().Return(HL.Boolean) << function(self)
|
|
return self.view.bagNode.gameObject.activeInHierarchy
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._ToggleBag = HL.Method(HL.Boolean, HL.Opt(HL.Boolean)) << function(self, active, isInit)
|
|
local node = self.view.bagNode
|
|
if isInit then
|
|
node.gameObject:SetActive(active)
|
|
self:_UpdateActionTypeToggleBinding()
|
|
return
|
|
end
|
|
|
|
if self:_IsBagActive() == active then
|
|
return
|
|
end
|
|
|
|
node.gameObject:SetActive(true)
|
|
if not active then
|
|
InputManagerInst.controllerNaviManager:SetTarget(nil)
|
|
node.animationWrapper:PlayOutAnimation(function()
|
|
node.gameObject:SetActive(false)
|
|
Notify(MessageConst.CLOSE_CONTROLLER_SMALL_MENU, self.view.bagNode.inputGroup.groupId)
|
|
end)
|
|
return
|
|
end
|
|
|
|
Notify(MessageConst.SHOW_AS_CONTROLLER_SMALL_MENU, {
|
|
panelId = PANEL_ID,
|
|
isGroup = true,
|
|
id = self.view.bagNode.inputGroup.groupId,
|
|
hintPlaceholder = self.view.controllerHintPlaceholder,
|
|
rectTransform = self.view.bagNode.rectTransform,
|
|
noHighlight = true,
|
|
})
|
|
|
|
if not self.m_getBagNodeItemCell then
|
|
self.m_getBagNodeItemCell = UIUtils.genCachedCellFunction(node.itemScrollList)
|
|
node.itemScrollList.onUpdateCell:AddListener(function(obj, csIndex)
|
|
self:_OnUpdateBagNodeItemCell(self.m_getBagNodeItemCell(obj), LuaIndex(csIndex))
|
|
end)
|
|
node.closeBtn.onClick:AddListener(function()
|
|
if self:_TryHideItemTips() then
|
|
return
|
|
end
|
|
self:_CancelBagSelect()
|
|
end)
|
|
node.confirmBtn.onClick:AddListener(function()
|
|
self:_OnClickBagConfirm()
|
|
end)
|
|
end
|
|
self:_PrepareBagData()
|
|
node.itemScrollList:ScrollToIndex(CSIndex(self.m_bagNodeSelectedIndex), true)
|
|
node.itemScrollList:UpdateCount(#self.m_bagNodeItemInfos)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnUpdateBagNodeItemCell = HL.Method(HL.Any, HL.Number) << function(self, cell, index)
|
|
local info = self.m_bagNodeItemInfos[index]
|
|
cell:InitItemCellForSelect({
|
|
itemBundle = info,
|
|
curNum = info.selectedCount,
|
|
tryChangeNum = function(newNum)
|
|
return self:_TryChangeSelectNum(index, newNum)
|
|
end,
|
|
onNumChanged = function(newNum)
|
|
self:_OnSelectNumChanged(index, newNum)
|
|
end,
|
|
bindInputChangeNum = true,
|
|
})
|
|
cell.view.forbidNode.gameObject:SetActive(not self.m_isFilling and not info.canBeDischarge)
|
|
cell.view.nonValidNode.gameObject:SetActive(info.canBeDischarge and not info.isValid)
|
|
cell.view.item.view.button.onClick:AddListener(function()
|
|
if not cell.view.item.showingTips then
|
|
cell.view.item:ShowTips({
|
|
tipsPosTransform = cell.view.tipsPos,
|
|
tipsPosType = UIConst.UI_TIPS_POS_TYPE.RightDown,
|
|
|
|
safeArea = cell.transform,
|
|
isSideTips = true,
|
|
})
|
|
end
|
|
end)
|
|
cell.view.item.view.button:ChangeActionOnSetNaviTarget(ActionOnSetNaviTarget.None)
|
|
cell.view.item.view.button.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
self.m_bagNodeSelectedIndex = index
|
|
end
|
|
end
|
|
cell.view.gameObject.name = info.id
|
|
if index == self.m_bagNodeSelectedIndex then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.view.item.view.button)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnSelectNumChanged = HL.Method(HL.Number, HL.Number) << function(self, index, newNum)
|
|
local info = self.m_bagNodeItemInfos[index]
|
|
info.selectedCount = newNum
|
|
if not self.m_isFilling then
|
|
if newNum == 0 then
|
|
if string.isEmpty(self.m_csInfo.itemId) then
|
|
for k, v in ipairs(self.m_bagNodeItemInfos) do
|
|
if v.selectedCount > 0 then
|
|
|
|
return
|
|
end
|
|
end
|
|
|
|
self.m_bagNodeSelectTargetLiquidId = nil
|
|
self:_UpdateBagNodeAllItemValidStateOnSelect()
|
|
end
|
|
elseif not self.m_bagNodeSelectTargetLiquidId then
|
|
self.m_bagNodeSelectTargetLiquidId = info.liquidId
|
|
self:_UpdateBagNodeAllItemValidStateOnSelect()
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._TryChangeSelectNum = HL.Method(HL.Number, HL.Number).Return(HL.Boolean, HL.Opt(HL.Number)) << function(self, index, newNum)
|
|
local info = self.m_bagNodeItemInfos[index]
|
|
if not self.m_isFilling then
|
|
if not info.canBeDischarge then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_CANT_DISCHARGE_IN_POOL_BOTTLE)
|
|
return false
|
|
end
|
|
if not info.isValid then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_DUMP_LIQUID_TYPE_MISMATCH)
|
|
return false
|
|
end
|
|
end
|
|
|
|
local bottleCount = 0
|
|
local capacity = 0
|
|
for k, v in ipairs(self.m_bagNodeItemInfos) do
|
|
if k ~= index then
|
|
bottleCount = bottleCount + v.selectedCount
|
|
capacity = capacity + v.selectedCount * v.liquidCapacity
|
|
end
|
|
end
|
|
if not self.m_csInfo.isInfinite then
|
|
local restCapacity
|
|
if self.m_isFilling then
|
|
restCapacity = self.m_csInfo.itemCount - capacity
|
|
else
|
|
restCapacity = self.m_csInfo.maxAmount - self.m_csInfo.itemCount - capacity
|
|
end
|
|
local maxNum = math.max(0, math.floor(restCapacity / info.liquidCapacity))
|
|
if maxNum < newNum then
|
|
if self.m_isFilling then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_FILL_NOT_ENOUGH)
|
|
else
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_DUMP_NOT_ENOUGH)
|
|
end
|
|
newNum = maxNum
|
|
end
|
|
end
|
|
if self.m_isFilling then
|
|
if bottleCount + newNum > Tables.factoryConst.maxFillingBottleCount then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_LIQUID_FILL_TOO_MUCH_BOTTLE)
|
|
return true, math.max(0, Tables.factoryConst.maxFillingBottleCount - bottleCount)
|
|
end
|
|
end
|
|
return true, newNum
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._UpdateBagNodeAllItemValidStateOnSelect = HL.Method() << function(self)
|
|
local targetLiquidId = self.m_bagNodeSelectTargetLiquidId
|
|
for k, v in ipairs(self.m_bagNodeItemInfos) do
|
|
v.isValid = not targetLiquidId or v.liquidId == targetLiquidId
|
|
local cell = self.m_getBagNodeItemCell(k)
|
|
if cell then
|
|
cell.view.nonValidNode.gameObject:SetActive(v.canBeDischarge and not v.isValid)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._PrepareBagData = HL.Method() << function(self)
|
|
self.m_bagNodeItemInfos = {}
|
|
|
|
local targetLiquidId = (not string.isEmpty(self.m_csInfo.itemId)) and self.m_csInfo.itemId or nil
|
|
local bottleTable = self.m_isFilling and Tables.emptyBottleTable or Tables.fullBottleTable
|
|
for id, bottleData in pairs(bottleTable) do
|
|
local needShow
|
|
if not targetLiquidId then
|
|
needShow = true
|
|
else
|
|
if self.m_isFilling then
|
|
needShow = lume.find(bottleData.liquidItems, targetLiquidId)
|
|
else
|
|
needShow = true
|
|
end
|
|
end
|
|
if needShow then
|
|
local count = Utils.getItemCount(id)
|
|
if count > 0 then
|
|
local itemData = Tables.itemTable[id]
|
|
local info = {
|
|
id = id,
|
|
count = count,
|
|
sortId1 = itemData.sortId1,
|
|
sortId2 = itemData.sortId2,
|
|
rarity = itemData.rarity,
|
|
liquidCapacity = bottleData.liquidCapacity,
|
|
selectedCount = self.m_selectedItemMap[id] and self.m_selectedItemMap[id] or 0,
|
|
}
|
|
if not self.m_isFilling then
|
|
info.liquidId = bottleData.liquidId
|
|
info.canBeDischarge = FactoryUtils.getLiquidCanBeDischarge(bottleData.liquidId)
|
|
|
|
if info.selectedCount > 0 then
|
|
targetLiquidId = bottleData.liquidId
|
|
end
|
|
else
|
|
info.isValid = true
|
|
end
|
|
info.validSortId = info.isValid and 1 or 0
|
|
info.countSortId = info.count > 0 and 1 or 0
|
|
table.insert(self.m_bagNodeItemInfos, info)
|
|
end
|
|
end
|
|
end
|
|
self.m_bagNodeSelectTargetLiquidId = targetLiquidId
|
|
if not self.m_isFilling then
|
|
|
|
self:_UpdateBagNodeAllItemValidStateOnSelect()
|
|
end
|
|
table.sort(self.m_bagNodeItemInfos, Utils.genSortFunction({ "validSortId", "countSortId", "rarity", "sortId1", "sortId2", "id" }, false))
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnClickBagConfirm = HL.Method() << function(self)
|
|
local prevCount = #self.m_selectedItemList
|
|
local prevIsEmpty = prevCount == 0
|
|
self.m_selectedItemList = {}
|
|
self.m_selectedItemMap = {}
|
|
for _, info in ipairs(self.m_bagNodeItemInfos) do
|
|
if info.selectedCount > 0 then
|
|
table.insert(self.m_selectedItemList, { id = info.id, count = info.selectedCount })
|
|
self.m_selectedItemMap[info.id] = info.selectedCount
|
|
end
|
|
end
|
|
self:_CalcCurBottleLiquidIdAndCapacity()
|
|
self:_ToggleBag(false)
|
|
local node = self.m_isFilling and self.view.fillContent or self.view.dumpContent
|
|
local currCount = #self.m_selectedItemList
|
|
local currIsEmpty = currCount == 0
|
|
local animType = prevIsEmpty == currIsEmpty and ItemAnimType.None or ItemAnimType.Update
|
|
self:_UpdateItemNode(node, animType)
|
|
self:_UpdateBottomNode()
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._CancelBagSelect = HL.Method() << function(self)
|
|
self:_ToggleBag(false)
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._CalcCurBottleLiquidIdAndCapacity = HL.Method() << function(self)
|
|
self.m_selectTargetLiquidId = nil
|
|
self.m_selectedBottleLiquidCapacity = 0
|
|
for _, info in ipairs(self.m_bagNodeItemInfos) do
|
|
self.m_selectedBottleLiquidCapacity = self.m_selectedBottleLiquidCapacity + info.liquidCapacity * info.selectedCount
|
|
if not self.m_isFilling and info.selectedCount > 0 then
|
|
self.m_selectTargetLiquidId = info.liquidId
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._HideLiquidPanelIfForbidden = HL.Method() << function(self)
|
|
local abilityType = GeneralAbilityType.FluidInteract
|
|
local abilityRuntimeData = GameInstance.player.generalAbilitySystem:GetAbilityRuntimeDataByType(abilityType)
|
|
local abilityState = abilityRuntimeData.state
|
|
if abilityState ~= AbilityState.ForbiddenSelect and abilityState ~= AbilityState.ForbiddenUse then
|
|
return
|
|
end
|
|
|
|
self:_CancelBagSelect()
|
|
|
|
if self:IsPlayingAnimationIn() then
|
|
self:PlayAnimationOutWithCallback(function()
|
|
PhaseManager:ExitPhaseFast(PhaseId.LiquidPool)
|
|
end)
|
|
else
|
|
PhaseManager:PopPhase(PhaseId.LiquidPool)
|
|
end
|
|
if not string.isEmpty(abilityRuntimeData.forbidSelectToastId) then
|
|
Notify(MessageConst.SHOW_TOAST, Language[abilityRuntimeData.forbidSelectToastId])
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LiquidPoolCtrl._TryHideItemTips = HL.Method().Return(HL.Boolean) << function(self)
|
|
local isShow = UIManager:IsShow(PanelId.ItemTips)
|
|
if isShow then
|
|
self:Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
end
|
|
return isShow
|
|
end
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl._OnGeneralAbilityStateChange = HL.Method(HL.Table) << function(self, args)
|
|
local abilityType = unpack(args)
|
|
if abilityType ~= GeneralAbilityType.FluidInteract then
|
|
return
|
|
end
|
|
self:_HideLiquidPanelIfForbidden()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LiquidPoolCtrl.ShowLiquidPool = HL.StaticMethod(HL.Table) << function(args)
|
|
local nodeId = args[1]
|
|
local tableIndex = args[2]
|
|
local ignoreAbility = args[3]
|
|
PhaseManager:OpenPhase(PhaseId.LiquidPool, { nodeId = nodeId, tableIndex = tableIndex, ignoreAbility = ignoreAbility})
|
|
end
|
|
|
|
|
|
HL.Commit(LiquidPoolCtrl)
|