742 lines
23 KiB
Lua
742 lines
23 KiB
Lua
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.SpaceshipStation
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl = HL.Class('SpaceshipStationCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.SPACESHIP_ON_SET_ROOM_STATION_SUCC] = 'OnSetRoomStationSucc',
|
|
[MessageConst.ON_SPACESHIP_HEAD_NAVI_TARGET_CHANGE] = 'OnHeadCellNaviTargetChange',
|
|
}
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.m_roomId = HL.Field(HL.String) << ''
|
|
|
|
|
|
SpaceshipStationCtrl.m_isControlCenter = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
SpaceshipStationCtrl.m_charEffectCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
SpaceshipStationCtrl.m_getCharCell = HL.Field(HL.Function)
|
|
|
|
|
|
SpaceshipStationCtrl.m_maxStationCharNum = HL.Field(HL.Number) << -1
|
|
|
|
|
|
SpaceshipStationCtrl.m_maxLvStationCharNum = HL.Field(HL.Number) << -1
|
|
|
|
|
|
SpaceshipStationCtrl.m_isScrollInit = HL.Field(HL.Boolean) << true
|
|
|
|
|
|
SpaceshipStationCtrl.m_skillNodes = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipStationCtrl.m_nowNaviHeadCell = HL.Field(HL.Userdata)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.closeBtn.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PhaseId.SpaceshipStation)
|
|
end)
|
|
self.view.confirmBtn.onClick:AddListener(function()
|
|
self:_OnClickConfirm()
|
|
end)
|
|
self.view.resetBtn.onClick:AddListener(function()
|
|
self:_OnClickReset()
|
|
end)
|
|
|
|
local roomId = arg.roomId
|
|
self.m_roomId = roomId
|
|
self.m_isControlCenter = roomId == Tables.spaceshipConst.controlCenterRoomId
|
|
|
|
self:_InitFilter()
|
|
self:_InitSort()
|
|
|
|
self.m_getCharCell = UIUtils.genCachedCellFunction(self.view.charScrollList)
|
|
self:BindInputPlayerAction("ss_char_detail", function()
|
|
if self.m_nowNaviHeadCell then
|
|
self.m_nowNaviHeadCell:ShowTips()
|
|
end
|
|
end)
|
|
|
|
self.view.charScrollList.onUpdateCell:AddListener(function(obj, csIndex)
|
|
self:_OnUpdateCell(self.m_getCharCell(obj), LuaIndex(csIndex))
|
|
end)
|
|
self.view.charScrollList.getCellName = function(csIndex)
|
|
local charInfo = self.m_curCharInfos[LuaIndex(csIndex)]
|
|
return "Char-" .. charInfo.id
|
|
end
|
|
|
|
self.m_charEffectCells = UIUtils.genCellCache(self.view.charEffectCell)
|
|
|
|
local spaceship = GameInstance.player.spaceship
|
|
|
|
local room = spaceship.rooms:get_Item(roomId)
|
|
self.m_maxStationCharNum = room.maxStationCharNum
|
|
self.m_maxLvStationCharNum = room.maxLvStationCount
|
|
local roomType = SpaceshipUtils.getRoomTypeByRoomId(roomId)
|
|
local roomTypeData = Tables.spaceshipRoomTypeTable[roomType]
|
|
self.view.nameTxt.text = roomTypeData.name
|
|
self.view.bigBgIcon:LoadSprite(UIConst.UI_SPRITE_SPACESHIP_ROOM, roomTypeData.bg .. "_shallow")
|
|
local color = UIUtils.getColorByString(roomTypeData.color)
|
|
self.view.colorBg.color = color
|
|
|
|
self.view.colorDeco.color = color
|
|
self.view.colorDeco.gameObject:SetActive(true)
|
|
|
|
self.view.lvDotNode:InitLvDotNode(room.lv, spaceship:GetRoomMaxLvByType(room.type), color)
|
|
|
|
self:_UpdateCharacters()
|
|
self:_UpdateStationInfos()
|
|
|
|
self:BindInputPlayerAction("ss_char_skill_detail",function()
|
|
if self.m_skillNodes then
|
|
for i, v in pairs(self.m_skillNodes) do
|
|
v:TriggerSkillHint()
|
|
end
|
|
end
|
|
end)
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.OnHeadCellNaviTargetChange = HL.Method(HL.Opt(HL.Userdata)) << function(self, cell)
|
|
self.m_nowNaviHeadCell = cell
|
|
self:_OnCellSelectedChanged(cell.m_charId, cell.view.button)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._OnCellSelectedChanged = HL.Method(HL.String, HL.Any) << function(self, charId, target)
|
|
local chosenIndex = lume.find(self.m_chosenCharIdList, charId)
|
|
if chosenIndex then
|
|
InputManagerInst:SetBindingText(target.hoverConfirmBindingId, Language.key_hint_common_unselect)
|
|
else
|
|
InputManagerInst:SetBindingText(target.hoverConfirmBindingId, Language.key_hint_common_select)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.m_filterTags = HL.Field(HL.Table)
|
|
|
|
local FilterType = {
|
|
Skill = 1,
|
|
WorkState = 2,
|
|
}
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._InitFilter = HL.Method() << function(self)
|
|
local inited = false
|
|
local filterTagGroups = {
|
|
{
|
|
title = Language.LUA_SPACESHIP_FILTER_TITLE_SKILL,
|
|
tags = {},
|
|
},
|
|
{
|
|
title = Language.LUA_SPACESHIP_FILTER_TITLE_WORK_STATE,
|
|
tags = {
|
|
{
|
|
name = Language.LUA_SPACESHIP_FILTER_TITLE_WORK_STATE_NONE,
|
|
type = FilterType.WorkState,
|
|
isWorking = false,
|
|
isResting = false,
|
|
},
|
|
{
|
|
name = Language.LUA_SPACESHIP_FILTER_TITLE_WORK_STATE_RESTING,
|
|
type = FilterType.WorkState,
|
|
isWorking = false,
|
|
isResting = true,
|
|
},
|
|
{
|
|
name = Language.LUA_SPACESHIP_FILTER_TITLE_WORK_STATE_WORKING,
|
|
type = FilterType.WorkState,
|
|
isWorking = true,
|
|
isResting = false,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for t, v in pairs(Tables.spaceshipRoomTypeTable) do
|
|
table.insert(filterTagGroups[1].tags, {
|
|
name = v.name,
|
|
type = FilterType.Skill,
|
|
roomType = GEnums.SpaceshipRoomType.__CastFrom(t),
|
|
order = t,
|
|
})
|
|
end
|
|
table.sort(filterTagGroups[1].tags, Utils.genSortFunction({"order"}, true))
|
|
self.m_filterTags = nil
|
|
self.view.filterBtn:InitFilterBtn({
|
|
tagGroups = filterTagGroups,
|
|
onConfirm = function(tags)
|
|
if not inited then
|
|
return
|
|
end
|
|
self:_ApplyFilter(tags)
|
|
end,
|
|
getResultCount = function(tags)
|
|
return self:_GetContentFilterResultCount(tags)
|
|
end,
|
|
sortNodeWidget = self.view.sortNode,
|
|
})
|
|
inited = true
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._ApplyFilter = HL.Method(HL.Opt(HL.Table)) << function(self, tags)
|
|
self.m_filterTags = tags
|
|
self:_GenCurCharInfos()
|
|
self:_UpdateCharacters(true)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._IsFilterValid = HL.Method(HL.Table, HL.Opt(HL.Table)).Return(HL.Boolean) << function(self, info, tags)
|
|
tags = tags or self.m_filterTags
|
|
if not tags then
|
|
return true
|
|
end
|
|
local groups = {}
|
|
for _, v in ipairs(tags) do
|
|
local list = groups[v.type]
|
|
if not list then
|
|
list = {}
|
|
groups[v.type] = list
|
|
end
|
|
table.insert(list, v)
|
|
end
|
|
for _, list in pairs(groups) do
|
|
local isPass
|
|
for _, v in ipairs(list) do
|
|
if v.type == FilterType.Skill then
|
|
if info.char:HasSkillForRoom(v.roomType) then
|
|
isPass = true
|
|
break
|
|
end
|
|
elseif v.type == FilterType.WorkState then
|
|
if v.isWorking == info.char.isWorking and v.isResting == info.char.isResting then
|
|
isPass = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if not isPass then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._GetContentFilterResultCount = HL.Method(HL.Table).Return(HL.Number) << function(self, tags)
|
|
local count = 0
|
|
for _, v in ipairs(self.m_allCharInfos) do
|
|
if self:_IsFilterValid(v, tags) then
|
|
count = count + 1
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._InitSort = HL.Method() << function(self)
|
|
local sortOptions = {
|
|
{
|
|
name = Language.LUA_SPACESHIP_CHAR_SORT_DEFAULT,
|
|
decKeys = { "chosenSortId", "isCurRoomSortId", "workingStateSortId", "stamina", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
incKeys = { "reverseChosenSortId", "isCurRoomSortId", "workingStateSortId", "stamina", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
},
|
|
{
|
|
name = Language.LUA_SPACESHIP_CHAR_SORT_STAMINA,
|
|
decKeys = { "chosenSortId", "stamina", "isCurRoomSortId", "workingStateSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
incKeys = { "reverseChosenSortId", "stamina", "isCurRoomSortId", "workingStateSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
},
|
|
{
|
|
name = Language.LUA_SPACESHIP_CHAR_SORT_SKILL,
|
|
decKeys = { "chosenSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "isCurRoomSortId", "workingStateSortId", "stamina", "id" },
|
|
incKeys = { "reverseChosenSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "isCurRoomSortId", "workingStateSortId", "stamina", "id" },
|
|
},
|
|
{
|
|
name = Language.LUA_SPACESHIP_CHAR_SORT_WORKING_STATE,
|
|
decKeys = { "chosenSortId", "workingStateSortId", "stamina", "isCurRoomSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
incKeys = { "reverseChosenSortId", "workingStateSortId", "stamina", "isCurRoomSortId", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
},
|
|
}
|
|
if self.m_isControlCenter then
|
|
table.insert(sortOptions, {
|
|
name = Language.LUA_SPACESHIP_CHAR_SORT_FRIENDSHIP,
|
|
decKeys = { "chosenSortId", "friendship", "isCurRoomSortId", "workingStateSortId", "stamina", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
incKeys = { "reverseChosenSortId", "friendship", "isCurRoomSortId", "workingStateSortId", "stamina", "validSkillCount", "validSkillCountIgnoreUnlock", "maxSkillSortId", "id" },
|
|
showFriendship = true,
|
|
})
|
|
end
|
|
self.view.sortNode:InitSortNode(sortOptions, function(data, isIncremental)
|
|
self:_ApplySortOption(data, isIncremental, true)
|
|
end, 0, nil, true, self.view.filterBtn)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._ApplySortOption = HL.Method(HL.Opt(HL.Table, HL.Boolean, HL.Boolean)) << function(self, sortData, isIncremental, needUpdateList)
|
|
sortData = sortData or self.view.sortNode:GetCurSortData()
|
|
if isIncremental == nil then
|
|
isIncremental = self.view.sortNode.isIncremental
|
|
end
|
|
|
|
local spaceship = GameInstance.player.spaceship
|
|
for _, info in ipairs(self.m_curCharInfos) do
|
|
local chosenIndex = lume.find(self.m_chosenCharIdList, info.id)
|
|
if chosenIndex then
|
|
info.chosenSortId = math.maxinteger - chosenIndex
|
|
info.reverseChosenSortId = -info.chosenSortId
|
|
else
|
|
info.chosenSortId = 0
|
|
info.reverseChosenSortId = 0
|
|
end
|
|
info.friendship = info.char.friendship
|
|
info.stamina = spaceship:GetCharCurStamina(info.id)
|
|
info.isCurRoomSortId = info.char.stationedRoomId == self.m_roomId and 1 or 0
|
|
if string.isEmpty(info.char.stationedRoomId) then
|
|
info.workingStateSortId = 1
|
|
else
|
|
|
|
info.workingStateSortId = info.char.isWorking and -1 or 0
|
|
end
|
|
end
|
|
|
|
local keys = isIncremental and sortData.incKeys or sortData.decKeys
|
|
table.sort(self.m_curCharInfos, Utils.genSortFunction(keys, isIncremental))
|
|
self.m_showFriendship = keys.showFriendship == true
|
|
|
|
self.m_curCharInfoReverseMap = {}
|
|
for k, v in ipairs(self.m_curCharInfos) do
|
|
self.m_curCharInfoReverseMap[v.id] = k
|
|
end
|
|
|
|
if needUpdateList then
|
|
self.m_isScrollInit = true
|
|
self.view.charScrollList:UpdateCount(#self.m_curCharInfos)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.m_allCharInfos = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipStationCtrl.m_allCharInfoReverseMap = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipStationCtrl.m_curCharInfos = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipStationCtrl.m_curCharInfoReverseMap = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipStationCtrl.m_chosenCharIdList = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._GenAllCharInfos = HL.Method() << function(self)
|
|
self.m_allCharInfos = {}
|
|
self.m_chosenCharIdList = {}
|
|
self.m_allCharInfoReverseMap = {}
|
|
local spaceship = GameInstance.player.spaceship
|
|
|
|
local room = spaceship.rooms:get_Item(self.m_roomId)
|
|
local roomType = room.type
|
|
for _, id in pairs(room.stationedCharList) do
|
|
table.insert(self.m_chosenCharIdList, id)
|
|
end
|
|
local index = 1
|
|
for id, char in pairs(spaceship.characters) do
|
|
local info = {
|
|
id = id,
|
|
char = char,
|
|
validSkillCount = 0,
|
|
validSkillCountIgnoreUnlock = 0,
|
|
maxSkillSortId = math.mininteger,
|
|
}
|
|
local haveData, charSkillData = Tables.spaceshipCharSkillTable:TryGetValue(id)
|
|
if haveData then
|
|
for _, v in pairs(charSkillData.skillList) do
|
|
local skillId = v.skillId
|
|
local skillData = Tables.spaceshipSkillTable[skillId]
|
|
if skillData.roomType == roomType then
|
|
info.validSkillCountIgnoreUnlock = info.validSkillCountIgnoreUnlock + 1
|
|
if char.skills:ContainsValue(skillId) then
|
|
info.validSkillCount = info.validSkillCount + 1
|
|
end
|
|
if skillData.sortId > info.maxSkillSortId then
|
|
info.maxSkillSortId = skillData.sortId
|
|
end
|
|
end
|
|
end
|
|
end
|
|
self.m_allCharInfos[index] = info
|
|
self.m_allCharInfoReverseMap[id] = index
|
|
index = index + 1
|
|
end
|
|
end
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._GenCurCharInfos = HL.Method() << function(self)
|
|
self.m_curCharInfos = {}
|
|
for _, v in ipairs(self.m_allCharInfos) do
|
|
if self:_IsFilterValid(v) then
|
|
table.insert(self.m_curCharInfos, v)
|
|
end
|
|
end
|
|
self:_ApplySortOption()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.m_showFriendship = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._UpdateCharacters = HL.Method(HL.Opt(HL.Boolean)) << function(self, notGen)
|
|
if not notGen then
|
|
self:_GenAllCharInfos()
|
|
self:_GenCurCharInfos()
|
|
end
|
|
local count = #self.m_curCharInfos
|
|
self.m_isScrollInit = true
|
|
self.view.charScrollList:UpdateCount(count)
|
|
self.view.charListEmptyNode.gameObject:SetActive(count == 0)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._OnUpdateCell = HL.Method(HL.Forward("SSCharHeadCell"), HL.Number) << function(self, cell, index)
|
|
local indexOfLineHead = index - ((index - 1) % self.view.charScrollList.countPerLine)
|
|
local contentScreenRect = UIUtils.getUIRectOfRectTransform(self.view.content, self.uiCamera)
|
|
|
|
local charInfo = self.m_curCharInfos[index]
|
|
cell:InitSSCharHeadCell({
|
|
charId = charInfo.id,
|
|
targetRoomId = self.m_roomId,
|
|
onClick = function()
|
|
self:_OnClickChar(index)
|
|
self:_OnCellSelectedChanged(self.m_curCharInfos[index].id, cell.view.button)
|
|
end,
|
|
groupId = self.view.inputGroup.groupId,
|
|
padding = {
|
|
bottom = self.view.transform.rect.height - contentScreenRect.yMax,
|
|
left = self.view.charListNode.rect.width + contentScreenRect.x * 2
|
|
},
|
|
})
|
|
|
|
self:_UpdateCharCellChooseState(charInfo.id, cell)
|
|
local chosenIndex = lume.find(self.m_chosenCharIdList, charInfo.id)
|
|
cell:SetChooseState(chosenIndex)
|
|
local showFriendship = self.m_isControlCenter or self.m_showFriendship
|
|
cell.view.friendshipNode.gameObject:SetActive(showFriendship)
|
|
if index == 1 and self.m_isScrollInit then
|
|
InputManagerInst.controllerNaviManager:SetTarget(cell.view.button)
|
|
self.m_isScrollInit = false
|
|
self:OnHeadCellNaviTargetChange(cell)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._UpdateCharChooseState = HL.Method(HL.String) << function(self, charId)
|
|
local index = self.m_curCharInfoReverseMap[charId]
|
|
if not index then
|
|
return
|
|
end
|
|
local cell = self.m_getCharCell(index)
|
|
if cell then
|
|
self:_UpdateCharCellChooseState(charId, cell)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._UpdateCharCellChooseState = HL.Method(HL.String, HL.Forward("SSCharHeadCell")) << function(self, charId, cell)
|
|
local chosenIndex = lume.find(self.m_chosenCharIdList, charId)
|
|
cell:SetChooseState(chosenIndex)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._OnClickChar = HL.Method(HL.Number) << function(self, index)
|
|
local charInfo = self.m_curCharInfos[index]
|
|
self:_ToggleChooseChar(charInfo.id)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._UpdateStationInfos = HL.Method() << function(self)
|
|
local spaceship = GameInstance.player.spaceship
|
|
|
|
local room = spaceship.rooms:get_Item(self.m_roomId)
|
|
local roomLvTable = SpaceshipUtils.getRoomLvTableByType(room.type)
|
|
local roomTypeData = Tables.spaceshipRoomTypeTable[room.type]
|
|
|
|
local attrs = SpaceshipUtils.preCalcRoomAttrs(self.m_roomId, self.m_chosenCharIdList)
|
|
self.view.ssRoomEffectInfoNode:InitSSRoomEffectInfoNode({
|
|
attrInfoList = attrs,
|
|
color = UIUtils.getColorByString(roomTypeData.color),
|
|
})
|
|
|
|
local contentScreenRect = UIUtils.getUIRectOfRectTransform(self.view.content, self.uiCamera)
|
|
local padding = {
|
|
bottom = self.view.transform.rect.height - contentScreenRect.yMax,
|
|
right = self.view.charEffectNode.rect.width - self.view.effectPadding.rect.width + contentScreenRect.x
|
|
}
|
|
self.m_skillNodes = {}
|
|
self.m_charEffectCells:Refresh(self.m_maxLvStationCharNum, function(cell, index)
|
|
local charId = self.m_chosenCharIdList[index]
|
|
cell.gameObject.name = "Cell-" .. index
|
|
cell.indexTxt.text = index
|
|
|
|
local isEmpty = string.isEmpty(charId)
|
|
local isLocked = index > self.m_maxStationCharNum
|
|
if isEmpty then
|
|
if isLocked then
|
|
local needLv
|
|
for k = room.lv + 1, room.maxLv do
|
|
local roomLvData = roomLvTable[k]
|
|
if roomLvData.stationMaxCount >= index then
|
|
needLv = k
|
|
break
|
|
end
|
|
end
|
|
cell.lockedTxt.text = string.format(Language.LUA_SPACESHIP_ROOM_UNLOCK_STATION_HINT, roomTypeData.name, needLv)
|
|
cell.simpleStateController:SetState("Locked")
|
|
else
|
|
cell.simpleStateController:SetState("Empty")
|
|
end
|
|
else
|
|
cell.simpleStateController:SetState("Normal")
|
|
cell.headCell:InitSSCharHeadCell({
|
|
charId = charId,
|
|
targetRoomId = self.m_roomId,
|
|
onClick = function()
|
|
cell.headCell:ShowTips()
|
|
end,
|
|
padding = padding,
|
|
})
|
|
cell.headCell.view.friendshipNode.gameObject:SetActive(self.m_isControlCenter)
|
|
cell.charSkillNode:InitSSCharSkillNode(charId, self.m_roomId, true)
|
|
table.insert(self.m_skillNodes, cell.charSkillNode)
|
|
cell.delBtn.onClick:RemoveAllListeners()
|
|
cell.delBtn.onClick:AddListener(function()
|
|
self:_ToggleChooseChar(charId)
|
|
end)
|
|
if not cell.warnCells then
|
|
cell.warnCells = UIUtils.genCellCache(cell.skillEffectWarnCell)
|
|
end
|
|
local warnTextList = {}
|
|
|
|
local char = spaceship.characters:get_Item(charId)
|
|
if not string.isEmpty(char.stationedRoomId) and char.stationedRoomId ~= self.m_roomId then
|
|
local roomType = SpaceshipUtils.getRoomTypeByRoomId(char.stationedRoomId)
|
|
local data = Tables.spaceshipRoomTypeTable[roomType]
|
|
table.insert(warnTextList, {
|
|
state = "InOtherRoom",
|
|
text = Language.LUA_SPACESHIP_CHAR_STATION_WARNING_LEAVE_ROOM,
|
|
roomColor = SpaceshipUtils.getRoomColor(char.stationedRoomId),
|
|
roomName = data.name
|
|
})
|
|
end
|
|
local info = self.m_allCharInfos[self.m_allCharInfoReverseMap[charId]]
|
|
if info.validSkillCount == 0 then
|
|
table.insert(warnTextList, {
|
|
state = "NoSkill",
|
|
text = Language.LUA_SPACESHIP_CHAR_STATION_WARNING_NO_SKILL,
|
|
})
|
|
end
|
|
if not string.isEmpty(char.stationedRoomId) and not char.isWorking then
|
|
table.insert(warnTextList, {
|
|
state = "IsResting",
|
|
text = Language.LUA_SPACESHIP_CHAR_STATION_WARNING_REST,
|
|
})
|
|
end
|
|
cell.warnCells:Refresh(#warnTextList, function(warnCell, warnIndex)
|
|
local warnInfo = warnTextList[warnIndex]
|
|
warnCell.simpleStateController:SetState(warnInfo.state)
|
|
warnCell.text.text = warnInfo.text
|
|
if warnInfo.roomName then
|
|
warnCell.roomBG.gameObject:SetActive(true)
|
|
warnCell.roomBG.color = warnInfo.roomColor
|
|
warnCell.roomName.text = warnInfo.roomName
|
|
else
|
|
warnCell.roomBG.gameObject:SetActive(false)
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
|
|
local curCount = #self.m_chosenCharIdList
|
|
self.view.stationCountDotNode:InitLvDotNode(curCount, self.m_maxStationCharNum)
|
|
self.view.stationCountTxt.text = string.format(Language.LUA_SPACESHIP_STATION_CHAR_COUNT_FORMAT, curCount, self.m_maxStationCharNum)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._ToggleChooseChar = HL.Method(HL.String) << function(self, charId)
|
|
local chosenIndex = lume.find(self.m_chosenCharIdList, charId)
|
|
if chosenIndex then
|
|
|
|
table.remove(self.m_chosenCharIdList, chosenIndex)
|
|
self:_UpdateCharChooseState(charId)
|
|
for _, v in ipairs(self.m_chosenCharIdList) do
|
|
self:_UpdateCharChooseState(v)
|
|
end
|
|
else
|
|
|
|
local curCount = #self.m_chosenCharIdList
|
|
if curCount >= self.m_maxStationCharNum then
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_SPACESHIP_STATION_CHAR_MAX)
|
|
return
|
|
end
|
|
table.insert(self.m_chosenCharIdList, charId)
|
|
self:_UpdateCharChooseState(charId)
|
|
|
|
Utils.triggerVoice("sim_assign_work", charId)
|
|
|
|
end
|
|
self:_UpdateStationInfos()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._OnClickReset = HL.Method() << function(self)
|
|
local oldChars = self.m_chosenCharIdList
|
|
self.m_chosenCharIdList = {}
|
|
for _, v in ipairs(oldChars) do
|
|
self:_UpdateCharChooseState(v)
|
|
end
|
|
self:_UpdateStationInfos()
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipStationCtrl.OnSetRoomStationSucc = HL.Method(HL.Table) << function(self, _)
|
|
PhaseManager:PopPhase(PhaseId.SpaceshipStation)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipStationCtrl._OnClickConfirm = HL.Method() << function(self)
|
|
local spaceship = GameInstance.player.spaceship
|
|
local room = spaceship.rooms:get_Item(self.m_roomId)
|
|
local notChanged = #self.m_chosenCharIdList == room.stationedCharList.Count
|
|
if notChanged then
|
|
for k, id in pairs(room.stationedCharList) do
|
|
if self.m_chosenCharIdList[LuaIndex(k)] ~= id then
|
|
notChanged = false
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if notChanged then
|
|
PhaseManager:PopPhase(PhaseId.SpaceshipStation)
|
|
return
|
|
end
|
|
GameInstance.player.spaceship:SetRoomStation(self.m_roomId, self.m_chosenCharIdList)
|
|
end
|
|
|
|
|
|
|
|
|
|
HL.Commit(SpaceshipStationCtrl)
|