983 lines
31 KiB
Lua
983 lines
31 KiB
Lua
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.ManualCraftPopups
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl = HL.Class('ManualCraftPopupsCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_itemCellList = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_unlockItemList = HL.Field(HL.Table)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_unlockItemRewardMap = HL.Field(HL.Table)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_unlockItemIdCellMap = HL.Field(HL.Table)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_facManualCraftSystem = HL.Field(HL.Any)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_inventorySystem = HL.Field(HL.Any)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_selectIndex = HL.Field(HL.Number) << 0
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_previewIndex = HL.Field(HL.Number) << 0
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_previewItemId = HL.Field(HL.Any) << nil
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_showTipsBindingId = HL.Field(HL.Number) << -1
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_rewardCellList = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_previewCellList = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_getDefaultCell = HL.Field(HL.Function)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_getSelectCell = HL.Field(HL.Function)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_needRefreshReward = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_sortMode = HL.Field(HL.Number) << 1
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_sortIncremental = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_activeScroll = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_jumpRewardFlag = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_initControllerSelected = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_bindSubCache = HL.Field(HL.Table)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_filterSetting = HL.Field(HL.Table)
|
|
|
|
|
|
ManualCraftPopupsCtrl.m_realData = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.ON_MANUAL_CRAFT_LEVEL_UP] = 'OnGetNewItemLevelUp',
|
|
[MessageConst.ON_MANUAL_CRAFT_GET_ITEM_REWARD] = 'OnGetReward',
|
|
[MessageConst.ON_GET_MANUAL_REWARD] = '_OnGetReward'
|
|
|
|
|
|
}
|
|
|
|
local sortOptions = {
|
|
{
|
|
|
|
name = Language.LUA_FAC_CRAFT_SORT_1,
|
|
sortMode = 1,
|
|
sortKeys = {"sortId1", "sortId2", "rarity", "id"},
|
|
},
|
|
{
|
|
|
|
name = Language.LUA_FAC_CRAFT_SORT_2,
|
|
sortMode = 2,
|
|
sortKeys = {"rarity","sortId1", "sortId2","id"},
|
|
},
|
|
}
|
|
|
|
local LUA_FIRST_INDEX = 1
|
|
local GATHER_MAP_VALID_COUNT = 1
|
|
local ShowRewardsType = {
|
|
RECEIVED = "RECEIVED",
|
|
AVAILABLE = "AVAILABLE",
|
|
NOT_AVAILABLE = "NOT_AVAILABLE",
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
|
|
|
|
self.view.selectPanel.gameObject:SetActive(false)
|
|
self.m_facManualCraftSystem = GameInstance.player.facManualCraft
|
|
self.m_inventorySystem = GameInstance.player.inventory
|
|
|
|
self.m_bindSubCache = {}
|
|
self.m_selectIndex = 0
|
|
self.m_unlockItemList = nil
|
|
self.m_unlockItemRewardMap = {}
|
|
self.m_unlockItemIdCellMap = {}
|
|
self.view.leftArrow.onClick:AddListener(function()
|
|
if self.m_selectIndex > 1 then
|
|
self.m_activeScroll = true
|
|
self.m_selectIndex = self.m_selectIndex - 1
|
|
AudioAdapter.PostEvent("Au_UI_Toggle_Tab_On")
|
|
self:_UpdateSelectView(false)
|
|
self.view.selectPanel:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):Play("manualcraftpopups_select_switch")
|
|
|
|
end
|
|
end)
|
|
|
|
self.view.rightArrow.onClick:AddListener(function()
|
|
if self.m_selectIndex < #self.m_unlockItemList then
|
|
self.m_activeScroll = true
|
|
self.m_selectIndex = self.m_selectIndex + 1
|
|
AudioAdapter.PostEvent("Au_UI_Toggle_Tab_On")
|
|
self:_UpdateSelectView(false)
|
|
self.view.selectPanel:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):Play("manualcraftpopups_select_switch")
|
|
|
|
end
|
|
end)
|
|
|
|
self.view.btnBack.onClick:AddListener(function()
|
|
if self.view.selectPanel.gameObject.activeSelf then
|
|
self:_UpdateDefaultView(self.m_needRefreshReward)
|
|
else
|
|
self:PlayAnimationOutAndClose()
|
|
end
|
|
end)
|
|
|
|
self.view.returnBtn.onClick:AddListener(function()
|
|
InputManagerInst.controllerNaviManager:SetTarget(nil)
|
|
self:_UpdateDefaultView(self.m_needRefreshReward)
|
|
end)
|
|
|
|
self.view.btnCommon.onClick:AddListener(function()
|
|
local nowLockData = self.m_unlockItemList[self.m_selectIndex]
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(nowLockData.itemId)
|
|
local list = CS.Beyond.Lua.UtilsForLua.GetStringList()
|
|
for i = 0, nowLockData.rewardList.Count - 1 do
|
|
local rewardId = nowLockData.rewardList[i]
|
|
local condition = nowLockData.unlockCondition[i]
|
|
local unlockId = nowLockData.unlockIdList[i]
|
|
local haveGet = self.m_facManualCraftSystem:CheckHaveGetReward(unlockId)
|
|
if nowCount >= condition and not haveGet then
|
|
list:Add(unlockId)
|
|
end
|
|
end
|
|
self.m_facManualCraftSystem:ReqManuallyUnlock(Utils.getCurrentScope(), list)
|
|
end)
|
|
|
|
self.m_getDefaultCell = UIUtils.genCachedCellFunction(self.view.itemList)
|
|
self.m_getSelectCell = UIUtils.genCachedCellFunction(self.view.previewScrollList)
|
|
|
|
self.view.itemList.onUpdateCell:AddListener(function(gameObject, index)
|
|
self:_UpdateDefaultCell((gameObject), index)
|
|
end)
|
|
|
|
self.view.previewScrollList.getCurSelectedIndex = function()
|
|
return CSIndex(self.m_previewIndex)
|
|
end
|
|
|
|
self.view.previewScrollList.onCellSelectedChanged:AddListener(function(obj, csIndex, isSelected)
|
|
self.m_previewIndex = LuaIndex(csIndex)
|
|
end)
|
|
|
|
|
|
self.view.previewScrollList.onUpdateCell:AddListener(function(gameObject, index)
|
|
self:_UpdateSelectCell((gameObject), index)
|
|
end)
|
|
|
|
self.view.previewScrollList:SetPaddingRight(self.view.previewScrollList.gameObject:GetComponent(typeof(CS.UnityEngine.RectTransform)).rect.width / 2 - 200)
|
|
self.view.previewScrollList:SetPaddingLeft(self.view.previewScrollList.gameObject:GetComponent(typeof(CS.UnityEngine.RectTransform)).rect.width / 2 - 200)
|
|
|
|
|
|
self.view.previewScrollList.onSelectedCell:AddListener(function(object, index)
|
|
self:_UpdateSelectCell((object), index)
|
|
end)
|
|
|
|
self.m_unlockItemList = {}
|
|
for k, v in cs_pairs(self.m_facManualCraftSystem.manufactureUnlockDataMap) do
|
|
table.insert(self.m_unlockItemList, v)
|
|
end
|
|
self.m_sortIncremental = true
|
|
|
|
|
|
self.m_filterSetting = {}
|
|
local selectedFilter = {}
|
|
local list = self.m_facManualCraftSystem:GetAllDomainData()
|
|
for i = 0 , list.Count - 1 do
|
|
local domainData = list[i]
|
|
table.insert(self.m_filterSetting, {id = domainData.domainId, domainName = domainData.domainName, defaultIsOn = true,name = domainData.domainName,isOn = true})
|
|
table.insert(selectedFilter, self.m_filterSetting[i + 1])
|
|
end
|
|
|
|
self:_SortAndFilter()
|
|
|
|
local validNum = 0
|
|
for i = 1,#self.m_filterSetting do
|
|
local filterNum = self:_FilterBtnGetResCount({self.m_filterSetting[i]})
|
|
if filterNum > 0 then
|
|
validNum = validNum + 1
|
|
end
|
|
end
|
|
|
|
if validNum > 1 then
|
|
self.view.sortNodeUp:InitSortNode(sortOptions, function(optData, isIncremental)
|
|
self.m_sortMode = optData.sortMode
|
|
self.m_sortIncremental = isIncremental
|
|
self:_UpdateDefaultView(true)
|
|
end, 0, self.m_sortIncremental, true, self.view.filterBtn)
|
|
else
|
|
self.view.sortNodeUp:InitSortNode(sortOptions, function(optData, isIncremental)
|
|
self.m_sortMode = optData.sortMode
|
|
self.m_sortIncremental = isIncremental
|
|
self:_UpdateDefaultView(true)
|
|
end, 0, self.m_sortIncremental, true)
|
|
end
|
|
|
|
|
|
self.view.filterBtn:InitFilterBtn({
|
|
tagGroups = {{tags = self.m_filterSetting}} ,
|
|
selectedTags = { },
|
|
onConfirm = function(tags)
|
|
self:_FilterBtnConfirm(tags)
|
|
self.m_sortMode = self.view.sortNodeUp:GetCurSortData().sortMode
|
|
self.m_sortIncremental = self.view.sortNodeUp.isIncremental
|
|
self:_UpdateDefaultView(true)
|
|
end,
|
|
getResultCount = function(tags)
|
|
return self:_FilterBtnGetResCount(tags)
|
|
end,
|
|
sortNodeWidget = self.view.sortNodeUp,
|
|
})
|
|
|
|
|
|
self.view.previewScrollList.onCenterIndexChanged:AddListener(function(oldIndex, newIndex)
|
|
if self.m_selectIndex ~= newIndex + 1 and not self.m_activeScroll then
|
|
self.m_selectIndex = newIndex + 1
|
|
AudioAdapter.PostEvent("Au_UI_Toggle_Tab_On")
|
|
self:_UpdateSelectView(false)
|
|
self.m_activeScroll = false
|
|
return
|
|
end
|
|
end)
|
|
|
|
self.view.itemList.onGraduallyShowFinish:AddListener(function()
|
|
self.m_needRefreshReward = false
|
|
end)
|
|
|
|
self.view.previewScrollList.onScrollEnd:AddListener(function()
|
|
if self.m_activeScroll then
|
|
self.m_activeScroll = false
|
|
self.view.previewScrollList:ScrollToIndex(self.m_selectIndex - 1)
|
|
end
|
|
end)
|
|
|
|
self:_UpdateDefaultView(true)
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._FilterBtnConfirm = HL.Method(HL.Any) << function(self, tags)
|
|
for i = 1, #self.m_filterSetting do
|
|
self.m_filterSetting[i].isOn = false
|
|
end
|
|
|
|
if tags ~= nil then
|
|
for i = 1,#tags do
|
|
for j = 1,#self.m_filterSetting do
|
|
if self.m_filterSetting[j].id == tags[i].id then
|
|
self.m_filterSetting[j].isOn = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._FilterBtnGetResCount = HL.Method(HL.Table).Return(HL.Number) << function(self, tags)
|
|
local noSelect = #tags == 0
|
|
if noSelect then
|
|
return #self.m_unlockItemList
|
|
end
|
|
|
|
local count = 0
|
|
for i = 1, #self.m_realData do
|
|
local itemId = self.m_realData[i].itemId
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(itemId)
|
|
if nowCount > 0 then
|
|
if noSelect then
|
|
count = count + 1
|
|
else
|
|
for j = 1, #tags do
|
|
if Tables.itemGatherTextTable:ContainsKey(itemId) then
|
|
local gather = Tables.itemGatherTextTable:GetValue(itemId)
|
|
if gather.domainId == tags[j].id then
|
|
count = count + 1
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._SortAndFilter = HL.Method() << function(self)
|
|
if not self.m_realData then
|
|
self.m_realData = self.m_unlockItemList
|
|
end
|
|
self.m_unlockItemList = self.m_realData
|
|
local noSelect = true
|
|
for i = 1, #self.m_filterSetting do
|
|
if self.m_filterSetting[i].isOn then
|
|
noSelect = false
|
|
break
|
|
end
|
|
end
|
|
local sortData = {}
|
|
|
|
for i = 1, #self.m_unlockItemList do
|
|
local itemId = self.m_unlockItemList[i].itemId
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(itemId)
|
|
if nowCount > 0 then
|
|
if noSelect then
|
|
table.insert(sortData, self.m_unlockItemList[i])
|
|
else
|
|
for j = 1, #self.m_filterSetting do
|
|
if Tables.itemGatherTextTable:ContainsKey(itemId) then
|
|
local gather = Tables.itemGatherTextTable:GetValue(itemId)
|
|
if self.m_filterSetting[j].isOn and gather.domainId == self.m_filterSetting[j].id then
|
|
table.insert(sortData, self.m_unlockItemList[i])
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local nowSelectItem = nil
|
|
if self.m_selectIndex then
|
|
nowSelectItem = self.m_unlockItemList[self.m_selectIndex]
|
|
end
|
|
table.sort(sortData, function(a,b)
|
|
local itemId1 = a.itemId
|
|
local itemId2 = b.itemId
|
|
|
|
local canGet1 = self.m_facManualCraftSystem:CheckHaveRewardByItemNoGet(itemId1) > 0
|
|
local canGet2 = self.m_facManualCraftSystem:CheckHaveRewardByItemNoGet(itemId2) > 0
|
|
|
|
if canGet1 ~= canGet2 then
|
|
return canGet1
|
|
end
|
|
|
|
local allGet1 = self.m_facManualCraftSystem:CheckAllGet(itemId1)
|
|
local allGet2 = self.m_facManualCraftSystem:CheckAllGet(itemId2)
|
|
|
|
if allGet1 ~= allGet2 then
|
|
return not allGet1
|
|
end
|
|
|
|
local itemData1 = Tables.itemTable:GetValue(itemId1)
|
|
local itemData2 = Tables.itemTable:GetValue(itemId2)
|
|
local sortKeys = sortOptions[self.m_sortMode].sortKeys
|
|
|
|
for i = 1, #sortKeys do
|
|
local key = sortKeys[i]
|
|
local value1 = itemData1[key]
|
|
local value2 = itemData2[key]
|
|
if value1 ~= value2 then
|
|
if self.m_sortIncremental then
|
|
return value1 < value2
|
|
else
|
|
return value1 > value2
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end)
|
|
|
|
self.m_unlockItemList = sortData
|
|
|
|
if nowSelectItem then
|
|
for i = 1, #self.m_unlockItemList do
|
|
if self.m_unlockItemList[i].itemId == nowSelectItem.itemId then
|
|
self.m_selectIndex = i
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._UpdateDefaultView = HL.Method(HL.Boolean) << function(self, needSortAndFilter)
|
|
self.view.selectPanel:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):Play("manualcraftpopups_select_out", function()
|
|
self.view.selectPanel.gameObject:SetActive(false)
|
|
end)
|
|
self.view.defaultScrollbarVertical.gameObject:SetActive(true)
|
|
self.view.bottomBg.gameObject:SetActive(true)
|
|
self.view.itemList.gameObject:SetActive(true)
|
|
self.view.btnBack.gameObject:SetActive(true)
|
|
if needSortAndFilter then
|
|
self:_SortAndFilter()
|
|
end
|
|
|
|
if DeviceInfo.usingController then
|
|
local controllerBackIndex = -1
|
|
for i = 1, #self.m_unlockItemList do
|
|
local item = self.m_unlockItemList[i]
|
|
if self.m_previewItemId == item.itemId then
|
|
controllerBackIndex = i
|
|
end
|
|
end
|
|
if controllerBackIndex ~= -1 then
|
|
self.view.itemList:ScrollToIndex(controllerBackIndex)
|
|
end
|
|
self.view.itemList:UpdateCount(#self.m_unlockItemList, controllerBackIndex)
|
|
else
|
|
self.view.itemList:UpdateCount(#self.m_unlockItemList)
|
|
end
|
|
|
|
|
|
|
|
self.view.sortNodeUp.gameObject:SetActive(true)
|
|
self.view.emptyStateTextNode.gameObject:SetActive(true)
|
|
|
|
|
|
local gatherMap = {}
|
|
for i = 1, #self.m_realData do
|
|
local itemId = self.m_realData[i].itemId
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(itemId)
|
|
if Tables.itemGatherTextTable:ContainsKey(itemId) then
|
|
local gather = Tables.itemGatherTextTable:GetValue(itemId)
|
|
if nowCount > 0 then
|
|
gatherMap[gather.domainId] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
local count = 0
|
|
for k,v in pairs(gatherMap) do
|
|
count = count + 1
|
|
end
|
|
if count > GATHER_MAP_VALID_COUNT then
|
|
if DeviceInfo.usingController then
|
|
self.view.filterBtn.gameObject:SetActive(false)
|
|
else
|
|
self.view.filterBtn.gameObject:SetActive(true)
|
|
end
|
|
else
|
|
self.view.filterBtn.gameObject:SetActive(false)
|
|
end
|
|
|
|
if self.m_selectIndex then
|
|
self.m_activeScroll = true
|
|
self.view.previewScrollList:ScrollToIndex(self.m_selectIndex - 1)
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._UpdateDefaultCell = HL.Method(GameObject, HL.Number) << function(self, cell, csIndex)
|
|
local index = LuaIndex(csIndex)
|
|
cell = self.m_getDefaultCell(cell)
|
|
local item = self.m_unlockItemList[index]
|
|
local itemData = Tables.itemTable:GetValue(item.itemId)
|
|
cell.gameObject.name = "CardsCell_" .. item.itemId
|
|
|
|
cell.itemIcon:LoadSprite(UIConst.UI_SPRITE_ITEM, itemData.iconId)
|
|
cell.commodityText.text = itemData.name
|
|
UIUtils.setItemRarityImage(cell.qualityColor, itemData.rarity)
|
|
local needRefresh = self.m_needRefreshReward
|
|
|
|
if not self.m_unlockItemRewardMap[cell] then
|
|
self.m_unlockItemRewardMap[cell] = UIUtils.genCellCache(cell.cell)
|
|
needRefresh = true
|
|
end
|
|
|
|
if not self.m_unlockItemIdCellMap[cell] then
|
|
self.m_unlockItemIdCellMap[cell] = item.itemId
|
|
else
|
|
if self.m_unlockItemIdCellMap[cell] ~= item.itemId then
|
|
needRefresh = true
|
|
self.m_unlockItemIdCellMap[cell] = item.itemId
|
|
end
|
|
end
|
|
|
|
local _, data = self.m_facManualCraftSystem.manufactureUnlockDataMap:TryGetValue(item.itemId)
|
|
local allGet = self.m_facManualCraftSystem:CheckAllGet(item.itemId)
|
|
|
|
cell.redDot:InitRedDot("ManualCraftReward", {itemId = item.itemId})
|
|
if allGet then
|
|
cell.finishBgNode.gameObject:SetActive(true)
|
|
else
|
|
cell.finishBgNode.gameObject:SetActive(false)
|
|
end
|
|
local path = Tables.itemGatherTextTable:GetValue(item.itemId).icon
|
|
cell.icon:LoadSprite(UIConst.UI_SPRITE_MANUAL_CRAFT_TYPE_ICON, path)
|
|
|
|
local unlockRewardList = self.m_unlockItemRewardMap[cell]
|
|
if needRefresh then
|
|
unlockRewardList:Refresh(data.rewardList.Count, function(rewardCell, rewardIndex)
|
|
rewardCell.gameObject:SetActive(true)
|
|
rewardIndex = rewardIndex - 1
|
|
local rewardId = data.rewardList[rewardIndex]
|
|
local count = data.rewardCount[rewardIndex]
|
|
local condition = data.unlockCondition[rewardIndex]
|
|
local unlockId = data.unlockIdList[rewardIndex]
|
|
local haveGet = self.m_facManualCraftSystem:CheckHaveGetReward(unlockId)
|
|
rewardCell.gameObject:SetActive(true)
|
|
rewardCell.itemBigBlack:InitItem({id = rewardId, count = count}, false)
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(data.itemId)
|
|
|
|
|
|
rewardCell.notAvailable.gameObject:SetActive(not haveGet and nowCount < condition)
|
|
rewardCell.availableEffect.gameObject:SetActive(not haveGet and nowCount >= condition)
|
|
rewardCell.availableEffect.gameObject:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):PlayLoopAnimation()
|
|
rewardCell.rewardedCover.gameObject:SetActive(haveGet)
|
|
self:_UpdateProgress(rewardCell.manufactureProgress, data, rewardIndex)
|
|
if data.rewardList.Count == rewardIndex + 1 then
|
|
|
|
end
|
|
end)
|
|
end
|
|
|
|
cell.button.onClick:RemoveAllListeners()
|
|
cell.button.onClick:AddListener(function()
|
|
self.m_selectIndex = index
|
|
self.m_previewIndex = index
|
|
self.m_previewItemId = item.itemId
|
|
|
|
self.m_activeScroll = true
|
|
self:_UpdateSelectView(false)
|
|
self.view.selectPanel:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):Play("manualcraftpopups_select_in")
|
|
end)
|
|
|
|
|
|
if self.m_initControllerSelected then
|
|
if self.m_previewItemId == item.itemId then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.button)
|
|
end
|
|
else
|
|
if index == LUA_FIRST_INDEX then
|
|
self.m_initControllerSelected = true
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.button)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._UpdateSelectView = HL.Method(HL.Boolean) << function(self, needSortAndFilter)
|
|
self.view.itemList.gameObject:SetActive(false)
|
|
self.view.selectPanel.gameObject:SetActive(true)
|
|
self.view.sortNodeUp.gameObject:SetActive(false)
|
|
self.view.emptyStateTextNode.gameObject:SetActive(false)
|
|
|
|
self.view.filterBtn.gameObject:SetActive(false)
|
|
self.view.bottomBg.gameObject:SetActive(false)
|
|
self.view.btnBack.gameObject:SetActive(false)
|
|
|
|
self.view.leftArrow.interactable = self.m_selectIndex > 1
|
|
self.view.rightArrow.interactable = self.m_selectIndex < #self.m_unlockItemList
|
|
self.view.defaultScrollbarVertical.gameObject:SetActive(false)
|
|
if needSortAndFilter then
|
|
self:_SortAndFilter()
|
|
end
|
|
self.m_activeScroll = true
|
|
local itemId = self.m_unlockItemList[self.m_selectIndex].itemId
|
|
self.m_rewardCellList = self.m_rewardCellList or UIUtils.genCellCache(self.view.rewardCell)
|
|
local _, data = self.m_facManualCraftSystem.manufactureUnlockDataMap:TryGetValue(self.m_unlockItemList[self.m_selectIndex].itemId)
|
|
self.view.previewScrollList:UpdateCount(#self.m_unlockItemList)
|
|
self.view.previewScrollList:ScrollToIndex(self.m_selectIndex - 1)
|
|
local allChildCount = self.view.progressBar.transform.childCount
|
|
|
|
local haveGet = self.m_facManualCraftSystem:CheckHaveRewardByItemNoGet(itemId)
|
|
local allGet = self.m_facManualCraftSystem:CheckHaveRewardByItemAllGet(itemId)
|
|
self.view.btnCommon.gameObject:SetActive(haveGet > 0)
|
|
self.view.completBtn.gameObject:SetActive(allGet)
|
|
|
|
for i = 0, allChildCount - 1 do
|
|
self.view.progressBar.transform:GetChild(i).gameObject:SetActive(false)
|
|
end
|
|
|
|
local gatherText = Tables.itemGatherTextTable:GetValue(itemId).desc
|
|
self.view.previewText:SetAndResolveTextStyle(gatherText)
|
|
self.m_jumpRewardFlag = false
|
|
self.m_rewardCellList:Refresh(data.rewardList.Count, function(cell, luaIndex)
|
|
cell.gameObject.name = "RewardCell_" .. luaIndex
|
|
index = CSIndex(luaIndex)
|
|
local rewardId = data.rewardList[index]
|
|
local count = data.rewardCount[index]
|
|
local condition = data.unlockCondition[index]
|
|
local unlockId = data.unlockIdList[index]
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(data.itemId)
|
|
|
|
local haveGet = self.m_facManualCraftSystem:CheckHaveGetReward(unlockId);
|
|
|
|
local showType = ShowRewardsType.RECEIVED
|
|
|
|
cell.receivedNode.gameObject:SetActive(false)
|
|
cell.available.gameObject:SetActive(false)
|
|
cell.notAvailable.gameObject:SetActive(false)
|
|
|
|
if haveGet then
|
|
showType = ShowRewardsType.RECEIVED
|
|
cell.receivedNode.gameObject:SetActive(true)
|
|
else
|
|
if nowCount >= condition then
|
|
showType = ShowRewardsType.AVAILABLE
|
|
cell.available.gameObject:SetActive(true)
|
|
else
|
|
showType = ShowRewardsType.NOT_AVAILABLE
|
|
cell.notAvailable.gameObject:SetActive(true)
|
|
end
|
|
end
|
|
|
|
cell.receivedNode.finish.gameObject:SetActive(haveGet)
|
|
|
|
cell.available.receiveBtn.onClick:RemoveAllListeners()
|
|
cell.available.receiveBtn.onClick:AddListener(function()
|
|
self.m_facManualCraftSystem:ReqManuallyUnlock(Utils.getCurrentScope(), unlockId)
|
|
end)
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(data.itemId)
|
|
self.view.progressText.text = nowCount
|
|
|
|
local view = {}
|
|
self.view.progressBar.transform:GetChild(index):GetComponent(typeof(CS.Beyond.Lua.LuaReference)):BindToLua(view)
|
|
self:_UpdateProgress(view, data, index)
|
|
|
|
local itemDaa = {id = rewardId, count = count}
|
|
local activeNode = cell.available
|
|
if nowCount < condition then
|
|
activeNode = cell.notAvailable
|
|
elseif haveGet then
|
|
activeNode = cell.receivedNode
|
|
else
|
|
activeNode = cell.available
|
|
end
|
|
|
|
if activeNode.itemBigBlack then
|
|
activeNode.itemBigBlack:InitItem(itemDaa, true)
|
|
end
|
|
activeNode.commodityText.text = Tables.itemTable:GetValue(rewardId).name
|
|
|
|
cell.receivedNode.keyHintR3.gameObject:SetActive(false)
|
|
cell.available.keyHintR3.gameObject:SetActive(false)
|
|
cell.notAvailable.keyHintR3.gameObject:SetActive(false)
|
|
|
|
cell.naviDecorator.onIsNaviTargetChanged = function(active)
|
|
cell.receivedNode.keyHintR3.gameObject:SetActive(active)
|
|
cell.available.keyHintR3.gameObject:SetActive(active)
|
|
cell.notAvailable.keyHintR3.gameObject:SetActive(active)
|
|
end
|
|
|
|
if self.m_jumpRewardFlag == false then
|
|
if index == 0 then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.naviDecorator)
|
|
cell.naviDecorator.onIsNaviTargetChanged(true)
|
|
end
|
|
if showType == ShowRewardsType.AVAILABLE then
|
|
self.m_jumpRewardFlag = true
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.naviDecorator)
|
|
cell.naviDecorator.onIsNaviTargetChanged(true)
|
|
end
|
|
end
|
|
|
|
local groupId = cell.inputGroup.groupId
|
|
local alreadyBindingId = self.m_bindSubCache[groupId]
|
|
if alreadyBindingId ~= nil then
|
|
InputManagerInst:DeleteBinding(alreadyBindingId)
|
|
self.m_bindSubCache[groupId] = nil
|
|
end
|
|
|
|
|
|
self.m_bindSubCache[groupId] = InputManagerInst:CreateBindingByActionId("show_item_tips", function()
|
|
if showType == ShowRewardsType.RECEIVED then
|
|
cell.receivedNode.itemBigBlack:ShowTips()
|
|
elseif showType == ShowRewardsType.AVAILABLE then
|
|
cell.available.itemBigBlack:ShowTips()
|
|
elseif showType == ShowRewardsType.NOT_AVAILABLE then
|
|
cell.notAvailable.itemBigBlack:ShowTips()
|
|
end
|
|
end, groupId)
|
|
end)
|
|
self.view.previewScrollList:GetComponent(typeof(CS.UnityEngine.UI.ScrollRect)).horizontal = false
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._UpdateSelectCell = HL.Method(GameObject, HL.Number) << function(self, cell, index)
|
|
if cell == nil then
|
|
logger.error("cell 11 == nil index:"..index)
|
|
end
|
|
|
|
index = index + 1
|
|
cell = self.m_getSelectCell(cell)
|
|
local previewId = self.m_unlockItemList[index].itemId
|
|
|
|
if cell == nil then
|
|
logger.error("cell == nil index:"..index)
|
|
else
|
|
if cell.select == nil then
|
|
logger.error("cell.select == nil index:"..index)
|
|
end
|
|
end
|
|
|
|
local activeNode = cell.select
|
|
|
|
if self.m_selectIndex == index then
|
|
cell.select.gameObject:SetActive(true)
|
|
cell.unselected.gameObject:SetActive(false)
|
|
activeNode = cell.select
|
|
else
|
|
cell.select.gameObject:SetActive(false)
|
|
cell.unselected.gameObject:SetActive(true)
|
|
activeNode = cell.unselected
|
|
end
|
|
local itemData = Tables.itemTable:GetValue(previewId)
|
|
activeNode.commodityText.text = itemData.name
|
|
activeNode.itemIcon:LoadSprite(UIConst.UI_SPRITE_ITEM, itemData.iconId)
|
|
UIUtils.setItemRarityImage(activeNode.qualityColor, itemData.rarity)
|
|
local path = Tables.itemGatherTextTable:GetValue(previewId).icon
|
|
cell.select.typeIcon1:LoadSprite(UIConst.UI_SPRITE_MANUAL_CRAFT_TYPE_ICON, path)
|
|
cell.unselected.typeIcon2:LoadSprite(UIConst.UI_SPRITE_MANUAL_CRAFT_TYPE_ICON, path)
|
|
|
|
cell.button.onClick:RemoveAllListeners()
|
|
cell.button.onClick:AddListener(function()
|
|
if self.m_selectIndex == index then
|
|
return
|
|
end
|
|
AudioAdapter.PostEvent("Au_UI_Toggle_Tab_On")
|
|
self.m_selectIndex = index
|
|
self.m_facManualCraftSystem:ReadRewardByItem(previewId)
|
|
|
|
self:_UpdateSelectView(false)
|
|
self.view.selectPanel:GetComponent(typeof(CS.Beyond.UI.UIAnimationWrapper)):Play("manualcraftpopups_select_switch")
|
|
|
|
end)
|
|
|
|
cell.redDot:InitRedDot("ManualCraftReward", {itemId = self.m_unlockItemList[index].itemId})
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._UpdateProgress = HL.Method(HL.Any, HL.Any, HL.Number) << function(self, cell, unlockData, index)
|
|
cell.gameObject:SetActive(true)
|
|
cell.text.text = tostring(unlockData.unlockCondition[index])
|
|
local nowCount = self.m_facManualCraftSystem:GetItemAccumulateCount(unlockData.itemId)
|
|
local isUnlock = nowCount >= unlockData.unlockCondition[index]
|
|
cell.selected.gameObject:SetActive(isUnlock)
|
|
cell.selectedLine.gameObject:SetActive(false)
|
|
cell.text.color = isUnlock and Color.black or Color.white
|
|
|
|
if cell.defalutLine then
|
|
cell.defalutLine.gameObject:SetActive(false)
|
|
if index < unlockData.rewardList.Count - 1 then
|
|
cell.defalutLine.gameObject:SetActive(true)
|
|
if cell.line then
|
|
cell.line.gameObject:SetActive(true)
|
|
end
|
|
end
|
|
end
|
|
if index < unlockData.rewardList.Count - 1 then
|
|
cell.selectedLine.gameObject:SetActive(true)
|
|
local lastCount = index ~= 0 and unlockData.unlockCondition[index] or 0
|
|
if nowCount == 1 then
|
|
nowCount = 0
|
|
end
|
|
cell.selectedLine.fillAmount = (nowCount - lastCount) / (unlockData.unlockCondition[index + 1] - lastCount)
|
|
end
|
|
|
|
if unlockData.rewardList.Count < 5 and index == unlockData.rewardList.Count - 1 and cell.line then
|
|
cell.line.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._GetItemCount = HL.Method(HL.String).Return(HL.Any) << function(self, itemId)
|
|
if Utils.isInSafeZone() or self:_IsValuableItem(itemId) then
|
|
return self.m_inventorySystem:GetItemCount(Utils.getCurrentScope(), Utils.getCurrentChapterId(), itemId)
|
|
else
|
|
return self.m_inventorySystem:GetItemCountInBag(Utils.getCurrentScope(), itemId)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._IsValuableItem = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
|
|
local itemData = Tables.itemTable[itemId]
|
|
local valuableDepotType = itemData.valuableTabType
|
|
if valuableDepotType ~= CS.Beyond.GEnums.ItemValuableDepotType.Factory then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl.OnGetNewItemLevelUp = HL.Method(HL.Any) << function(self, args)
|
|
self.m_needRefreshReward = true
|
|
PhaseManager:OpenPhase(PhaseId.ManualcraftUpgradePopup,{itemList = args})
|
|
if self.view.selectPanel.gameObject.activeSelf then
|
|
self:_UpdateSelectView(false)
|
|
else
|
|
self:_UpdateDefaultView(true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl._OnGetReward = HL.Method(HL.Any) << function(self, newItems)
|
|
self.m_needRefreshReward = true
|
|
self:OnGetReward(newItems)
|
|
if self.view.selectPanel.gameObject.activeSelf then
|
|
self:_UpdateSelectView(false)
|
|
else
|
|
self:_UpdateDefaultView(true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl.OnGetReward = HL.Method(HL.Any) << function(self, newItems)
|
|
local idList = newItems[1]
|
|
local info = {
|
|
title = Language.LUA_FAC_MANUAL_CRAFT_REWARD,
|
|
onComplete = function()
|
|
end,
|
|
}
|
|
info.items = {}
|
|
local levelUp = {}
|
|
for i = 0, idList.Count - 1 do
|
|
local id = idList[i]
|
|
local data = Tables.factoryManualCraftFormulaUnlockTable:GetValue(id)
|
|
local itemId = data.rewardItemId1
|
|
local count = data.rewardItemCount1
|
|
local itemData = Tables.itemTable:GetValue(itemId)
|
|
|
|
table.insert(info.items, {
|
|
id = itemId,
|
|
count = count,
|
|
})
|
|
|
|
if itemData.type == CS.Beyond.GEnums.ItemType.FormulaLevelUp then
|
|
table.insert(levelUp, id)
|
|
end
|
|
end
|
|
|
|
if #levelUp > 0 then
|
|
if #info.items > 0 then
|
|
info.onComplete = function()
|
|
Notify(MessageConst.ON_MANUAL_CRAFT_LEVEL_UP, levelUp)
|
|
end
|
|
else
|
|
Notify(MessageConst.ON_MANUAL_CRAFT_LEVEL_UP, levelUp)
|
|
end
|
|
end
|
|
|
|
if #info.items > 0 then
|
|
Notify(MessageConst.SHOW_SYSTEM_REWARDS, info)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ManualCraftPopupsCtrl.OnClose = HL.Override() << function(self)
|
|
self.view.previewScrollList.onScrollEnd:RemoveAllListeners()
|
|
end
|
|
|
|
|
|
|
|
|
|
HL.Commit(ManualCraftPopupsCtrl)
|