555 lines
18 KiB
Lua
555 lines
18 KiB
Lua
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.SpaceshipControlCenter
|
|
local PHASE_ID = PhaseId.SpaceshipControlCenter
|
|
|
|
local HelpedStateByRoomType = {
|
|
[GEnums.SpaceshipRoomType.ControlCenter] = "MoodRecovery",
|
|
[GEnums.SpaceshipRoomType.ManufacturingStation] = "FastMade",
|
|
[GEnums.SpaceshipRoomType.GrowCabin] = "ExtraProducts",
|
|
[GEnums.SpaceshipRoomType.CommandCenter] = "FastAction",
|
|
[GEnums.SpaceshipRoomType.GuestRoomClueExtension] = "ExtraRewards",
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl = HL.Class('SpaceshipControlCenterCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
SpaceshipControlCenterCtrl.m_roomCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
SpaceshipControlCenterCtrl.m_roomIndexTab = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipControlCenterCtrl.m_nowNaviRoomCell = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipControlCenterCtrl.m_visitorHelpBindingId = HL.Field(HL.Number) << -1
|
|
|
|
|
|
SpaceshipControlCenterCtrl.m_isFriend = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.SPACESHIP_ON_SYNC_ROOM_STATION] = 'OnSyncRoomStation',
|
|
[MessageConst.SPACESHIP_ON_ROOM_LEVEL_UP] = '_RefreshRooms',
|
|
[MessageConst.ON_SPACESHIP_HELP_ROOM] = 'OnSSHelpRoom',
|
|
[MessageConst.ON_SPACESHIP_USE_HELP_CREDIT] = 'OnUseHelpCredit',
|
|
[MessageConst.ON_SPACESHIP_GROW_CABIN_HARVEST] = "OnSpaceshipGrowCabinHelped",
|
|
[MessageConst.ON_SPACESHIP_ASSIST_DATA_MODIFY] = "OnRefreshFriendData",
|
|
[MessageConst.ON_SPACESHIP_JOIN_FRIEND_INFO_EXCHANGE] = "OnRefreshFriendData",
|
|
[MessageConst.ON_SPACESHIP_GUEST_ROOM_CLUE_REWARD_ITEM] = 'OnSpaceshipGuestRoomClueRewardItem',
|
|
[MessageConst.ON_SPACESHIP_CLUE_INFO_SYNC] = 'OnRefreshFriendData',
|
|
}
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OpenControlCenter = HL.StaticMethod() << function()
|
|
PhaseManager:OpenPhase(PhaseId.SpaceshipControlCenter)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.closeBtn.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PhaseId.SpaceshipControlCenter)
|
|
end)
|
|
if not GameInstance.player.spaceship.isViewingFriend then
|
|
self:BindInputPlayerAction("ss_open_control_center", function()
|
|
PhaseManager:PopPhase(PhaseId.SpaceshipControlCenter)
|
|
end)
|
|
end
|
|
|
|
self.view.reportBtn.onClick:AddListener(function()
|
|
PhaseManager:OpenPhase(PhaseId.SpaceshipDailyReport)
|
|
end)
|
|
if GameInstance.player.spaceship.isViewingFriend then
|
|
self.view.assistCtrlNode:SetState("Visitors")
|
|
self.m_isFriend = true
|
|
self.view.moneyCell.view.gainNode.gameObject:SetActive(false)
|
|
self:_SetFriendState()
|
|
else
|
|
self.view.assistCtrlNode:SetState("Owner")
|
|
self.m_isFriend = false
|
|
self:_SetSelfState()
|
|
end
|
|
self.m_roomCells = UIUtils.genCellCache(self.view.roomNode.roomCell)
|
|
self:_RefreshRooms()
|
|
self.view.redDotArrow:InitRedDot("SSControlCenterRoot", self.m_roomIndexTab)
|
|
if GameInstance.player.spaceship.isViewingFriend and self.m_visitorHelpBindingId == -1 then
|
|
self.m_visitorHelpBindingId = self:BindInputPlayerAction("ss_help_friend_room", function()
|
|
if self.m_nowNaviRoomCell then
|
|
AudioManager.PostEvent("Au_UI_Button_Produce")
|
|
self.m_nowNaviRoomCell.visitorsNode.helpBtn.onClick:Invoke()
|
|
end
|
|
end)
|
|
end
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
|
|
end
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnClose = HL.Override() << function(self)
|
|
|
|
end
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnShow = HL.Override() << function(self)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnRoomCellNaviTargetChange = HL.Method(HL.Opt(HL.Table, HL.Boolean, HL.String))
|
|
<< function(self, cell, canHelp, roomId)
|
|
self.m_nowNaviRoomCell = cell
|
|
self.m_nowNaviRoomCell.roomId = roomId
|
|
self:_RefreshBinding(canHelp, roomId)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._RefreshBinding = HL.Method(HL.Boolean, HL.String) << function(self, canHelp, roomId)
|
|
if not self.m_nowNaviRoomCell or self.m_nowNaviRoomCell.roomId ~= roomId then
|
|
return
|
|
end
|
|
if self.m_visitorHelpBindingId ~= -1 then
|
|
InputManagerInst:ToggleBinding(self.m_visitorHelpBindingId, canHelp)
|
|
if roomId == Tables.spaceshipConst.guestRoomClueExtensionId then
|
|
InputManagerInst:SetBindingText(self.m_visitorHelpBindingId, Language.ui_spaceship_controlcenter_visitornode_swapbtn_swaptext)
|
|
else
|
|
InputManagerInst:SetBindingText(self.m_visitorHelpBindingId, Language.key_hint_ss_help_friend_room)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._SetSelfState = HL.Method() << function(self)
|
|
if GameInstance.player.spaceship.isViewingFriend then
|
|
return
|
|
end
|
|
self.view.friendAssistNode:InitFriendAssistNode(Tables.spaceshipConst.controlCenterRoomId)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._SetFriendState = HL.Method() << function(self)
|
|
local spaceship = GameInstance.player.spaceship
|
|
if not spaceship.isViewingFriend then
|
|
return
|
|
end
|
|
local rewardItem = Tables.rewardTable[Tables.spaceshipConst.visitorHelpRewardId].itemBundles[CSIndex(1)]
|
|
local itemId = rewardItem.id
|
|
SpaceshipUtils.InitMoneyLimitCell(self.view.moneyCell, itemId)
|
|
local friendInfo = spaceship:GetFriendRoleInfo()
|
|
if friendInfo then
|
|
self.view.playerNameNode:InitSocializeFriendName(friendInfo.roleId)
|
|
end
|
|
|
|
local clueData = spaceship:GetClueData(CS.Beyond.Gameplay.SpaceshipEnums.SpaceshipDataType.Self)
|
|
self.view.assistHintNode.swapMessNode.gameObject:SetActive(clueData ~= nil)
|
|
if clueData then
|
|
local swapTime = Tables.spaceshipConst.joinInfoExchangeCountLimit - (clueData.joinFriendExchangeCnt or 0)
|
|
self.view.assistHintNode.swapTimesTxt.text = string.format("%d/%d", swapTime, Tables.spaceshipConst.joinInfoExchangeCountLimit)
|
|
end
|
|
|
|
self.view.assistHintNode.detailBtn.onClick:RemoveAllListeners()
|
|
self.view.assistHintNode.detailBtn.onClick:AddListener(function()
|
|
UIManager:Open(PanelId.InstructionBook, "control_center_help_rule")
|
|
end)
|
|
self:_SetTimeText()
|
|
self:_StartCoroutine(function()
|
|
while true do
|
|
coroutine.wait(UIConst.COMMON_UI_TIME_UPDATE_INTERVAL)
|
|
self:_SetTimeText()
|
|
end
|
|
end)
|
|
local isHelpDone = spaceship.helpOtherCount >= Tables.spaceshipConst.helpOthersCountLimit
|
|
self.view.assistHintNode.dayLimitNode:SetState(isHelpDone and "tomorrow" or "today")
|
|
self.view.assistHintNode.assistTimesTxt.text = string.format("%d/%d", spaceship.helpOtherRemainCount, Tables.spaceshipConst.helpOthersCountLimit)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnSSHelpRoom = HL.Method(HL.Opt(HL.Table)) << function(self, arg)
|
|
local roomId = arg and arg[1] or Tables.spaceshipConst.controlCenterRoomId
|
|
local success = arg and arg[2] or false
|
|
self:_RefreshGainNode(roomId, success)
|
|
self:_SetFriendState()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnUseHelpCredit = HL.Method(HL.Opt(HL.Table)) << function(self, arg)
|
|
self:_SetSelfState()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnRefreshFriendData = HL.Method(HL.Opt(HL.Any)) << function(self, args)
|
|
if not self.m_isFriend then
|
|
return
|
|
end
|
|
self:_SetFriendState()
|
|
self:_RefreshRooms()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnSpaceshipGuestRoomClueRewardItem = HL.Method(HL.Any) << function(self, args)
|
|
local items, sources = unpack(args)
|
|
SpaceshipUtils.ShowClueOutcomePopup(items, sources, self.view.moneyCell, nil)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._RefreshGainNode = HL.Method(HL.String, HL.Boolean) << function(self, roomId, success)
|
|
if success then
|
|
local rewardItem = Tables.rewardTable[Tables.spaceshipConst.visitorHelpRewardId].itemBundles[CSIndex(1)]
|
|
local itemCount = rewardItem.count
|
|
local itemId = rewardItem.id
|
|
SpaceshipUtils.PlayMoneyNodeGainAnim(self.view.moneyCell, itemId, itemCount)
|
|
end
|
|
local rooms = GameInstance.player.spaceship:GetRoomsWithSort()
|
|
local itemIndex = 1
|
|
for i = CSIndex(1), CSIndex(rooms.Count) do
|
|
local info = rooms[i]
|
|
local roomId = rooms[i].id
|
|
if info.type == GEnums.SpaceshipRoomType.GuestRoom then
|
|
goto continue
|
|
end
|
|
if info.type ~= GEnums.SpaceshipRoomType.ControlCenter then
|
|
self:_RefreshRoomGainNode(self.m_roomCells:GetItem(itemIndex) , roomId, true)
|
|
itemIndex = itemIndex + 1
|
|
else
|
|
self:_RefreshRoomGainNode(self.view[roomId] , roomId, true)
|
|
end
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._RefreshRoomGainNode = HL.Method(HL.Table, HL.String, HL.Opt(HL.Boolean)) << function(self, cell, roomId, refreshNode)
|
|
cell.visitorsNode.gainNode.gameObject:SetActive(true)
|
|
|
|
local itemCount = 0
|
|
if roomId == Tables.spaceshipConst.guestRoomClueExtensionId then
|
|
local clueData = GameInstance.player.spaceship:GetClueData(CS.Beyond.Gameplay.SpaceshipEnums.SpaceshipDataType.Friend)
|
|
if clueData ~= nil then
|
|
local success, data = Tables.spaceshipGuestRoomClueLvTable:TryGetValue(clueData.clueRoomLevel)
|
|
if success then
|
|
itemCount = data.creditFriendJoinExchangeGain
|
|
end
|
|
end
|
|
else
|
|
local rewardItem = Tables.rewardTable[Tables.spaceshipConst.visitorHelpRewardId].itemBundles[CSIndex(1)]
|
|
itemCount = rewardItem.count
|
|
end
|
|
cell.visitorsNode.creditTxt.text = string.format("+%d", itemCount)
|
|
if refreshNode then
|
|
self:_RefreshVisitorNode(cell, roomId)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._SetTimeText = HL.Method() << function(self)
|
|
local targetTime = Utils.getNextCommonServerRefreshTime()
|
|
local curTime = DateTimeUtils.GetCurrentTimestampBySeconds()
|
|
local leftSec = targetTime - curTime
|
|
self.view.assistHintNode.refreshTimesTxt.text = UIUtils.getLeftTimeToSecond(leftSec)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnSyncRoomStation = HL.Method() << function(self)
|
|
self:_RefreshRooms()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._RefreshRooms = HL.Method(HL.Opt(HL.Any)) << function(self, _)
|
|
local roomCount = GameInstance.player.spaceship.rooms.Count - 1
|
|
local hasValue, _ = GameInstance.player.spaceship:TryGetRoom(Tables.spaceshipConst.guestRoomId)
|
|
if hasValue then
|
|
roomCount = roomCount - 1
|
|
end
|
|
self.m_roomCells:Refresh(roomCount)
|
|
local itemIndex = 1
|
|
self.m_roomIndexTab = {}
|
|
|
|
local rooms = GameInstance.player.spaceship:GetRoomsWithSort()
|
|
for i = CSIndex(1), CSIndex(rooms.Count) do
|
|
local info = rooms[i]
|
|
local roomId = rooms[i].id
|
|
if info.type == GEnums.SpaceshipRoomType.GuestRoom then
|
|
goto continue
|
|
end
|
|
if info.type ~= GEnums.SpaceshipRoomType.ControlCenter then
|
|
self:_UpdateRoomCell(self.m_roomCells:GetItem(itemIndex) , roomId)
|
|
self.m_roomIndexTab[roomId] = itemIndex
|
|
itemIndex = itemIndex + 1
|
|
else
|
|
self:_UpdateRoomCell(self.view[roomId] , roomId)
|
|
end
|
|
::continue::
|
|
end
|
|
if self.m_isFriend then
|
|
return
|
|
end
|
|
local succ, roomInfo = GameInstance.player.spaceship:TryGetRoom(Tables.spaceshipConst.controlCenterRoomId)
|
|
if not succ then
|
|
return
|
|
end
|
|
self.view.roomEffectInfoNode:InitSSRoomEffectInfoNode({
|
|
attrsMap = roomInfo.attrsMap,
|
|
color = SpaceshipUtils.getRoomColor(roomInfo.id),
|
|
})
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._UpdateRoomCell = HL.Method(HL.Table, HL.String) << function(self, cell, roomId)
|
|
local succ, roomInfo = GameInstance.player.spaceship:TryGetRoom(roomId)
|
|
if not succ or not cell then
|
|
return
|
|
end
|
|
local roomTypeData = Tables.spaceshipRoomTypeTable[roomInfo.type]
|
|
cell.ownerButton.enabled = true
|
|
cell.ownerButton.onClick:RemoveAllListeners()
|
|
cell.ownerButton.onClick:AddListener(function()
|
|
if roomInfo.type == GEnums.SpaceshipRoomType.ControlCenter then
|
|
PhaseManager:OpenPhase(PhaseId.SpaceshipStation, { roomId = roomId })
|
|
else
|
|
local phaseId = PhaseId[SpaceshipConst.ROOM_PHASE_ID_NAME_MAP_BY_TYPE[roomInfo.type]]
|
|
PhaseManager:OpenPhase(phaseId, { roomId = roomId, moveCam = false, })
|
|
end
|
|
end)
|
|
|
|
local node = cell.contentNode
|
|
node.icon:LoadSprite(UIConst.UI_SPRITE_SPACESHIP_ROOM, roomTypeData.icon)
|
|
node.iconColorBG.color = UIUtils.getColorByString(roomTypeData.color)
|
|
node.nameTxt.text = SpaceshipUtils.getFormatCabinSerialNum(roomId, roomInfo.serialNum)
|
|
node.lvDotNode:InitLvDotNode(roomInfo.lv, roomInfo.maxLv, node.iconColorBG.color)
|
|
self:_UpdateRoomCellStation(cell, roomInfo)
|
|
cell.simpleStateController:SetState("Normal")
|
|
cell.visitorsNode.helpBtn.onClick:RemoveAllListeners()
|
|
cell.visitorsNode.helpBtn.onClick:AddListener(function()
|
|
GameInstance.player.spaceship:SpaceshipHelpRoom(roomId)
|
|
end)
|
|
cell.visitorsNode.swapBtn.onClick:RemoveAllListeners()
|
|
cell.visitorsNode.swapBtn.onClick:AddListener(function()
|
|
GameInstance.player.spaceship:SpaceshipHelpRoom(roomId)
|
|
end)
|
|
|
|
if GameInstance.player.spaceship.isViewingFriend then
|
|
cell.redDot.gameObject:SetActive(false)
|
|
else
|
|
if roomInfo.type == GEnums.SpaceshipRoomType.GrowCabin then
|
|
cell.redDot:InitRedDot("SSGrowCabin", roomId)
|
|
elseif roomInfo.type == GEnums.SpaceshipRoomType.ManufacturingStation then
|
|
cell.redDot:InitRedDot("SSManufacturingStation", roomId)
|
|
elseif roomInfo.type == GEnums.SpaceshipRoomType.GuestRoomClueExtension then
|
|
cell.redDot:InitRedDot("SSGuestRoomClue")
|
|
else
|
|
cell.redDot.gameObject:SetActive(false)
|
|
end
|
|
end
|
|
self:_RefreshVisitorNode(cell, roomId)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._RefreshVisitorNode = HL.Method(HL.Table, HL.String) << function(self, cell, roomId)
|
|
local spaceship = GameInstance.player.spaceship
|
|
if not spaceship.isViewingFriend then
|
|
return
|
|
end
|
|
local succ, roomInfo = spaceship:TryGetRoom(roomId)
|
|
if not succ then
|
|
return
|
|
end
|
|
|
|
local friendInfo = spaceship:GetFriendRoleInfo()
|
|
local isHelped = spaceship:CheckIsHelpOther(friendInfo.roleId, roomId)
|
|
local unableHelp = spaceship:CheckUnableHelpByRoomId(roomId)
|
|
local SpaceshipDataType = CS.Beyond.Gameplay.SpaceshipEnums.SpaceshipDataType
|
|
local clueData = spaceship:GetClueData(SpaceshipDataType.Self)
|
|
if isHelped then
|
|
cell.visitorsNode.visitorsNode:SetState(HelpedStateByRoomType[roomInfo.type])
|
|
self:_RefreshRoomGainNode(cell, roomId)
|
|
elseif unableHelp and roomId == Tables.spaceshipConst.guestRoomClueExtensionId then
|
|
if clueData then
|
|
if spaceship:GetJoinFriendCount(SpaceshipDataType.Self) >= Tables.spaceshipConst.joinInfoExchangeCountLimit then
|
|
cell.visitorsNode.visitorsNode:SetState("GuestroomClueCantHelp")
|
|
else
|
|
cell.visitorsNode.visitorsNode:SetState("DisableOpen")
|
|
end
|
|
else
|
|
cell.visitorsNode.visitorsNode:SetState("GuestroomClueLocked")
|
|
end
|
|
elseif unableHelp then
|
|
cell.visitorsNode.visitorsNode:SetState("DisableAssist")
|
|
elseif roomId == Tables.spaceshipConst.guestRoomClueExtensionId then
|
|
cell.visitorsNode.visitorsNode:SetState("MessSwap")
|
|
else
|
|
cell.visitorsNode.visitorsNode:SetState("AssistHelp")
|
|
end
|
|
local canHelp = not isHelped and not unableHelp
|
|
if self.m_visitorHelpBindingId ~= -1 then
|
|
self:_RefreshBinding(canHelp, roomId)
|
|
end
|
|
cell.visitorsNodeInputBindingGroupNaviDecorator.onIsNaviTargetChanged = function(isTarget)
|
|
if isTarget then
|
|
canHelp = not spaceship:CheckIsHelpOther(friendInfo.roleId, roomId) and not unableHelp
|
|
self:OnRoomCellNaviTargetChange(cell, canHelp, roomId)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl.OnSpaceshipGrowCabinHelped = HL.Method(HL.Any) << function(self, args)
|
|
if not GameInstance.player.spaceship.isViewingFriend then
|
|
return
|
|
end
|
|
local title = Language.LUA_SPACESHIP_ROOM_GROW_CABIN_HELP_OUTCOME_POPUP_TITLE
|
|
local items = unpack(args)
|
|
self:_ShowOutcomePopup(title, items)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._ShowOutcomePopup = HL.Method(HL.String, HL.Any) << function(self, title, csItems)
|
|
local itemMap = {}
|
|
for i = 0, csItems.Count - 1 do
|
|
local item = csItems[i]
|
|
|
|
if item.id == Tables.spaceshipConst.creditItemId then
|
|
goto continue
|
|
end
|
|
|
|
if itemMap[item.id or item.Id] then
|
|
local accCount = itemMap[item.id or item.Id]
|
|
itemMap[item.id or item.Id] = accCount + item.Count or 0 + item.count or 0
|
|
else
|
|
itemMap[item.id or item.Id] = item.Count or 0 + item.count or 0
|
|
end
|
|
::continue::
|
|
end
|
|
|
|
local items = {}
|
|
|
|
for id, count in pairs(itemMap) do
|
|
local needShowHelp = Tables.spaceshipGrowCabinOutCome2MaterialTable:ContainsKey(id)
|
|
table.insert(items, {
|
|
id = id,
|
|
count = count,
|
|
needShowHelp = needShowHelp,
|
|
})
|
|
end
|
|
if #items == 0 then
|
|
return
|
|
end
|
|
Notify(MessageConst.SHOW_SYSTEM_REWARDS, {
|
|
title = title,
|
|
items = items,
|
|
})
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipControlCenterCtrl._UpdateRoomCellStation = HL.Method(HL.Table, CS.Beyond.Gameplay.SpaceshipSystem.Room) << function(self, cell, roomInfo)
|
|
local node = cell.contentNode
|
|
if not node.m_charCells then
|
|
node.m_charCells = UIUtils.genCellCache(node.charCell)
|
|
end
|
|
|
|
local maxCount = roomInfo.maxLvStationCount
|
|
local curMaxCount = roomInfo.maxStationCharNum
|
|
local curCount = roomInfo.stationedCharList.Count
|
|
node.m_charCells:Refresh(maxCount, function(charCell, index)
|
|
if index <= curCount then
|
|
charCell.view.simpleStateController:SetState("Normal")
|
|
charCell:InitSSCharHeadCell({
|
|
charId = roomInfo.stationedCharList[CSIndex(index)],
|
|
targetRoomId = roomInfo.id,
|
|
})
|
|
elseif index <= curMaxCount then
|
|
charCell.view.simpleStateController:SetState("Empty")
|
|
else
|
|
charCell.view.simpleStateController:SetState("Locked")
|
|
end
|
|
end)
|
|
|
|
node.countTxt.text = string.format("%d/%d", curCount, curMaxCount)
|
|
end
|
|
|
|
|
|
HL.Commit(SpaceshipControlCenterCtrl)
|