665 lines
19 KiB
Lua
665 lines
19 KiB
Lua
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.SpaceshipReceptionDisplay
|
|
local PHASE_ID = PhaseId.SpaceshipReceptionDisplay
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl = HL.Class('SpaceshipReceptionDisplayCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_infoList = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_filteredInfoList = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_selectedTags = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_isSave = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.GetCell = HL.Field(HL.Function)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.cell2Select = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_select2Cell = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_maxSelectNum = HL.Field(HL.Number) << 1
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_nowSelectNum = HL.Field(HL.Number) << 0
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_pictureRedDots = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_nowNaviPictureCell = HL.Field(HL.Userdata)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_sortIsIncremental = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_sortOptData = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.m_redDotShowCor = HL.Field(HL.Thread)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.ON_SPACESHIP_GUEST_ROOM_SET_CHAR_PICTURE_LIST] = '_OnSavePicture',
|
|
[MessageConst.ON_READ_NEW_SS_PICTURE] = '_UpdateRedDotByInfoList',
|
|
[MessageConst.ON_SPACESHIP_HEAD_NAVI_TARGET_CHANGE] = 'OnCellNaviTargetChange',
|
|
}
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.ResetPicture = HL.StaticMethod() << function()
|
|
local picIdsList = GameInstance.player.spaceship:GetScreenWallPicIds()
|
|
local picIdsTable = {}
|
|
if picIdsList and picIdsList.Count > 0 then
|
|
for i = CSIndex(1), CSIndex(picIdsList.Count) do
|
|
local pictureId = picIdsList[i]
|
|
local succ, data = Tables.pictureGenderTable:TryGetValue(pictureId)
|
|
if succ and tonumber(GameInstance.player.playerInfoSystem.gender) ~= data.gender then
|
|
pictureId = data.reversePictureId
|
|
end
|
|
table.insert(picIdsTable, pictureId)
|
|
end
|
|
GameInstance.player.spaceship:ChangeGuestRoomScreenWallPics(picIdsTable)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.btnClose.onClick:AddListener(function()
|
|
if not self.m_isSave then
|
|
Notify(MessageConst.SHOW_POP_UP,{
|
|
content = Language.LUA_SS_POSTER_UN_SAVE_CLOSE_POPUP,
|
|
onConfirm = function()
|
|
PhaseManager:PopPhase(PHASE_ID)
|
|
end
|
|
})
|
|
else
|
|
PhaseManager:PopPhase(PHASE_ID)
|
|
end
|
|
end)
|
|
|
|
self.view.btnSave.onClick:AddListener(function()
|
|
local tmpTable = {}
|
|
local tmpPicTable = {}
|
|
for _, cellIndex in pairs(self.m_select2Cell) do
|
|
local item = self.m_filteredInfoList[cellIndex]
|
|
local picId = item.posterData.pictureId
|
|
if not tmpPicTable[picId] then
|
|
table.insert(tmpTable, picId)
|
|
tmpPicTable[picId] = true
|
|
end
|
|
end
|
|
|
|
|
|
local guestRoomId = Tables.spaceshipConst.guestRoomId
|
|
local guestRoomTypeStr = tostring(GEnums.SpaceshipRoomType.GuestRoom)
|
|
local picIdsList = GameInstance.player.spaceship:GetScreenWallPicIds()
|
|
local beforeIds = {}
|
|
local afterIds = {}
|
|
local places = {}
|
|
for i = 1, Tables.spaceshipConst.charPictureMaxCount do
|
|
local prevId = (picIdsList and i <= picIdsList.Count) and picIdsList[CSIndex(i)] or nil
|
|
local afterId = tmpTable[i]
|
|
if prevId ~= afterId then
|
|
table.insert(beforeIds, prevId == nil and '' or prevId)
|
|
table.insert(afterIds, afterId == nil and '' or afterId)
|
|
table.insert(places, tostring(i))
|
|
end
|
|
end
|
|
if #places > 0 then
|
|
EventLogManagerInst:GameEvent_PersonalDecoration(beforeIds, afterIds, places, "screen_wall", guestRoomTypeStr, guestRoomId)
|
|
end
|
|
|
|
|
|
GameInstance.player.spaceship:ChangeGuestRoomScreenWallPics(tmpTable)
|
|
self:SetSaveState(true)
|
|
end)
|
|
|
|
self.view.resetBtn.onClick:AddListener(function()
|
|
if self.m_nowSelectNum > 0 then
|
|
self:SetSaveState(false)
|
|
end
|
|
self:ShowSelectItems()
|
|
end)
|
|
|
|
self.GetCell = UIUtils.genCachedCellFunction(self.view.pictureScroll)
|
|
self.view.pictureScroll.onSelectedCell:AddListener(function(obj, csIndex)
|
|
local cellIndex = LuaIndex(csIndex)
|
|
self:OnClickItem(cellIndex)
|
|
end)
|
|
|
|
self.view.pictureScroll.onUpdateCell:AddListener(function(object, index)
|
|
local cellIndex = LuaIndex(index)
|
|
self:OnUpdateCell(object, cellIndex)
|
|
end)
|
|
|
|
self:BindInputPlayerAction("ss_view_detail_picture", function()
|
|
if self.m_nowNaviPictureCell then
|
|
self.m_nowNaviPictureCell:OpenPicturePanel()
|
|
end
|
|
end)
|
|
|
|
self.m_selectedTags = {}
|
|
self.m_select2Cell = {}
|
|
self.cell2Select = {}
|
|
self.m_filteredInfoList = {}
|
|
self.m_infoList = {}
|
|
self.m_maxSelectNum = Tables.spaceshipConst.charPictureMaxCount
|
|
local charPotentialIndex2Infos, _ = CharInfoUtils.GetAllCharPotentialInfos()
|
|
if #charPotentialIndex2Infos >= 1 then
|
|
self.view.commonState:SetState("Normal")
|
|
else
|
|
self.view.commonState:SetState("Null")
|
|
end
|
|
|
|
self:_InitSortNode()
|
|
self:_InitFilterNode()
|
|
self:UpdatePictureItems(charPotentialIndex2Infos)
|
|
local picIdsList = GameInstance.player.spaceship:GetScreenWallPicIds()
|
|
local picIdsTable = {}
|
|
if picIdsList and picIdsList.Count > 0 then
|
|
for i = CSIndex(1), CSIndex(picIdsList.Count) do
|
|
table.insert(picIdsTable, picIdsList[i])
|
|
end
|
|
end
|
|
self:ShowSelectItems(picIdsTable)
|
|
self:SetSaveState(true)
|
|
self.m_redDotShowCor = self:_StartCoroutine(function()
|
|
while true do
|
|
coroutine.wait(0.2)
|
|
self:_UpdateRedDot()
|
|
end
|
|
end)
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnClose = HL.Override() << function(self)
|
|
|
|
end
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnIntScreen = HL.StaticMethod() << function()
|
|
PhaseManager:OpenPhase(PHASE_ID)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnCellNaviTargetChange = HL.Method(HL.Opt(HL.Userdata)) << function(self, cell)
|
|
self.m_nowNaviPictureCell = cell
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnUpdateCell = HL.Method(HL.Userdata, HL.Number) << function(self, object, index)
|
|
local cell = self:GetCellByIndex(index)
|
|
local item = self.m_filteredInfoList[index]
|
|
|
|
cell:InitSSPictureCell(item.posterData.pictureId, self.m_filteredInfoList, function(arg)
|
|
self:OnClickItem(index)
|
|
end)
|
|
cell:SelectIndex(self.cell2Select[index])
|
|
local isOld = GameInstance.player.spaceship:GetPictureRedDotReadState(item.posterData.pictureId)
|
|
cell:UpdateRedDotState(not isOld)
|
|
if index == 1 then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.view.pictureBtn)
|
|
end
|
|
self:_UpdateRedDot()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.OnClickItem = HL.Method(HL.Number) << function(self, cellIndex)
|
|
local cell = self:GetCellByIndex(cellIndex)
|
|
local cellSelectIndex = self:_GetCellSelectIndex(cellIndex)
|
|
|
|
GameInstance.player.spaceship:ReadPictureRedDot(self.m_filteredInfoList[cellIndex].posterData.pictureId)
|
|
cell:UpdateRedDotState(false)
|
|
|
|
if self.m_nowSelectNum >= self.m_maxSelectNum and self.cell2Select[cellIndex] == nil then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_WALL_LIMIT_MAX)
|
|
return
|
|
end
|
|
|
|
if cellSelectIndex > 0 then
|
|
local index = self.cell2Select[cellIndex]
|
|
self.m_select2Cell[index] = nil
|
|
self.cell2Select[cellIndex] = nil
|
|
self.m_filteredInfoList[cellIndex].selectIndex = nil
|
|
self.m_nowSelectNum = self.m_nowSelectNum - 1
|
|
cell:SelectIndex()
|
|
elseif self.m_nowSelectNum < self.m_maxSelectNum then
|
|
local curIndex = self:_GetNextIndex()
|
|
self.m_select2Cell[curIndex] = cellIndex
|
|
self.cell2Select[cellIndex] = curIndex
|
|
self.m_filteredInfoList[cellIndex].selectIndex = curIndex
|
|
self.m_nowSelectNum = curIndex
|
|
end
|
|
local itemList = self:_UpdateMultiSelect()
|
|
self:UpdatePicCount(#itemList, self.m_maxSelectNum)
|
|
self:SetSaveState(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.UpdatePicCount = HL.Method(HL.Number, HL.Number) << function(self, nowNum, maxNum)
|
|
self.view.picCountTxt.text = string.format("%d<size=26>/%d</size>", nowNum, maxNum)
|
|
self.view.lvDotNode:InitLvDotNode(nowNum, maxNum)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._UpdateMultiSelect = HL.Method(HL.Opt(HL.Boolean)).Return(HL.Table) << function(self)
|
|
local result = {}
|
|
local itemList = {}
|
|
for _, cellIndex in pairs(self.m_select2Cell) do
|
|
table.insert(result, cellIndex)
|
|
end
|
|
|
|
self.cell2Select = {}
|
|
self.m_select2Cell = {}
|
|
|
|
for index, cellIndex in pairs(result) do
|
|
local cell = self:GetCellByIndex(cellIndex)
|
|
self.cell2Select[cellIndex] = index
|
|
self.m_select2Cell[index] = cellIndex
|
|
if cell then
|
|
cell:SelectIndex(index)
|
|
end
|
|
local item = self.m_filteredInfoList[cellIndex]
|
|
table.insert(itemList, item)
|
|
end
|
|
return itemList
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.ShowSelectItems = HL.Method(HL.Opt(HL.Table)) << function(self, items)
|
|
|
|
self.cell2Select = {}
|
|
self.m_select2Cell = {}
|
|
if items then
|
|
self.m_nowSelectNum = #items
|
|
for index, picId in pairs(items) do
|
|
local cellIndex = self:_GetIndexByPicId(picId)
|
|
self.cell2Select[cellIndex] = index
|
|
self.m_select2Cell[index] = cellIndex
|
|
end
|
|
else
|
|
self.m_nowSelectNum = 0
|
|
end
|
|
self:UpdatePicCount(self.m_nowSelectNum, self.m_maxSelectNum)
|
|
self:_ShowMultiItems()
|
|
self:_OnFilterConfirm(self.m_selectedTags)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._ShowMultiItems = HL.Method() << function(self)
|
|
for cellIndex = 1, self.view.pictureScroll.count do
|
|
local cell = self:GetCellByIndex(cellIndex)
|
|
if cell then
|
|
cell:SelectIndex(self.cell2Select[cellIndex])
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._GetIndexByPicId = HL.Method(HL.Any).Return(HL.Number) << function(self, pictureId)
|
|
for index = 1, #self.m_filteredInfoList do
|
|
local charItem = self.m_filteredInfoList[index]
|
|
if charItem.posterData.pictureId == pictureId then
|
|
return index
|
|
end
|
|
end
|
|
return -1;
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._GetNextIndex = HL.Method().Return(HL.Number) << function(self)
|
|
for index = 1, self.m_maxSelectNum do
|
|
if not Utils.isInclude(self.cell2Select, index) then
|
|
return index
|
|
end
|
|
end
|
|
return -1
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.GetCellByIndex = HL.Method(HL.Number).Return(HL.Forward("SSPictureCell")) << function(self, cellIndex)
|
|
local go = self.view.pictureScroll:Get(CSIndex(cellIndex))
|
|
local cell = nil
|
|
if go then
|
|
cell = self.GetCell(go)
|
|
end
|
|
return cell
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._GetCellSelectIndex = HL.Method(HL.Number).Return(HL.Number) << function(self, cellIndex)
|
|
if self.cell2Select[cellIndex] ~= nil and self.cell2Select[cellIndex] > 0 then
|
|
return self.cell2Select[cellIndex]
|
|
else
|
|
return -1
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.SetSaveState = HL.Method(HL.Boolean) << function(self, isSave)
|
|
if self.m_isSave == isSave then
|
|
return
|
|
end
|
|
if isSave then
|
|
self.view.btnSaveRoot:SetState("DisableState")
|
|
else
|
|
self.view.btnSaveRoot:SetState("NormalState")
|
|
end
|
|
self.m_isSave = isSave
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._InitSortNode = HL.Method() << function(self)
|
|
self.view.sortNode:InitSortNode(UIConst.SS_PICTURE_SORT_OPTION, function(optData, isIncremental)
|
|
local filteredList = self.m_filteredInfoList
|
|
filteredList = self:_ApplySort(filteredList, optData, isIncremental)
|
|
self:_RefreshPicList(true, filteredList)
|
|
end, nil, false, true, self.view.filterBtn)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._InitFilterNode = HL.Method() << function(self)
|
|
local filterArgs = {
|
|
tagGroups = FilterUtils.generateConfig_POSTER_PICTURE(),
|
|
selectedTags = self.m_selectedTags,
|
|
onConfirm = function(tags)
|
|
self:_OnFilterConfirm(tags)
|
|
end,
|
|
getResultCount = function(tags)
|
|
return self:_OnFilterGetCount(tags)
|
|
end,
|
|
sortNodeWidget = self.view.sortNode,
|
|
}
|
|
self.view.filterBtn:InitFilterBtn(filterArgs)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._SortData = HL.Method(HL.Table, HL.Table, HL.Boolean) << function(self, itemList, keys, isIncremental)
|
|
if itemList then
|
|
table.sort(itemList, Utils.genSortFunction(keys, isIncremental))
|
|
self.m_sortIsIncremental = isIncremental
|
|
self.m_sortOptData = keys
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._OnFilterConfirm = HL.Method(HL.Table) << function(self, tags)
|
|
self.m_selectedTags = tags or {}
|
|
local filteredList = self.m_infoList
|
|
filteredList = self:_ApplySort(filteredList, self.view.sortNode:GetCurSortData(), self.view.sortNode.isIncremental)
|
|
filteredList = self:_ApplyFilter(filteredList, self.m_selectedTags)
|
|
if #filteredList > 0 then
|
|
self.view.commonState:SetState("Normal")
|
|
elseif #self.m_infoList == 0 then
|
|
self.view.commonState:SetState("Null")
|
|
else
|
|
self.view.commonState:SetState("ScreenNull")
|
|
end
|
|
self.m_filteredInfoList = filteredList
|
|
self:_RefreshPicList(true, filteredList)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl.UpdatePictureItems = HL.Method(HL.Table) << function(self, items)
|
|
self.m_infoList = lume.deepCopy(items)
|
|
self.m_filteredInfoList = lume.deepCopy(items)
|
|
self:_OnFilterConfirm(self.m_selectedTags)
|
|
self.view.sortNode:SortCurData()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._OnFilterGetCount = HL.Method(HL.Table).Return(HL.Number) << function(self, tags)
|
|
local resultCount = 0
|
|
for _, itemInfo in pairs(self.m_infoList) do
|
|
if FilterUtils.checkIfPassFilter(itemInfo, tags) then
|
|
resultCount = resultCount + 1
|
|
end
|
|
end
|
|
return resultCount
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._ApplySort = HL.Method(HL.Table, HL.Table, HL.Boolean).Return(HL.Table)
|
|
<< function(self, itemInfoList, optData, isIncremental)
|
|
local tempPictureIdList = {}
|
|
for selectIndex, cellIndex in pairs(self.m_select2Cell) do
|
|
local item = itemInfoList[cellIndex]
|
|
if item then
|
|
local picId = item.posterData.pictureId
|
|
tempPictureIdList[picId] = selectIndex
|
|
end
|
|
end
|
|
for _, itemInfo in pairs(itemInfoList) do
|
|
local picId = itemInfo.posterData.pictureId
|
|
if tempPictureIdList[picId] then
|
|
itemInfo.selectSlot = -tempPictureIdList[picId]
|
|
itemInfo.selectSlotReverse = tempPictureIdList[picId]
|
|
else
|
|
itemInfo.selectSlot = math.mininteger
|
|
itemInfo.selectSlotReverse = math.maxinteger
|
|
end
|
|
end
|
|
|
|
local keys = isIncremental and optData.reverseKeys or optData.keys
|
|
self:_SortData(itemInfoList, keys, isIncremental)
|
|
self.m_select2Cell = {}
|
|
self.cell2Select = {}
|
|
for cellIndex, info in pairs(itemInfoList) do
|
|
local cellPicId = info.posterData.pictureId
|
|
local selectIndex = tempPictureIdList[cellPicId]
|
|
if selectIndex then
|
|
self.m_select2Cell[selectIndex] = cellIndex
|
|
self.cell2Select[cellIndex] = selectIndex
|
|
end
|
|
end
|
|
return itemInfoList
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._ApplyFilter = HL.Method(HL.Table, HL.Table).Return(HL.Table)
|
|
<< function(self, itemInfoList, selectedTags)
|
|
local filteredList = {}
|
|
local tempPictureIdList = {}
|
|
for selectIndex, cellIndex in pairs(self.m_select2Cell) do
|
|
local item = itemInfoList[cellIndex]
|
|
local picId = item.posterData.pictureId
|
|
tempPictureIdList[picId] = selectIndex
|
|
end
|
|
|
|
for _, itemInfo in pairs(itemInfoList) do
|
|
if FilterUtils.checkIfPassFilter(itemInfo, selectedTags) or
|
|
tempPictureIdList[itemInfo.posterData.pictureId] ~= nil
|
|
then
|
|
table.insert(filteredList, itemInfo)
|
|
end
|
|
end
|
|
self:_SortData(itemInfoList, self.m_sortOptData, self.m_sortIsIncremental)
|
|
|
|
self.m_select2Cell = {}
|
|
self.cell2Select = {}
|
|
for cellIndex, info in pairs(filteredList) do
|
|
local cellPicId = info.posterData.pictureId
|
|
local selectIndex = tempPictureIdList[cellPicId]
|
|
if selectIndex then
|
|
self.m_select2Cell[selectIndex] = cellIndex
|
|
self.cell2Select[cellIndex] = selectIndex
|
|
end
|
|
end
|
|
|
|
return filteredList
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._RefreshPicList = HL.Method(HL.Opt(HL.Boolean, HL.Table)) << function(self, setTop, targetItems)
|
|
local count = #targetItems
|
|
self.view.pictureScroll:UpdateCount(count, setTop or false)
|
|
self:_UpdateRedDotByInfoList()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._OnSavePicture = HL.Method() << function(self)
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_SS_POSTER_SAVE_POPUP)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._UpdateRedDotByInfoList = HL.Method(HL.Opt(HL.Table)) << function(self, args)
|
|
self.m_pictureRedDots = {}
|
|
for index, info in ipairs(self.m_filteredInfoList) do
|
|
local cellPicId = info.posterData.pictureId
|
|
local isOld = GameInstance.player.spaceship:GetPictureRedDotReadState(cellPicId)
|
|
if not isOld then
|
|
self.m_pictureRedDots[index] = cellPicId
|
|
end
|
|
end
|
|
self:_UpdateRedDot()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._UpdateRedDot = HL.Method() << function(self)
|
|
if not self.m_pictureRedDots then
|
|
self:_UpdateRedDotByInfoList()
|
|
end
|
|
local start, final = self:_GetShowingCellStartEnd()
|
|
local needRedDot = false
|
|
for i, picId in pairs(self.m_pictureRedDots) do
|
|
if i > LuaIndex(final) then
|
|
needRedDot = true
|
|
break
|
|
end
|
|
end
|
|
self.view.redDot.gameObject:SetActive(needRedDot)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipReceptionDisplayCtrl._GetShowingCellStartEnd = HL.Method().Return(HL.Number,HL.Number) << function(self)
|
|
local totalCount = lume.count(self.m_filteredInfoList)
|
|
local scrollRect = self.view.pictureScroll.transform.rect
|
|
local cellRect = self.view.ssPictureCell.gameObject.transform.rect
|
|
local scrollSpace = self.view.pictureScroll.space
|
|
local rowCount = math.floor(scrollRect.width / (cellRect.width + scrollSpace.x))
|
|
local calCount = math.ceil(totalCount / rowCount)
|
|
local showCount = math.floor(math.min(totalCount, (scrollRect.height) / (cellRect.height + scrollSpace.y))) * rowCount
|
|
local scrollNormal = math.min(math.max((self.view.container.transform.anchoredPosition.y / self.view.container.rect.height), 0), 1)
|
|
local start = math.ceil(calCount * scrollNormal * rowCount)
|
|
local final = start + showCount
|
|
return start, final
|
|
end
|
|
|
|
HL.Commit(SpaceshipReceptionDisplayCtrl)
|