485 lines
17 KiB
Lua
485 lines
17 KiB
Lua
local MAX_REPORT_COUNT = 3
|
|
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.SpaceshipDailyReport
|
|
local PHASE_ID = PhaseId.SpaceshipDailyReport
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl = HL.Class('SpaceshipDailyReportCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
|
|
}
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_reportInfos = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_reportBackBindingIds = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_isScrollInit = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_curIndex = HL.Field(HL.Number) << -1
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_dayTabCache = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_focusBindingIds = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipDailyReportCtrl.m_getReportCell = HL.Field(HL.Function)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.closeBtn.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PHASE_ID)
|
|
end)
|
|
|
|
self.view.btnLeft.onClick:AddListener(function()
|
|
self:_ChangeToDay(self.m_curIndex + 1)
|
|
end)
|
|
self.view.btnRight.onClick:AddListener(function()
|
|
self:_ChangeToDay(self.m_curIndex - 1)
|
|
end)
|
|
|
|
self.m_dayTabCache = UIUtils.genCellCache(self.view.dayTabCell)
|
|
self.m_getReportCell = UIUtils.genCachedCellFunction(self.view.scrollViewScrollList)
|
|
|
|
self:_InitData()
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
|
|
end
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._InitData = HL.Method() << function(self)
|
|
self.m_reportInfos = {}
|
|
self.m_reportBackBindingIds = {}
|
|
self.m_focusBindingIds = {}
|
|
local curDayStartTimestamp = DateTimeUtils.GetServerCurBelongedDayStartTimestamp()
|
|
local secondsPerDay = 24 * 3600
|
|
local dayStartTimestamps = {}
|
|
local roomReportInfoByTs = {}
|
|
for k = 1, MAX_REPORT_COUNT do
|
|
local ts = curDayStartTimestamp - (k - 1) * secondsPerDay
|
|
table.insert(dayStartTimestamps, ts)
|
|
roomReportInfoByTs[ts] = {}
|
|
end
|
|
local rooms = GameInstance.player.spaceship:GetRoomsWithSort()
|
|
for i = CSIndex(1), CSIndex(rooms.Count) do
|
|
local data = rooms[i]
|
|
local roomId = rooms[i].id
|
|
if data.roomType == GEnums.SpaceshipRoomType.GuestRoom then
|
|
goto continue
|
|
end
|
|
local haveTodayReport = false
|
|
local isCC = data.roomType == GEnums.SpaceshipRoomType.ControlCenter
|
|
for ts, report in pairs(data.reports) do
|
|
if roomReportInfoByTs[ts] then
|
|
if ts == curDayStartTimestamp then
|
|
haveTodayReport = true
|
|
end
|
|
table.insert(roomReportInfoByTs[ts], {
|
|
id = roomId,
|
|
isCC = isCC,
|
|
sortId = i,
|
|
data = data,
|
|
report = report,
|
|
})
|
|
end
|
|
end
|
|
|
|
if not haveTodayReport then
|
|
table.insert(roomReportInfoByTs[curDayStartTimestamp], {
|
|
id = roomId,
|
|
isCC = isCC,
|
|
sortId = i,
|
|
data = data,
|
|
})
|
|
end
|
|
::continue::
|
|
end
|
|
|
|
for k, ts in ipairs(dayStartTimestamps) do
|
|
local roomReports = roomReportInfoByTs[ts]
|
|
if next(roomReports) then
|
|
table.sort(roomReports, Utils.genSortFunction({ "sortId"}, true))
|
|
table.insert(self.m_reportInfos, {
|
|
ts = ts,
|
|
roomReports = roomReports,
|
|
})
|
|
end
|
|
end
|
|
|
|
local dayCount = #self.m_reportInfos
|
|
self.m_dayTabCache:Refresh(dayCount)
|
|
|
|
self:_ChangeToDay(1)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._ChangeToDay = HL.Method(HL.Number) << function(self, index)
|
|
if self.m_curIndex == index and not self.m_isScrollInit then
|
|
return
|
|
end
|
|
self.m_isScrollInit = true
|
|
self.m_curIndex = index
|
|
self.m_dayTabCache:Get(index).toggle.isOn = true
|
|
self:_RefreshRoomCells()
|
|
self:_RefreshBottom()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._RefreshRoomCells = HL.Method() << function(self)
|
|
local info = self.m_reportInfos[self.m_curIndex]
|
|
self.view.scrollViewScrollList.onUpdateCell:AddListener(function(obj, csIndex)
|
|
local cell = self.m_getReportCell(obj)
|
|
self:_OnUpdateRoomCell(cell, LuaIndex(csIndex))
|
|
end)
|
|
self.view.scrollViewScrollList:UpdateCount(#info.roomReports, true)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._RefreshBottom = HL.Method() << function(self)
|
|
local info = self.m_reportInfos[self.m_curIndex]
|
|
local isToday = self.m_curIndex == 1
|
|
|
|
self.view.todayHint.gameObject:SetActive(isToday)
|
|
self.view.btnLeft.interactable = self.m_curIndex < #self.m_reportInfos
|
|
self.view.btnRight.interactable = self.m_curIndex > 1
|
|
|
|
local dateNode = self.view.dateNode
|
|
dateNode.animationWrapper:PlayInAnimation()
|
|
dateNode.simpleStateController:SetState(isToday and "Today" or "NotToday")
|
|
|
|
local offsetSeconds = Utils.getServerTimeZoneOffsetSeconds()
|
|
dateNode.dateTxt.text = os.date("!%m.%d", info.ts + offsetSeconds)
|
|
dateNode.todayImg.gameObject:SetActive(isToday)
|
|
if isToday then
|
|
dateNode.startTimeTxt.text = string.format("%02d:00", DateTimeUtils.GAME_DAY_DIVISION_HOUR)
|
|
local curTs = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
local cutTxt = os.date("!%H:%M", curTs + Utils.getServerTimeZoneOffsetSeconds())
|
|
if curTs - info.ts >= (24 - DateTimeUtils.GAME_DAY_DIVISION_HOUR) * 3600 then
|
|
cutTxt = cutTxt .. "(+1)"
|
|
end
|
|
dateNode.curTimeTxt.text = cutTxt
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._OnUpdateRoomCell = HL.Method(HL.Table, HL.Number) << function(self, cell, index)
|
|
local info = self.m_reportInfos[self.m_curIndex].roomReports[index]
|
|
local roomInfo = info.data
|
|
local roomTypeData = Tables.spaceshipRoomTypeTable[info.data.roomType]
|
|
cell.icon:LoadSprite(UIConst.UI_SPRITE_SPACESHIP_ROOM, roomTypeData.icon)
|
|
cell.nameTxt.text = SpaceshipUtils.getFormatCabinSerialNum(roomInfo.id, roomInfo.serialNum)
|
|
cell.iconBg.color = UIUtils.getColorByString(roomTypeData.color)
|
|
cell.gameObject.name = index
|
|
|
|
local typeTxtStr = SpaceshipConst.TYPE_TXT_MAP[roomInfo.type]
|
|
if typeTxtStr then
|
|
cell.typeNode.gameObject:SetActive(true)
|
|
cell.typeTxt.text = typeTxtStr
|
|
else
|
|
cell.typeNode.gameObject:SetActive(false)
|
|
end
|
|
|
|
local isToday = self.m_curIndex == 1
|
|
if not cell.m_charCells then
|
|
cell.m_charCells = UIUtils.genCellCache(cell.charCell)
|
|
end
|
|
|
|
local chars = {}
|
|
local stationedChars = {}
|
|
local charDivideLineIndex
|
|
local maxCount = roomInfo.maxLvStationCount
|
|
local curMaxCount = roomInfo.maxStationCharNum
|
|
local curCount = roomInfo.stationedCharList.Count
|
|
if isToday then
|
|
for k = 1, maxCount do
|
|
local cInfo = {}
|
|
if k <= curCount then
|
|
cInfo.charId = roomInfo.stationedCharList[CSIndex(k)]
|
|
stationedChars[cInfo.charId] = true
|
|
elseif k <= curMaxCount then
|
|
cInfo.isEmpty = true
|
|
else
|
|
cInfo.isLocked = true
|
|
end
|
|
table.insert(chars, cInfo)
|
|
end
|
|
charDivideLineIndex = maxCount
|
|
if info.report then
|
|
for _, charId in pairs(info.report.charWorkRecord) do
|
|
if not stationedChars[charId] then
|
|
table.insert(chars, { charId = charId })
|
|
end
|
|
end
|
|
end
|
|
else
|
|
local showCount = math.max(info.report and info.report.charWorkRecord.Count or 0, 1)
|
|
for k = 1, showCount do
|
|
local cInfo = {}
|
|
local charId = info.report and info.report.charWorkRecord.Count >= k and info.report.charWorkRecord[CSIndex(k)]
|
|
if info.report and charId then
|
|
cInfo.charId = charId
|
|
else
|
|
cInfo.isEmpty = true
|
|
end
|
|
table.insert(chars, cInfo)
|
|
end
|
|
end
|
|
|
|
self.m_focusBindingIds[index] = self:BindInputPlayerAction("ss_focus_item", function()
|
|
Notify(MessageConst.SHOW_AS_CONTROLLER_SMALL_MENU, {
|
|
panelId = PANEL_ID,
|
|
isGroup = true,
|
|
id = cell.targetInputBindingGroupMonoTarget.groupId,
|
|
noHighlight = false,
|
|
useNormalFrame = true,
|
|
rectTransform = cell.focusNode,
|
|
})
|
|
cell.targetSelectableNaviGroup:NaviToThisGroup(true)
|
|
InputManagerInst:ToggleBinding(self.m_reportBackBindingIds[index], true)
|
|
end, cell.inputBindingGroupMonoTarget.groupId)
|
|
|
|
self.m_reportBackBindingIds[index] = self:BindInputPlayerAction("common_back", function()
|
|
Notify(MessageConst.CLOSE_CONTROLLER_SMALL_MENU, cell.targetInputBindingGroupMonoTarget.groupId)
|
|
InputManagerInst:ToggleBinding(self.m_reportBackBindingIds[index], false)
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.inputBindingGroupNaviDecorator)
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
Notify(MessageConst.HIDE_SPACESHIP_CHAR_TIPS)
|
|
end, cell.targetInputBindingGroupMonoTarget.groupId)
|
|
|
|
InputManagerInst:ToggleBinding(self.m_reportBackBindingIds[index], false)
|
|
InputManagerInst:ToggleBinding(self.m_focusBindingIds[index], false)
|
|
|
|
cell.inputBindingGroupNaviDecorator.onGroupSetAsNaviTarget:RemoveAllListeners()
|
|
cell.inputBindingGroupNaviDecorator.onGroupSetAsNaviTarget:AddListener(function(select)
|
|
local haveReport = false
|
|
if info.report and info.report.charWorkRecord and info.report.outputs then
|
|
haveReport = info.report.charWorkRecord.Count > 0 or info.report.outputs.Count > 0
|
|
end
|
|
InputManagerInst:ToggleBinding(self.m_focusBindingIds[index], select and haveReport)
|
|
cell.charNode.controllerScrollEnabled = select
|
|
end)
|
|
|
|
cell.charNode.content.pivot = #chars > 10 and Vector2(0,0.5) or Vector2(0.5,0.5)
|
|
cell.m_charCells:Refresh(#chars, function(charCell, charIndex)
|
|
self:_OnUpdateCharCell(charCell, chars[charIndex], info)
|
|
charCell.transform:SetSiblingIndex(CSIndex(charIndex))
|
|
end)
|
|
if charDivideLineIndex and #chars > charDivideLineIndex then
|
|
cell.charDivideLine.gameObject:SetActive(true)
|
|
cell.charDivideLine.transform:SetSiblingIndex(charDivideLineIndex)
|
|
else
|
|
cell.charDivideLine.gameObject:SetActive(false)
|
|
end
|
|
local items = {}
|
|
if info.isCC then
|
|
cell.emptyHint.gameObject:SetActive(false)
|
|
cell.itemNode.gameObject:SetActive(false)
|
|
else
|
|
if info.report then
|
|
for itemId, count in pairs(info.report.outputs) do
|
|
local itemData = Tables.itemTable[itemId]
|
|
table.insert(items, {
|
|
id = itemId,
|
|
count = count,
|
|
sortId1 = itemData.sortId1,
|
|
sortId2 = itemData.sortId2,
|
|
rarity = itemData.rarity,
|
|
})
|
|
end
|
|
table.sort(items, Utils.genSortFunction(UIConst.COMMON_ITEM_SORT_KEYS))
|
|
end
|
|
if not cell.m_itemCells then
|
|
cell.m_itemCells = UIUtils.genCellCache(cell.item)
|
|
end
|
|
if next(items) then
|
|
cell.emptyHint.gameObject:SetActive(false)
|
|
cell.itemNode.gameObject:SetActive(true)
|
|
cell.m_itemCells:Refresh(#items, function(itemCell, itemIndex)
|
|
itemCell:InitItem(items[itemIndex], function()
|
|
itemCell:ShowTips()
|
|
Notify(MessageConst.HIDE_SPACESHIP_CHAR_TIPS)
|
|
end)
|
|
if DeviceInfo.usingController then
|
|
itemCell:SetEnableHoverTips(false)
|
|
itemCell:SetExtraInfo({
|
|
isSideTips = true,
|
|
})
|
|
end
|
|
end)
|
|
|
|
if DeviceInfo.usingController then
|
|
cell.targetSelectableNaviGroup.onIsFocusedChange:AddListener(function(isFocused)
|
|
if not isFocused then
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
Notify(MessageConst.HIDE_SPACESHIP_CHAR_TIPS)
|
|
end
|
|
end)
|
|
end
|
|
else
|
|
cell.emptyHint.gameObject:SetActive(true)
|
|
cell.itemNode.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
LayoutRebuilder.ForceRebuildLayoutImmediate(cell.charNode.content)
|
|
if #chars > 0 then
|
|
cell.charNode:ScrollToNaviTarget(cell.m_charCells:GetItem(1).charHead.view.button)
|
|
end
|
|
|
|
cell.targetSelectableNaviGroup.getDefaultSelectableFunc = function()
|
|
for i, v in ipairs(chars) do
|
|
if v.charId then
|
|
return cell.m_charCells:GetItem(i).charHead.view.button
|
|
end
|
|
end
|
|
for i, v in ipairs(items) do
|
|
if v.id then
|
|
return cell.m_itemCells:GetItem(i).view.button
|
|
end
|
|
end
|
|
end
|
|
if index == 1 and self.m_isScrollInit then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.inputBindingGroupNaviDecorator)
|
|
cell.charNode.controllerScrollEnabled = true
|
|
self.m_isScrollInit = false
|
|
else
|
|
cell.charNode.controllerScrollEnabled = false
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._OnUpdateCharCell = HL.Method(HL.Table, HL.Table, HL.Table) << function(self, charCell, info, roomReport)
|
|
charCell.friendshipChangeNode.gameObject:SetActive(false)
|
|
|
|
charCell.charHead.view.emptyState.onGroupSetAsNaviTarget:RemoveAllListeners()
|
|
charCell.charHead.view.emptyState.onGroupSetAsNaviTarget:AddListener(function(select)
|
|
if select then
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
Notify(MessageConst.HIDE_SPACESHIP_CHAR_TIPS)
|
|
end
|
|
end)
|
|
if info.isLocked then
|
|
charCell.charHead.view.simpleStateController:SetState("Locked")
|
|
if roomReport.isCC then
|
|
charCell.friendshipChangeNode.gameObject:SetActive(true)
|
|
charCell.friendshipChangeNode:SetState("Empty")
|
|
end
|
|
return
|
|
elseif info.isEmpty then
|
|
charCell.charHead.view.simpleStateController:SetState("Empty")
|
|
if roomReport.isCC then
|
|
charCell.friendshipChangeNode.gameObject:SetActive(true)
|
|
charCell.friendshipChangeNode:SetState("Empty")
|
|
end
|
|
return
|
|
end
|
|
charCell.charHead.view.simpleStateController:SetState("Normal")
|
|
|
|
local charId = info.charId
|
|
local isSideTips = DeviceInfo.usingController
|
|
charCell.charHead:InitSSCharHeadCell({
|
|
charId = charId,
|
|
targetRoomId = roomReport.id,
|
|
onClick = function()
|
|
charCell.charHead.view.selectNode.gameObject:SetActive(true)
|
|
Notify(MessageConst.HIDE_ITEM_TIPS)
|
|
Notify(MessageConst.SHOW_SPACESHIP_CHAR_TIPS, {
|
|
key = charCell.transform,
|
|
charId = charId,
|
|
transform = charCell.tipsTarget.transform,
|
|
onClose = function()
|
|
if not IsNull(charCell.charHead.view.selectNode)then
|
|
charCell.charHead.view.selectNode.gameObject:SetActive(false)
|
|
end
|
|
end,
|
|
isSideTips = isSideTips,
|
|
posType = UIConst.UI_TIPS_POS_TYPE.LeftDown,
|
|
ignoreWorkNode = true,
|
|
})
|
|
end,
|
|
hideStaminaNode = true,
|
|
})
|
|
|
|
if not roomReport.isCC then
|
|
return
|
|
end
|
|
charCell.friendshipChangeNode.gameObject:SetActive(true)
|
|
charCell.friendshipChangeNode:SetState("Num")
|
|
|
|
local curFriendship = GameInstance.player.spaceship.characters:get_Item(charId).friendship
|
|
for k = 1, self.m_curIndex - 1 do
|
|
local otherDayTs = self.m_reportInfos[k].ts
|
|
local succ, r = roomReport.data.reports:TryGetValue(otherDayTs)
|
|
if succ then
|
|
local succ2, addedValue = r.outputs:TryGetValue(charId)
|
|
if succ2 then
|
|
curFriendship = curFriendship - addedValue
|
|
end
|
|
end
|
|
end
|
|
|
|
local finalPercent = math.floor(CSPlayerDataUtil.GetFriendshipPercent(curFriendship) * 100)
|
|
local addedValue
|
|
if roomReport.report then
|
|
_, addedValue = roomReport.report.outputs:TryGetValue(charId)
|
|
end
|
|
local startPercent = math.floor(CSPlayerDataUtil.GetFriendshipPercent(curFriendship - (addedValue or 0)) * 100)
|
|
charCell.friendshipTxt.text = string.format(Language.LUA_SPACESHIP_CHAR_FRIENDSHIP_FORMAT, finalPercent)
|
|
charCell.addedFriendshipTxt.text = string.format(Language.LUA_SPACESHIP_CHAR_FRIENDSHIP_FORMAT, startPercent)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipDailyReportCtrl._OnPanelInputBlocked = HL.Override(HL.Boolean) << function(self, active)
|
|
if DeviceInfo.usingController then
|
|
self.view.keyHintLeft.gameObject:SetActive(active)
|
|
self.view.keyHintRight.gameObject:SetActive(active)
|
|
end
|
|
end
|
|
|
|
HL.Commit(SpaceshipDailyReportCtrl)
|