1226 lines
40 KiB
Lua
1226 lines
40 KiB
Lua
local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
|
|
|
|
local hiddenTechId = "hidden-tech"
|
|
|
|
local BLUEPRINT_SHARE_STATEMENT_KEY = "blueprint_share_statement_key"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent = HL.Class('BlueprintContent', UIWidgetBase)
|
|
|
|
|
|
|
|
BlueprintContent.m_deviceInfos = HL.Field(HL.Table)
|
|
|
|
|
|
BlueprintContent.m_csBPInst = HL.Field(CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintInstance)
|
|
|
|
|
|
BlueprintContent.m_csBP = HL.Field(CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprint)
|
|
|
|
|
|
BlueprintContent.m_deviceCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
BlueprintContent.isEditing = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
BlueprintContent.isSharing = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
BlueprintContent.curIcon = HL.Field(HL.String) << 'blueprint_default_icon'
|
|
|
|
|
|
BlueprintContent.curColorId = HL.Field(HL.Number) << -1
|
|
|
|
|
|
BlueprintContent.m_bpAbnormalIconHelper = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
BlueprintContent.m_deviceCellMaxNumber = HL.Field(HL.Number) << 8
|
|
|
|
|
|
BlueprintContent.m_isNaviDevice = HL.Field(HL.Boolean) << true
|
|
|
|
|
|
BlueprintContent.m_inputFieldNum = HL.Field(HL.Number) << 1
|
|
|
|
|
|
BlueprintContent.m_blueprintID = HL.Field(HL.Any) << 0
|
|
|
|
|
|
|
|
|
|
BlueprintContent._OnFirstTimeInit = HL.Override() << function(self)
|
|
self.m_deviceCells = UIUtils.genCellCache(self.view.deviceCell)
|
|
self:_InitTag()
|
|
self.view.changeIconBtn.onClick:AddListener(function()
|
|
self:_ToggleChangeIcon(not self.view.changeIconNode.gameObject.activeSelf)
|
|
end)
|
|
self.view.changeIconNode.view.autoCloseArea.onTriggerAutoClose:AddListener(function()
|
|
self:_ToggleChangeIcon(false)
|
|
end)
|
|
|
|
self.view.nameInputField.onValidateCharacterLimit = I18nUtils.GetRealTextByLengthLimit
|
|
self.view.nameInputField.onGetTextLength = I18nUtils.GetTextRealLength
|
|
|
|
self.view.descInputField.onValidateCharacterLimit = I18nUtils.GetRealTextByLengthLimit
|
|
self.view.descInputField.onGetTextLength = I18nUtils.GetTextRealLength
|
|
|
|
if BEYOND_DEBUG_COMMAND and UNITY_EDITOR then
|
|
if GameInstance.player.remoteFactory.blueprint.debugBuiltinBlueprints then
|
|
self.view.nameInputField.characterLimit = 0
|
|
self.view.descInputField.characterLimit = 0
|
|
end
|
|
end
|
|
|
|
self:RegisterMessage(MessageConst.FAC_ON_REVIEW_BLUEPRINT, function()
|
|
self:FacOnReviewBlueprint()
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent.InitBlueprintContent = HL.Method(HL.Opt(CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintInstance, HL.Any, CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprint, HL.Boolean, HL.Boolean, HL.Table)) << function(self, csBPInst, id, csBP, isEditing, isSharing, bpAbnormalIconHelper)
|
|
self:_FirstTimeInit()
|
|
|
|
self:ChangeIsEditing(isEditing)
|
|
|
|
self.m_blueprintID = id
|
|
self.m_csBPInst = csBPInst
|
|
self.m_csBP = csBP or csBPInst.info.bp
|
|
self.m_bpAbnormalIconHelper = bpAbnormalIconHelper
|
|
self.isSharing = isSharing
|
|
|
|
self:Refresh()
|
|
self:_ToggleChangeIcon(false, true)
|
|
if self.m_csBPInst then
|
|
self:_InitShare()
|
|
end
|
|
self:_DisableAllInputField()
|
|
if DeviceInfo.usingController then
|
|
self:_InitController()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._InitController = HL.Method() << function(self)
|
|
|
|
self.view.content.onDefaultNaviFailed:RemoveAllListeners()
|
|
self.view.content.onDefaultNaviFailed:AddListener(function(dir)
|
|
self:_FindTechAndDevice(dir)
|
|
end)
|
|
|
|
|
|
InputManagerInst:ChangeParent(true, self.view.techTipsNode.inputBindingGroupMonoTarget.groupId, self.view.contentInputBindingGroupMonoTarget.groupId)
|
|
|
|
|
|
self.view.content.onIsFocusedChange:RemoveAllListeners()
|
|
self.view.content.onIsFocusedChange:AddListener(function(isFocused)
|
|
if isFocused then
|
|
if #self.m_deviceInfos == 0 and #self.m_lackTechIdInfos == 0 then
|
|
Notify(MessageConst.SHOW_TOAST,Language.LUA_FAC_BLUEPRINT_NO_DETAIL_INFO)
|
|
self.view.content:ManuallyStopFocus()
|
|
elseif #self.m_lackTechIdInfos == 0 then
|
|
else
|
|
self.m_techCells:Refresh(#self.m_lackTechIdInfos, function(cell, index)
|
|
if index == 1 then
|
|
UIUtils.setAsNaviTarget(cell.button)
|
|
end
|
|
end)
|
|
end
|
|
else
|
|
self:_CloseTechTips()
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
end
|
|
end)
|
|
|
|
|
|
self:SetActiveControllerNode(FacConst.FocusStateTable.UnFocused)
|
|
self.view.topContainer.onIsFocusedChange:RemoveAllListeners()
|
|
self.view.topContainer.onIsFocusedChange:AddListener(function(isFocused)
|
|
self:_DisableAllInputField()
|
|
self:SetActiveControllerNode(isFocused and FacConst.FocusStateTable.Focused or FacConst.FocusStateTable.UnFocused)
|
|
if not isFocused then
|
|
return
|
|
end
|
|
if self.isEditing then
|
|
UIUtils.setAsNaviTarget(self.view.changeIconBtn)
|
|
elseif self.view.rightActions.previewBtn.gameObject.activeInHierarchy then
|
|
UIUtils.setAsNaviTarget(self.view.rightActions.previewBtn)
|
|
elseif self.view.rightActions.editBtn.gameObject.activeInHierarchy then
|
|
UIUtils.setAsNaviTarget(self.view.rightActions.editBtn)
|
|
end
|
|
end)
|
|
|
|
|
|
self:_InitControllerTopContainer()
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent.SetActiveControllerNode = HL.Method(HL.Number) << function(self, state)
|
|
local isOtherPeopleGift = FactoryUtils.isOtherPeopleGiftBlueprint(self.m_csBPInst)
|
|
self.view.rightActions.controllerNode:SetState(isOtherPeopleGift and "Three" or "Two")
|
|
self.view.rightActions.controllerNodeNotFocused:SetState(isOtherPeopleGift and "Three" or "Two")
|
|
if self.isEditing then
|
|
self.view.saveBlueControllerNode.gameObject:SetActive(state == FacConst.FocusStateTable.Focused)
|
|
self.view.saveBlueControllerNodeNotFocused.gameObject:SetActive(state == FacConst.FocusStateTable.UnFocused)
|
|
else
|
|
self.view.rightActions.controllerNode.gameObject:SetActive(state == FacConst.FocusStateTable.Focused)
|
|
self.view.rightActions.controllerNodeNotFocused.gameObject:SetActive(state == FacConst.FocusStateTable.UnFocused)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._DisableAllInputField = HL.Method() << function(self)
|
|
self.view.nameInputFieldEditBgImage.gameObject:SetActive(false)
|
|
self.view.descEditBgImage.gameObject:SetActive(false)
|
|
InputManagerInst:ToggleBinding(self.view.nameInputField.activeInputBindingId, false)
|
|
InputManagerInst:ToggleBinding(self.view.descInputField.activeInputBindingId, false)
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._InitControllerTopContainer = HL.Method() << function(self)
|
|
self:_DisableAllInputField()
|
|
|
|
self.view.nameInputField.onIsNaviTargetChanged = function(isTarget)
|
|
InputManagerInst:ToggleBinding(self.view.nameInputField.activeInputBindingId, isTarget)
|
|
InputManagerInst:ToggleBinding(self.view.descInputField.activeInputBindingId, not isTarget)
|
|
end
|
|
self.view.nameInputField.onFocused:AddListener(function(_)
|
|
self.view.nameInputFieldEditBgImage.gameObject:SetActive(true)
|
|
end)
|
|
self.view.nameInputField.onEndEdit:AddListener(function(_)
|
|
self.view.nameInputFieldEditBgImage.gameObject:SetActive(false)
|
|
end)
|
|
|
|
|
|
self.view.descInputFieldLightImage.gameObject:SetActive(false)
|
|
self.view.descInputField.onIsNaviTargetChanged = function(isTarget)
|
|
InputManagerInst:ToggleBinding(self.view.descInputField.activeInputBindingId, isTarget)
|
|
InputManagerInst:ToggleBinding(self.view.nameInputField.activeInputBindingId, not isTarget)
|
|
end
|
|
self.view.descInputField.onFocused:AddListener(function(_)
|
|
self.view.descEditBgImage.gameObject:SetActive(true)
|
|
end)
|
|
self.view.descInputField.onEndEdit:AddListener(function(_)
|
|
self.view.descEditBgImage.gameObject:SetActive(false)
|
|
end)
|
|
|
|
|
|
self.view.tagNode.button.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
self:_DisableAllInputField()
|
|
else
|
|
self.view.tagNode.inEditHint.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
|
|
self.view.changeIconBtn.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
self:_DisableAllInputField()
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent._FindTechAndDevice = HL.Method(HL.Any) << function(self, dir)
|
|
|
|
if not (dir == Unity.UI.NaviDirection.Left or dir == Unity.UI.NaviDirection.Right) then
|
|
return
|
|
end
|
|
|
|
|
|
local currentTarget = self.view.content.LayerSelectedTarget
|
|
local currentTargetIndex = -1
|
|
local currentTargetType = -1
|
|
self.m_techCells:Refresh(#self.m_lackTechIdInfos, function(cell, index)
|
|
if currentTarget == cell.button then
|
|
currentTargetIndex = index
|
|
currentTargetType = 1
|
|
end
|
|
end)
|
|
self.m_deviceCells:Refresh(#self.m_deviceInfos, function(cell, index)
|
|
if currentTarget == cell.item.view.button then
|
|
currentTargetIndex = index
|
|
currentTargetType = 2
|
|
end
|
|
end)
|
|
|
|
|
|
local futureTargetIndex = currentTargetIndex + ((dir == Unity.UI.NaviDirection.Right) and 1 or -1)
|
|
local futureTargetType = currentTargetType
|
|
if futureTargetType == 1 and futureTargetIndex > #self.m_lackTechIdInfos then
|
|
futureTargetIndex = 1
|
|
futureTargetType = 2
|
|
elseif futureTargetType == 2 and futureTargetIndex <= 0 then
|
|
futureTargetIndex = #self.m_lackTechIdInfos
|
|
futureTargetType = 1
|
|
end
|
|
|
|
|
|
if futureTargetType == 1 then
|
|
self.m_techCells:Refresh(#self.m_lackTechIdInfos, function(cell, index)
|
|
if index == futureTargetIndex then
|
|
UIUtils.setAsNaviTarget(cell.button)
|
|
end
|
|
end)
|
|
else
|
|
self.m_deviceCells:Refresh(#self.m_deviceInfos, function(cell, index)
|
|
if index == futureTargetIndex then
|
|
UIUtils.setAsNaviTarget(cell.item.view.button)
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent.ChangeIsEditing = HL.Method(HL.Boolean) << function(self, isEditing)
|
|
self.isEditing = isEditing
|
|
self.view.stateController:SetState(isEditing and "Edit" or "View")
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.Refresh = HL.Method() << function(self)
|
|
local deviceMap = {}
|
|
|
|
if self.m_csBPInst then
|
|
|
|
local bpInfo = self.m_csBPInst.info
|
|
|
|
|
|
local range = self.m_csBP.sourceRect
|
|
self.view.sizeTxt.text = string.format(Language.LUA_FAC_BLUEPRINT_RANGE_FORMAT_NUM_ONLY, range.width, range.height)
|
|
|
|
|
|
|
|
local hasAbnormal = false
|
|
local hasUnknowItem = false
|
|
local inBlackbox = Utils.isInBlackbox()
|
|
for _, entry in pairs(self.m_csBP.buildingNodes) do
|
|
local buildingId = entry.templateId
|
|
if Tables.factoryBuildingTable:ContainsKey(buildingId) then
|
|
if deviceMap[buildingId] then
|
|
deviceMap[buildingId] = deviceMap[buildingId] + 1
|
|
else
|
|
deviceMap[buildingId] = 1
|
|
end
|
|
else
|
|
|
|
deviceMap[buildingId] = 0
|
|
end
|
|
if not inBlackbox and not hasUnknowItem and not hasAbnormal and not string.isEmpty(entry.productIcon) then
|
|
if not GameInstance.player.inventory:IsItemFound(entry.productIcon) then
|
|
hasUnknowItem = true
|
|
hasAbnormal = true
|
|
else
|
|
hasAbnormal = self.m_bpAbnormalIconHelper and self.m_bpAbnormalIconHelper.IsAbnormal(buildingId, entry.productIcon)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
for _, entry in pairs(self.m_csBP.conveyorNodes) do
|
|
deviceMap[entry.templateId] = 0
|
|
end
|
|
|
|
|
|
self.curSelectedTags = {}
|
|
for _, tagId in pairs(bpInfo.tags) do
|
|
self.curSelectedTags[tagId] = true
|
|
end
|
|
self:_RefreshContentTagCells()
|
|
|
|
|
|
local t = self.m_csBPInst.sourceType
|
|
|
|
self.view.nameTxt.text = bpInfo.name
|
|
self.view.nameInputField.text = bpInfo.name
|
|
|
|
local hideDesc = (t == CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintSourceType.Gift and GameInstance.player.friendSystem.isCommunicationRestricted) or
|
|
GameInstance.player.friendSystem:PlayerInBlackList(self.m_csBPInst.creatorRoleId)
|
|
local desc = hideDesc and "" or bpInfo.desc
|
|
if FactoryUtils.isPlayerBP(self.m_csBPInst) then
|
|
self.view.descTxt.richText = false
|
|
self.view.descTxt.text = desc
|
|
self.view.descInputField.text = desc
|
|
else
|
|
self.view.descTxt.richText = true
|
|
self.view.descTxt:SetAndResolveTextStyle(desc)
|
|
end
|
|
self:_OnChangeIcon(bpInfo.icon.icon, bpInfo.icon.baseColor)
|
|
|
|
FactoryUtils.SetCreatorName(self, false, self.m_csBPInst)
|
|
self:_RefreshLackTech()
|
|
|
|
self.view.lackWarnNode.gameObject:SetActive(hasAbnormal)
|
|
if hasAbnormal then
|
|
self.view.lackWarnTxt.text = hasUnknowItem and Language.LUA_FAC_BLUEPRINT_LACK_ITEM or Language.LUA_FAC_BLUEPRINT_LACK_FORMULA
|
|
end
|
|
else
|
|
|
|
local batchSelect = GameInstance.remoteFactoryManager.batchSelect
|
|
local range = batchSelect.selectedRange
|
|
|
|
|
|
local needReverse = lume.round(LuaSystemManager.factory.topViewCamTarget.eulerAngles.y) % 180 ~= 0
|
|
self.view.sizeTxt.text = string.format(Language.LUA_FAC_BLUEPRINT_RANGE_FORMAT_NUM_ONLY, needReverse and range.height or range.width, needReverse and range.width or range.height)
|
|
|
|
|
|
self:_OnChangeIcon(FacConst.FAC_BLUEPRINT_DEFAULT_ICON, FacConst.BLUEPRINT_DEFAULT_ICON_BG_COLOR_ID)
|
|
|
|
|
|
local targets = LuaSystemManager.factory.batchSelectTargets
|
|
for nodeId, _ in pairs(targets) do
|
|
local node = FactoryUtils.getBuildingNodeHandler(nodeId)
|
|
local buildingId = node.templateId
|
|
if Tables.factoryBuildingTable:ContainsKey(buildingId) then
|
|
if deviceMap[buildingId] then
|
|
deviceMap[buildingId] = deviceMap[buildingId] + 1
|
|
else
|
|
deviceMap[buildingId] = 1
|
|
end
|
|
else
|
|
deviceMap[buildingId] = 0
|
|
end
|
|
end
|
|
|
|
|
|
self.curSelectedTags = {}
|
|
self:_RefreshContentTagCells()
|
|
|
|
|
|
self.view.creatorNode.gameObject:SetActive(false)
|
|
|
|
self.view.lackInfoNode.gameObject:SetActive(false)
|
|
self.haveLackTechs = false
|
|
|
|
self.view.lackWarnNode.gameObject:SetActive(false)
|
|
end
|
|
|
|
|
|
self.m_deviceInfos = {}
|
|
local sortByIsEnough = self.view.config.SORT_BY_IS_ENOUGH
|
|
for templateId, count in pairs(deviceMap) do
|
|
local itemId
|
|
if count == 0 then
|
|
if templateId == FacConst.BELT_ID then
|
|
itemId = FacConst.BELT_ITEM_ID
|
|
elseif templateId == FacConst.PIPE_ID then
|
|
itemId = FacConst.PIPE_ITEM_ID
|
|
else
|
|
local data = FactoryUtils.getLogisticData(templateId)
|
|
itemId = data.itemId
|
|
end
|
|
else
|
|
itemId = FactoryUtils.getBuildingItemId(templateId)
|
|
end
|
|
if itemId then
|
|
local itemData = Tables.itemTable[itemId]
|
|
local info = {
|
|
buildingId = templateId,
|
|
id = itemData.id,
|
|
sortId1 = itemData.sortId1,
|
|
sortId2 = itemData.sortId2,
|
|
}
|
|
if count > 0 then
|
|
info.count = count
|
|
end
|
|
if sortByIsEnough then
|
|
local isEnough = count <= 0 or Utils.getItemCount(info.id, true, true) >= count
|
|
info.isEnoughOrder = isEnough and 0 or 1
|
|
end
|
|
table.insert(self.m_deviceInfos, info)
|
|
end
|
|
end
|
|
if sortByIsEnough then
|
|
table.sort(self.m_deviceInfos, Utils.genSortFunction({ "isEnoughOrder", "sortId1", "sortId2", "id", "customSortId" }))
|
|
else
|
|
table.sort(self.m_deviceInfos, Utils.genSortFunction(UIConst.COMMON_ITEM_SORT_KEYS))
|
|
end
|
|
|
|
self.m_deviceCells:Refresh(#self.m_deviceInfos, function(cell, index)
|
|
self:_OnUpdateCell(cell, index)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._OnUpdateCell = HL.Method(HL.Table, HL.Number) << function(self, cell, index)
|
|
if self.isSharing then
|
|
if index == self.m_deviceCellMaxNumber and #self.m_deviceInfos - self.m_deviceCellMaxNumber > 0 then
|
|
cell.countNode.gameObject:SetActive(false)
|
|
cell.item.gameObject:SetActive(false)
|
|
cell.deviceCountTxt.text = #self.m_deviceInfos - self.m_deviceCellMaxNumber + 1
|
|
cell.moreDeviceCell.gameObject:SetActive(true)
|
|
return
|
|
elseif index > self.m_deviceCellMaxNumber then
|
|
cell.gameObject:SetActive(false)
|
|
return
|
|
end
|
|
end
|
|
|
|
local info = self.m_deviceInfos[index]
|
|
cell.item:InitItem(info, true)
|
|
self:_UpdateCellCount(cell, index)
|
|
|
|
if DeviceInfo.usingController then
|
|
cell.item:SetExtraInfo({
|
|
tipsPosType = UIConst.UI_TIPS_POS_TYPE.LeftMid,
|
|
tipsPosTransform = self.view.content.transform,
|
|
isSideTips = true,
|
|
})
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._UpdateCellCount = HL.Method(HL.Table, HL.Number) << function(self, cell, index)
|
|
local info = self.m_deviceInfos[index]
|
|
if self.view.config.SHOW_OWN_COUNT and info.count then
|
|
local count = Utils.getItemCount(info.id, true, true)
|
|
local isEnough = count >= info.count
|
|
cell.countTxt.text = UIUtils.setCountColor(count, not isEnough)
|
|
cell.countNode.gameObject:SetActive(true)
|
|
else
|
|
cell.countNode.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.UpdateCount = HL.Method() << function(self)
|
|
if not self.m_deviceCells then
|
|
return
|
|
end
|
|
self.m_deviceCells:Update(function(cell, index)
|
|
self:_UpdateCellCount(cell, index)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent.GetFirstLackItemIdAndCount = HL.Method().Return(HL.Opt(HL.String, HL.Number)) << function(self)
|
|
for _, info in ipairs(self.m_deviceInfos) do
|
|
if info.count then
|
|
local count = Utils.getItemCount(info.id, true, true)
|
|
if count < info.count then
|
|
return info.id, info.count - count
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.GetAllDeviceIdAndCount = HL.Method().Return(HL.Table) << function(self)
|
|
local ret = {}
|
|
for _, info in ipairs(self.m_deviceInfos) do
|
|
if info.count then
|
|
local isEnough = info.count <= 0 or Utils.getItemCount(info.id, true, true) >= info.count
|
|
if not isEnough then
|
|
table.insert(ret, {
|
|
id = info.buildingId,
|
|
count = info.count
|
|
})
|
|
end
|
|
end
|
|
end
|
|
return ret
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent.m_tagGroupCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
BlueprintContent.m_tagCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
BlueprintContent.curSelectedTags = HL.Field(HL.Table)
|
|
|
|
|
|
BlueprintContent.m_tagGroupInfos = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
|
|
BlueprintContent._InitTag = HL.Method() << function(self)
|
|
self.view.tagNode.editBtn.onClick:AddListener(function()
|
|
self:_OnClickEditTag()
|
|
end)
|
|
if DeviceInfo.usingController then
|
|
self.view.tagNode.button.onClick:AddListener(function()
|
|
self:_OnClickEditTag()
|
|
end)
|
|
end
|
|
self.view.selectTagNode.autoCloseArea.onTriggerAutoClose:AddListener(function()
|
|
self:_ToggleSelectTag(false)
|
|
end)
|
|
self:_ToggleSelectTag(false)
|
|
self.m_tagCells = UIUtils.genCellCache(self.view.tagNode.tagCell)
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._OnClickEditTag = HL.Method() << function(self)
|
|
if self.view.selectTagNode.gameObject.activeInHierarchy then
|
|
self:_ToggleSelectTag(false)
|
|
else
|
|
self:_ToggleSelectTag(true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._ToggleSelectTag = HL.Method(HL.Boolean, HL.Opt(HL.Boolean)) << function(self, active, skipAni)
|
|
local node = self.view.selectTagNode
|
|
if not skipAni and not active then
|
|
if node.animationWrapper.curState == CS.Beyond.UI.UIConst.AnimationState.Out then
|
|
|
|
return
|
|
end
|
|
end
|
|
if active then
|
|
self:_ToggleChangeIcon(false, true)
|
|
if not self.m_tagGroupCells then
|
|
self.m_tagGroupCells = UIUtils.genCellCache(node.tagGroupCell)
|
|
self.m_tagGroupInfos = FactoryUtils.getBlueprintTagGroupInfos()
|
|
end
|
|
self.m_tagGroupCells:Refresh(#self.m_tagGroupInfos, function(groupCell, index)
|
|
local groupInfo = self.m_tagGroupInfos[index]
|
|
groupCell.nameTxt.text = groupInfo.title
|
|
if not groupCell.m_tagCells then
|
|
groupCell.m_tagCells = UIUtils.genCellCache(groupCell.tagCell)
|
|
end
|
|
groupCell.m_tagCells:Refresh(#groupInfo.tags, function(tagCell, tagIndex)
|
|
local tagInfo = groupInfo.tags[tagIndex]
|
|
tagCell.nameTxt.text = tagInfo.name
|
|
tagCell.button.onClick:RemoveAllListeners()
|
|
tagCell.button.onClick:AddListener(function()
|
|
self:_OnClickTagCell(tagInfo, tagCell, groupCell)
|
|
end)
|
|
tagCell.stateController:SetState(self.curSelectedTags[tagInfo.id] and "Selected" or "Unselected")
|
|
tagCell.button.hintTextId = self.curSelectedTags[tagInfo.id] and "key_hint_common_unselect" or "key_hint_common_select"
|
|
Notify(MessageConst.REFRESH_CONTROLLER_HINT)
|
|
tagCell.button.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
tagCell.button.hintTextId = self.curSelectedTags[tagInfo.id] and "key_hint_common_unselect" or "key_hint_common_select"
|
|
Notify(MessageConst.REFRESH_CONTROLLER_HINT)
|
|
end
|
|
end
|
|
end)
|
|
end)
|
|
|
|
local curCount = lume.count(self.curSelectedTags)
|
|
local maxCount = Tables.facBlueprintConst.BluePrintTagNumMax
|
|
node.countTxt.text = string.format("%s/%d", UIUtils.setCountColor(curCount, curCount >= maxCount), maxCount)
|
|
end
|
|
if skipAni then
|
|
node.animationWrapper:ClearTween(false)
|
|
node.gameObject:SetActive(active)
|
|
else
|
|
UIUtils.PlayAnimationAndToggleActive(node.animationWrapper, active)
|
|
end
|
|
self.view.tagNode.inEditHint.gameObject:SetActive(active)
|
|
if active and DeviceInfo.usingController then
|
|
node.contentSelectableNaviGroup:ManuallyFocus()
|
|
node.contentSelectableNaviGroup.onIsFocusedChange:RemoveAllListeners()
|
|
node.contentSelectableNaviGroup.onIsFocusedChange:AddListener(function(isFocused)
|
|
if not isFocused then
|
|
self:_ToggleSelectTag(false)
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._OnClickTagCell = HL.Method(HL.Table, HL.Table, HL.Table) << function(self, tagInfo, tagCell, groupCell)
|
|
local newValue = not self.curSelectedTags[tagInfo.id]
|
|
local curCount
|
|
local maxCount = Tables.facBlueprintConst.BluePrintTagNumMax
|
|
if newValue then
|
|
|
|
local typeData = Tables.factoryBlueprintTagTypeTable[tagInfo.type]
|
|
if not typeData.allowMultiSelect then
|
|
|
|
local sameTypeTagId
|
|
for otherId, _ in pairs(self.curSelectedTags) do
|
|
local data = Tables.factoryBlueprintTagTable[otherId]
|
|
if data.type == tagInfo.type then
|
|
sameTypeTagId = otherId
|
|
break
|
|
end
|
|
end
|
|
if sameTypeTagId then
|
|
self.curSelectedTags[sameTypeTagId] = nil
|
|
groupCell.m_tagCells:Update(function(cell, index)
|
|
if cell ~= tagCell then
|
|
cell.stateController:SetState("Unselected")
|
|
cell.button.hintTextId = "key_hint_common_select"
|
|
Notify(MessageConst.REFRESH_CONTROLLER_HINT)
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
curCount = lume.count(self.curSelectedTags)
|
|
if curCount == maxCount then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_FAC_BLUEPRINT_MAX_TAG)
|
|
return
|
|
end
|
|
|
|
self.curSelectedTags[tagInfo.id] = newValue
|
|
curCount = curCount + 1
|
|
else
|
|
self.curSelectedTags[tagInfo.id] = nil
|
|
curCount = lume.count(self.curSelectedTags)
|
|
end
|
|
self.view.selectTagNode.countTxt.text = string.format("%s/%d", UIUtils.setCountColor(curCount, curCount >= maxCount), maxCount)
|
|
tagCell.stateController:SetState(newValue and "Selected" or "Unselected")
|
|
tagCell.button.hintTextId = self.curSelectedTags[tagInfo.id] and "key_hint_common_unselect" or "key_hint_common_select"
|
|
Notify(MessageConst.REFRESH_CONTROLLER_HINT)
|
|
self:_RefreshContentTagCells()
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._RefreshContentTagCells = HL.Method() << function(self)
|
|
local tagList = {}
|
|
for id, _ in pairs(self.curSelectedTags) do
|
|
local data = Tables.factoryBlueprintTagTable[id]
|
|
table.insert(tagList, {
|
|
id = id,
|
|
data = data,
|
|
sortId = data.sortId,
|
|
})
|
|
end
|
|
table.sort(tagList, Utils.genSortFunction({ "sortId", "id" }))
|
|
local count = #tagList
|
|
if count == 0 then
|
|
self.m_tagCells:Refresh(0)
|
|
self.view.tagNode.addBtn.gameObject:SetActive(self.isEditing)
|
|
self.view.tagNode.emptyNode.gameObject:SetActive(not self.isEditing)
|
|
self.view.tagNode.changeHint.gameObject:SetActive(false)
|
|
else
|
|
self.m_tagCells:Refresh(count, function(cell, index)
|
|
local info = tagList[index]
|
|
cell.nameTxt.text = info.data.name
|
|
end)
|
|
self.view.tagNode.addBtn.gameObject:SetActive(false)
|
|
self.view.tagNode.emptyNode.gameObject:SetActive(false)
|
|
self.view.tagNode.changeHint.gameObject:SetActive(self.isEditing)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.GetSortedTagIds = HL.Method().Return(HL.Table) << function(self)
|
|
local tagList = {}
|
|
for id, _ in pairs(self.curSelectedTags) do
|
|
table.insert(tagList, id)
|
|
end
|
|
table.sort(tagList)
|
|
return tagList
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._ToggleChangeIcon = HL.Method(HL.Boolean, HL.Opt(HL.Boolean)) << function(self, active, skipAni)
|
|
local node = self.view.changeIconNode
|
|
if not skipAni and not active then
|
|
if node.view.animationWrapper.curState == CS.Beyond.UI.UIConst.AnimationState.Out then
|
|
|
|
return
|
|
end
|
|
end
|
|
if active then
|
|
if not node.m_csBP then
|
|
node:InitBlueprintChangeIconNode(self.m_csBP, self.curIcon, self.curColorId, function(iconId, colorId)
|
|
self:_OnChangeIcon(iconId, colorId)
|
|
end)
|
|
end
|
|
end
|
|
|
|
if skipAni then
|
|
node.view.animationWrapper:ClearTween(false)
|
|
node.gameObject:SetActive(active)
|
|
else
|
|
UIUtils.PlayAnimationAndToggleActive(node.view.animationWrapper, active)
|
|
end
|
|
|
|
if active then
|
|
self:_ToggleSelectTag(false, true)
|
|
end
|
|
|
|
if active and DeviceInfo.usingController then
|
|
node:RefreshController()
|
|
node.view.changeIconNodeMain.onIsFocusedChange:RemoveAllListeners()
|
|
node.view.changeIconNodeMain.onIsFocusedChange:AddListener(function(isFocused)
|
|
if not isFocused then
|
|
self:_ToggleChangeIcon(false)
|
|
self.view.inChangeIconHint.gameObject:SetActive(false)
|
|
end
|
|
end)
|
|
end
|
|
self.view.inChangeIconHint.gameObject:SetActive(active)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._OnChangeIcon = HL.Method(HL.String, HL.Number) << function(self, iconId, colorId)
|
|
self.curIcon = iconId
|
|
self.curColorId = colorId
|
|
self.view.blueprintIcon:InitBlueprintIcon(iconId, colorId)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent.m_lackTechIdInfos = HL.Field(HL.Table)
|
|
|
|
|
|
BlueprintContent.m_techCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
BlueprintContent.haveLackTechs = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
BlueprintContent._InitLackTechIdInfos = HL.Method() << function(self)
|
|
local lockedTechIds
|
|
if Utils.isInBlackbox() then
|
|
lockedTechIds = {}
|
|
else
|
|
lockedTechIds = GameInstance.player.remoteFactory.blueprint:GetLockedTechIdsInBlueprint(self.m_csBP)
|
|
end
|
|
local infoMap = {}
|
|
local techSys = GameInstance.player.facTechTreeSystem
|
|
for _, techId in pairs(lockedTechIds) do
|
|
if techSys:NodeIsHidden(techId) then
|
|
|
|
if not infoMap[hiddenTechId] then
|
|
infoMap[hiddenTechId] = {
|
|
icon = "icon_industrial_plan_unknown_node",
|
|
name = Language.LUA_FAC_BLUEPRINT_HIDDEN_TECH_NAME,
|
|
desc = Language.LUA_FAC_BLUEPRINT_HIDDEN_TECH_DESC,
|
|
sortId1 = 3,
|
|
}
|
|
end
|
|
else
|
|
local techData = Tables.facSTTNodeTable[techId]
|
|
if techSys:PackageIsLocked(techData.groupId) then
|
|
|
|
if not infoMap[techData.groupId] then
|
|
local data = Tables.facSTTGroupTable[techData.groupId]
|
|
infoMap[techData.groupId] = {
|
|
id = techData.groupId,
|
|
isGroup = true,
|
|
icon = data.icon,
|
|
name = data.groupName,
|
|
desc = data.desc,
|
|
sortId1 = 2,
|
|
sortId2 = techData.groupId,
|
|
}
|
|
end
|
|
elseif techSys:LayerIsLocked(techData.layer) then
|
|
|
|
if not infoMap[techData.layer] then
|
|
local data = Tables.facSTTLayerTable[techData.layer]
|
|
infoMap[techData.layer] = {
|
|
id = techData.layer,
|
|
groupId = techData.groupId,
|
|
layerId = techData.layer,
|
|
isLayer = true,
|
|
icon = data.icon,
|
|
name = data.name,
|
|
desc = data.desc,
|
|
sortId1 = 1,
|
|
sortId2 = data.order,
|
|
}
|
|
end
|
|
else
|
|
|
|
if not infoMap[techId] then
|
|
infoMap[techId] = {
|
|
id = techId,
|
|
icon = techData.icon,
|
|
name = techData.name,
|
|
desc = techData.desc,
|
|
sortId1 = 0,
|
|
sortId2 = techData.sortId,
|
|
}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self.m_lackTechIdInfos = {}
|
|
for _, v in pairs(infoMap) do
|
|
table.insert(self.m_lackTechIdInfos, v)
|
|
end
|
|
table.sort(self.m_lackTechIdInfos, Utils.genSortFunction({ "sortId1", "sortId2", "id" }, true))
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._RefreshLackTech = HL.Method() << function(self)
|
|
self:_InitLackTechIdInfos()
|
|
if not self.m_techCells then
|
|
self:_InitLackTechNode()
|
|
end
|
|
local count = #self.m_lackTechIdInfos
|
|
if count > 0 then
|
|
self.haveLackTechs = true
|
|
self.m_techCells:Refresh(count, function(cell, index)
|
|
cell.button.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
self:_OnClickTechCell(index)
|
|
else
|
|
cell.selectedBG.gameObject:SetActive(false)
|
|
self:_CloseTechTips()
|
|
end
|
|
end
|
|
local info = self.m_lackTechIdInfos[index]
|
|
cell.button.onClick:RemoveAllListeners()
|
|
cell.button.onClick:AddListener(function()
|
|
if cell.selectedBG.gameObject.activeSelf then
|
|
self:_CloseTechTips()
|
|
else
|
|
self:_OnClickTechCell(index)
|
|
end
|
|
end)
|
|
cell.icon:LoadSprite(UIConst.UI_SPRITE_FAC_TECH_ICON, info.icon)
|
|
cell.selectedBG.gameObject:SetActive(false)
|
|
end)
|
|
if self.isSharing then
|
|
self.view.lackInfoNode.gameObject:SetActive(false)
|
|
else
|
|
self.view.lackInfoNode.gameObject:SetActive(true)
|
|
end
|
|
else
|
|
self.haveLackTechs = false
|
|
self.view.lackInfoNode.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._InitLackTechNode = HL.Method() << function(self)
|
|
self.m_techCells = UIUtils.genCellCache(self.view.lackInfoCell)
|
|
|
|
local tipsNode = self.view.techTipsNode
|
|
tipsNode.gameObject:SetActive(false)
|
|
tipsNode.transform:SetParent(self:GetUICtrl().view.transform)
|
|
tipsNode.autoCloseArea.onTriggerAutoClose:AddListener(function()
|
|
self:_CloseTechTips()
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent._CloseTechTips = HL.Method(HL.Opt(HL.Boolean)) << function(self, skipAni)
|
|
if skipAni then
|
|
self.view.techTipsNode.animationWrapper:ClearTween(false)
|
|
self.view.techTipsNode.gameObject:SetActive(false)
|
|
else
|
|
UIUtils.PlayAnimationAndToggleActive(self.view.techTipsNode.animationWrapper, false)
|
|
end
|
|
self.m_techCells:Update(function(cell)
|
|
cell.selectedBG.gameObject:SetActive(false)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent._OnClickTechCell = HL.Method(HL.Number) << function(self, index)
|
|
if index > #self.m_lackTechIdInfos then
|
|
self.view.content:ManuallyStopFocus()
|
|
return
|
|
end
|
|
local tipsNode = self.view.techTipsNode
|
|
local info = self.m_lackTechIdInfos[index]
|
|
|
|
tipsNode.titleTxt.text = info.name
|
|
tipsNode.descTxt.text = info.name
|
|
tipsNode.iconImg:LoadSprite(UIConst.UI_SPRITE_FAC_TECH_ICON, info.icon .. "_big")
|
|
|
|
local lockedText
|
|
tipsNode.jumpBtn.onClick:RemoveAllListeners()
|
|
if not info.id then
|
|
|
|
lockedText = Language.LUA_FAC_BLUEPRINT_HIDDEN_TECH_LOCKED_HINT
|
|
elseif info.isGroup then
|
|
|
|
lockedText = string.format(Language.LUA_FAC_BLUEPRINT_TECH_PACKAGE_LOCKED_HINT, info.name)
|
|
elseif info.isLayer then
|
|
|
|
tipsNode.jumpBtn.onClick:AddListener(function()
|
|
PhaseManager:OpenPhase(PhaseId.FacTechTree, { layerId = info.layerId })
|
|
end)
|
|
else
|
|
|
|
tipsNode.jumpBtn.onClick:AddListener(function()
|
|
PhaseManager:OpenPhase(PhaseId.FacTechTree, { techId = info.id })
|
|
end)
|
|
end
|
|
if lockedText then
|
|
tipsNode.lockedNode.gameObject:SetActive(true)
|
|
tipsNode.jumpNode.gameObject:SetActive(false)
|
|
tipsNode.lockedTxt.text = lockedText
|
|
else
|
|
tipsNode.lockedNode.gameObject:SetActive(false)
|
|
tipsNode.jumpNode.gameObject:SetActive(true)
|
|
end
|
|
|
|
UIUtils.PlayAnimationAndToggleActive(tipsNode.animationWrapper, true)
|
|
|
|
local curCell
|
|
self.m_techCells:Update(function(cell, k)
|
|
if k == index then
|
|
cell.selectedBG.gameObject:SetActive(true)
|
|
curCell = cell
|
|
else
|
|
cell.selectedBG.gameObject:SetActive(false)
|
|
end
|
|
end)
|
|
tipsNode.autoCloseArea.tmpSafeArea = curCell.transform
|
|
|
|
local panelCtrl = self:GetUICtrl()
|
|
UIUtils.updateTipsPosition(tipsNode.transform, curCell.transform, panelCtrl.view.transform, panelCtrl.uiCamera, UIConst.UI_TIPS_POS_TYPE.LeftTop)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BlueprintContent._InitShare = HL.Method() << function(self)
|
|
self.view.deviceCell.moreDeviceCell.gameObject:SetActive(false)
|
|
|
|
local isOtherPeopleGift = FactoryUtils.isOtherPeopleGiftBlueprint(self.m_csBPInst)
|
|
self.view.rightActions.moreBtn.gameObject:SetActive(isOtherPeopleGift)
|
|
if isOtherPeopleGift then
|
|
self.view.rightActions.moreBtn.button.onClick:AddListener(function()
|
|
self:_SeeMoreInfo()
|
|
end)
|
|
end
|
|
self:_RefreshShareState()
|
|
end
|
|
|
|
|
|
|
|
|
|
BlueprintContent._SeeMoreInfo = HL.Method(HL.Opt(HL.Any)) << function(self,arg)
|
|
local onClose
|
|
if arg and arg.onClose then
|
|
onClose = arg.onClose
|
|
end
|
|
if not UIManager:IsOpen(PanelId.BlueprintShareBlackScreen) then
|
|
UIManager:Open(PanelId.BlueprintShareBlackScreen,{
|
|
csBPInst = self.m_csBPInst,
|
|
id = self.m_blueprintID,
|
|
tipsTransform = self.view.rightActions.moreBtn.rectTransform,
|
|
isReporting = true,
|
|
onClose = onClose,
|
|
deviceInfo = self.m_deviceInfos,
|
|
})
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._RefreshShareState = HL.Method() << function(self)
|
|
if Utils.isInBlackbox() then
|
|
self.view.rightActions.shareNode.gameObject:SetActive(false)
|
|
return
|
|
end
|
|
|
|
local reviewStatus = self.m_csBPInst.reviewStatus
|
|
local sourceType = self.m_csBPInst.sourceType
|
|
if sourceType == CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintSourceType.Gift or sourceType == CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintSourceType.Sys then
|
|
reviewStatus = CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintReviewStatus.Approved
|
|
end
|
|
self.view.rightActions.shareNode.shareBtn.onClick:RemoveAllListeners()
|
|
self.view.rightActions.shareNode.shareBtn.gameObject:SetActive(true)
|
|
|
|
if reviewStatus == CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintReviewStatus.Approved then
|
|
self.view.rightActions.shareNode.stateController:SetState("CanShare")
|
|
self.view.rightActions.shareNode.shareBtn.onClick:AddListener(function()
|
|
UIManager:Open(PanelId.BlueprintShareBlackScreen,{
|
|
csBPInst = self.m_csBPInst,
|
|
id = self.m_blueprintID,
|
|
tipsTransform = self.view.rightActions.shareNode.canShareNode,
|
|
isReporting = false,
|
|
deviceInfo = self.m_deviceInfos,
|
|
})
|
|
end)
|
|
elseif reviewStatus == CS.Beyond.Gameplay.RemoteFactory.RemoteFactoryBlueprintReviewStatus.InProgress then
|
|
self.view.rightActions.shareNode.stateController:SetState("InAudit")
|
|
self.view.rightActions.shareNode.shareBtn.onClick:AddListener(function()
|
|
Notify(MessageConst.SHOW_TOAST,Language.LUA_FAC_BLUEPRINT_PENDING_CANT_SHARE)
|
|
end)
|
|
else
|
|
self.view.rightActions.shareNode.stateController:SetState("NeedSubmit")
|
|
self.view.rightActions.shareNode.shareBtn.onClick:AddListener(function()
|
|
self:_PendingShare()
|
|
end)
|
|
end
|
|
|
|
if GameInstance.player.remoteFactory.blueprint.forbidShare or GameInstance.player.friendSystem.isCommunicationRestricted then
|
|
self.view.rightActions.shareNode.shareBtn.onClick:RemoveAllListeners()
|
|
self.view.rightActions.shareNode.shareBtn.onClick:AddListener(function()
|
|
Notify(MessageConst.SHOW_TOAST,Language.LUA_BLUEPRINT_BAN_SHARE)
|
|
end)
|
|
return
|
|
end
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent._PendingShare = HL.Method() << function(self)
|
|
self.view.topContainer:ManuallyStopFocus()
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = Language.LUA_FAC_BLUEPRINT_REVIEW_POPUP,
|
|
warningContent = Language.LUA_FAC_BLUEPRINT_REVIEW_POPUP_WARNING,
|
|
onConfirm = function()
|
|
UIManager:Close(PanelId.BlueprintShareBlackScreen)
|
|
UIManager:Close(PanelId.CommonPopUp)
|
|
local alreadyReadStatement = ClientDataManagerInst:GetBool(BLUEPRINT_SHARE_STATEMENT_KEY,false)
|
|
if not alreadyReadStatement then
|
|
UIManager:Open(PanelId.InstructionBook, {
|
|
id = "fac_blueprint_statement",
|
|
})
|
|
ClientDataManagerInst:SetBool(BLUEPRINT_SHARE_STATEMENT_KEY, true, false, EClientDataTimeValidType.Permanent)
|
|
end
|
|
Notify(MessageConst.SHOW_TOAST,Language.LUA_FAC_BLUEPRINT_SHARE_STATEMENT_TIP)
|
|
GameInstance.player.remoteFactory.blueprint:SendReviewBlueprint(self.m_blueprintID)
|
|
end,
|
|
onCancel = function()
|
|
UIManager:Close(PanelId.BlueprintShareBlackScreen)
|
|
end
|
|
})
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.FacOnReviewBlueprint = HL.Method() << function(self)
|
|
self:_RefreshShareState()
|
|
Notify(MessageConst.FAC_ON_REFRESH_SHARE_STATE, { isInProgress = true })
|
|
end
|
|
|
|
|
|
|
|
BlueprintContent.SetFriendShareState = HL.Method() << function(self)
|
|
self.view.rightActions.moreBtn.gameObject:SetActive(false)
|
|
self.view.rightActions.buttonNode.gameObject:SetActive(false)
|
|
self.view.rightActions.shareNode.shareBtn.gameObject:SetActive(false)
|
|
self:SetActiveControllerNode(FacConst.FocusStateTable.None)
|
|
InputManagerInst:ToggleGroup(self.view.topBinding.groupId,false)
|
|
end
|
|
|
|
|
|
|
|
HL.Commit(BlueprintContent)
|
|
return BlueprintContent
|