763 lines
23 KiB
Lua
763 lines
23 KiB
Lua
|
|
local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
|
|
local PANEL_ID = PanelId.SpaceshipCollectionBooth
|
|
local PHASE_ID = PhaseId.SpaceshipCollectionBooth
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl = HL.Class('SpaceshipCollectionBoothCtrl', uiCtrl.UICtrl)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.s_messages = HL.StaticField(HL.Table) << {
|
|
[MessageConst.SPACESHIP_ON_SHOWCASE_MODIFY] = 'SpaceshipOnShowcaseModify',
|
|
}
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_showingItemList = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_slotCells = HL.Field(HL.Forward('UIListCache'))
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_getItemCell = HL.Field(HL.Function)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_level = HL.Field(CS.Beyond.Gameplay.Core.SpaceShipGameLevel)
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.OpenSpaceshipShowcasePanel = HL.StaticMethod() << function()
|
|
PhaseManager:OpenPhase(PHASE_ID)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
|
|
self.view.closeBtn.onClick:AddListener(function()
|
|
PhaseManager:PopPhase(PHASE_ID)
|
|
end)
|
|
self.view.backBtn.onClick:AddListener(function()
|
|
self:_TryExecute(function()
|
|
self:_ToggleItemList(false)
|
|
end, Language.LUA_SS_SHOWCASE_EXIT_SLOT_NOT_SAVE_HINT)
|
|
end)
|
|
self.view.helpBtn.onClick:AddListener(function()
|
|
UIManager:Open(PanelId.InstructionBook, "spaceship_showcase")
|
|
end)
|
|
|
|
self.view.leftArrowBtn.onClick:AddListener(function()
|
|
self:_TryExecute(function()
|
|
self:_OnClickSlot((CSIndex(self.m_curSlotIndex) - 1) % #self.m_slotInfos + 1)
|
|
end, Language.LUA_SS_SHOWCASE_CHANGE_SLOT_NOT_SAVE_HINT)
|
|
end)
|
|
self.view.rightArrowBtn.onClick:AddListener(function()
|
|
self:_TryExecute(function()
|
|
self:_OnClickSlot((CSIndex(self.m_curSlotIndex) + 1) % #self.m_slotInfos + 1)
|
|
end, Language.LUA_SS_SHOWCASE_CHANGE_SLOT_NOT_SAVE_HINT)
|
|
end)
|
|
|
|
self.view.itemInfoNode.placementBtn.onClick:AddListener(function()
|
|
self:_ToggleItemList(true)
|
|
end)
|
|
self.view.itemInfoNode.replaceBtn.onClick:AddListener(function()
|
|
self:_ToggleItemList(true)
|
|
end)
|
|
self.view.itemInfoNode.confirmBtn.onClick:AddListener(function()
|
|
self:_OnClickConfirm()
|
|
end)
|
|
|
|
self.m_slotCells = UIUtils.genCellCache(self.view.slotCell)
|
|
|
|
self.m_getItemCell = UIUtils.genCachedCellFunction(self.view.itemScrollList)
|
|
self.view.itemScrollList.onUpdateCell:AddListener(function(obj, csIndex)
|
|
self:_OnUpdateItemCell(self.m_getItemCell(obj), LuaIndex(csIndex))
|
|
end)
|
|
|
|
do
|
|
local prefab = self.loader:LoadGameObject(SpaceshipConst.SHOWCASE_LOWER_SLOT_EFFECT_PREFAB)
|
|
self.m_lowerSlotEffect = self:_CreateWorldGameObject(prefab)
|
|
self.m_lowerSlotEffect:SetActive(false)
|
|
end
|
|
do
|
|
local prefab = self.loader:LoadGameObject(SpaceshipConst.SHOWCASE_UPPER_SLOT_EFFECT_PREFAB)
|
|
self.m_upperSlotEffect = self:_CreateWorldGameObject(prefab)
|
|
self.m_upperSlotEffect:SetActive(false)
|
|
end
|
|
|
|
local _, level = GameUtil.SpaceshipUtils.TryGetSpaceshipLevel()
|
|
self.m_level = level
|
|
self.m_lvData = level.data
|
|
self:_InitCamera()
|
|
level:HideCharacters(self.m_lvData.showcaseRootPos, self.view.config.HIDE_CHAR_RADIUS)
|
|
|
|
self:_InitItemInfos()
|
|
self:_RefreshSlots()
|
|
do
|
|
local playerPos = GameUtil.playerPos - self.m_lvData.showcaseRootPos
|
|
local nearSlotIndex, minDist
|
|
for k, v in pairs(self.m_lvData.showcaseSlotLocalPosInfoList) do
|
|
local dist = (playerPos - v.Item1).magnitude
|
|
if not nearSlotIndex or dist < minDist then
|
|
nearSlotIndex = LuaIndex(k)
|
|
minDist = dist
|
|
end
|
|
end
|
|
self:_OnClickSlot(nearSlotIndex, true)
|
|
end
|
|
self.view.emptyCell.placeStateController:SetState("Empty")
|
|
self.view.emptyCell.button.onClick:AddListener(function()
|
|
if self.m_showingItemList then
|
|
self:_OnClickItem(0)
|
|
end
|
|
end)
|
|
|
|
self:_ToggleItemList(false, true)
|
|
|
|
self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({ self.view.inputGroup.groupId })
|
|
|
|
local data = CS.HG.Rendering.Runtime.HGDepthOfFieldData(CS.HG.Rendering.Runtime.HGDepthOfFieldType.Circle, 0, 0, 0,
|
|
self.view.config.CAM_DOF_FAR_FOCUS_START, self.view.config.CAM_DOF_FAR_FOCUS_END, self.view.config.CAM_DOF_FAR_RADIUS)
|
|
Utils.enableCameraDOF(data)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.OnShow = HL.Override() << function(self)
|
|
self:_SetCurItemAsNaviTarget()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.OnClose = HL.Override() << function(self)
|
|
Utils.disableCameraDOF()
|
|
self:_ClearCamera()
|
|
local _, level = GameUtil.SpaceshipUtils.TryGetSpaceshipLevel()
|
|
level:ShowCharacters()
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._SetCurItemAsNaviTarget = HL.Method() << function(self)
|
|
if self.m_showingItemList then
|
|
if self.m_curItemIndex == 0 then
|
|
InputManagerInst.controllerNaviManager:SetTarget(self.view.emptyCell.button)
|
|
else
|
|
self.view.itemScrollList:ScrollToIndex(self.m_curItemIndex, true)
|
|
InputManagerInst.controllerNaviManager:SetTarget(self.m_getItemCell(self.m_curItemIndex).button)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.SpaceshipOnShowcaseModify = HL.Method(HL.Opt(HL.Any)) << function(self, arg)
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_SS_SHOWCASE_SAVE_SUCC)
|
|
self:_RefreshItemList()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._TryExecute = HL.Method(HL.Function, HL.String) << function(self, action, hint)
|
|
if not self.m_showingItemList or self:_IsCurChooseIsCurrentPlaced() then
|
|
action()
|
|
else
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = hint,
|
|
onConfirm = function()
|
|
action()
|
|
self.m_level.showcaseItemManager:RefreshItems()
|
|
self:_UpdateCameraState()
|
|
end
|
|
})
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_slotInfos = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_curSlotIndex = HL.Field(HL.Number) << 1
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._RefreshSlots = HL.Method() << function(self)
|
|
local slotTable = Tables.spaceshipShowcaseTable
|
|
self.m_slotInfos = {}
|
|
for k, v in pairs(slotTable) do
|
|
table.insert(self.m_slotInfos, {
|
|
id = k,
|
|
data = v,
|
|
sortId = v.sortId,
|
|
})
|
|
end
|
|
table.sort(self.m_slotInfos, Utils.genSortFunction({"sortId"}, true))
|
|
|
|
self.m_slotCells:Refresh(#self.m_slotInfos, function(cell, index)
|
|
local info = self.m_slotInfos[index]
|
|
cell.nameTxt.text = info.data.name
|
|
cell.toggle.onValueChanged:RemoveAllListeners()
|
|
cell.toggle.onValueChanged:AddListener(function()
|
|
self:_OnClickSlot(index)
|
|
end)
|
|
self:_UpdateSlotState(index, cell, info)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateSlotState = HL.Method(HL.Number, HL.Opt(HL.Table, HL.Table)) << function(self, index, cell, info)
|
|
if not cell then
|
|
cell = self.m_slotCells:Get(index)
|
|
info = self.m_slotInfos[index]
|
|
end
|
|
if index == self.m_curSlotIndex then
|
|
cell.toggle:SetIsOnWithoutNotify(true)
|
|
cell.stateController:SetState("Choose")
|
|
else
|
|
cell.toggle:SetIsOnWithoutNotify(false)
|
|
local isEmpty = string.isEmpty(GameInstance.player.spaceship:GetShowcaseItemAt(info.id))
|
|
cell.stateController:SetState(isEmpty and "Empty" or "Normal")
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._OnClickSlot = HL.Method(HL.Number, HL.Opt(HL.Boolean)) << function(self, index, isInit)
|
|
if index == self.m_curSlotIndex and not isInit then
|
|
return
|
|
end
|
|
local oldIndex = self.m_curSlotIndex
|
|
self.m_curSlotIndex = index
|
|
self:_UpdateSlotState(oldIndex)
|
|
self:_UpdateSlotState(index)
|
|
self:_RefreshItemList()
|
|
self:_UpdateAreaInfo()
|
|
self:_SetCurItemAsNaviTarget()
|
|
self:_UpdateCameraState(isInit)
|
|
self:_UpdateSlotEffect()
|
|
AudioAdapter.PostEvent("au_int_system_spaceship_showcase_light")
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateAreaInfo = HL.Method() << function(self)
|
|
local node = self.view.areaInfoNode
|
|
for k, v in ipairs(self.m_slotInfos) do
|
|
local cell = node["slot" .. k]
|
|
cell.nameTxt.text = v.data.name
|
|
local isCurrent = k == self.m_curSlotIndex
|
|
if isCurrent then
|
|
cell.stateController:SetState("Choose")
|
|
node.curSlotTxt.text = v.data.name
|
|
else
|
|
local hasItem = GameInstance.player.spaceship:GetShowcaseItemAt(v.id) ~= nil
|
|
cell.stateController:SetState(hasItem and "Exhibits" or "NoExhibits")
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_itemInfos = HL.Field(HL.Table)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_curItemIndex = HL.Field(HL.Number) << 0
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._InitItemInfos = HL.Method() << function(self)
|
|
self.m_itemInfos = {}
|
|
local list = Tables.itemListByTypeTable[GEnums.ItemType.SpaceshipExhibition].list
|
|
for _, id in pairs(list) do
|
|
if Utils.getItemCount(id) > 0 then
|
|
local data = Tables.itemTable[id]
|
|
table.insert(self.m_itemInfos, {
|
|
id = id,
|
|
data = data,
|
|
showcaseItemData = Tables.spaceshipShowcaseItemTable[id],
|
|
sortId1 = data.sortId1,
|
|
sortId2 = data.sortId2,
|
|
rarity = data.rarity,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateItemInfoOrder = HL.Method() << function(self)
|
|
local slotInfo = self.m_slotInfos[self.m_curSlotIndex]
|
|
for _, v in ipairs(self.m_itemInfos) do
|
|
local slotId = GameInstance.player.spaceship:GetItemBelongShowcaseId(v.id)
|
|
v.isCurrentSortId = slotId == slotInfo.id and 0 or 1
|
|
v.usedSortId = string.isEmpty(slotId) and 0 or 1
|
|
end
|
|
table.sort(self.m_itemInfos, Utils.genSortFunction({ "isCurrentSortId", "usedSortId", "sortId1", "sortId2", "rarity" }, true))
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._ToggleItemList = HL.Method(HL.Boolean, HL.Opt(HL.Boolean)) << function(self, active, isInit)
|
|
self.m_showingItemList = active
|
|
|
|
self.view.backBtn.gameObject:SetActive(active)
|
|
self.view.closeBtn.gameObject:SetActive(not active)
|
|
if isInit then
|
|
self.view.itemListNode.gameObject:SetActive(active)
|
|
self.view.slotListNode.gameObject:SetActive(not active)
|
|
else
|
|
self.view.itemListNode.gameObject:SetActive(true)
|
|
self.view.slotListNode.gameObject:SetActive(true)
|
|
if active then
|
|
self.view.bottomNode:PlayInAnimation(function()
|
|
self.view.itemListNode.gameObject:SetActive(true)
|
|
self.view.slotListNode.gameObject:SetActive(false)
|
|
end)
|
|
else
|
|
self.view.bottomNode:PlayOutAnimation(function()
|
|
self.view.itemListNode.gameObject:SetActive(false)
|
|
self.view.slotListNode.gameObject:SetActive(true)
|
|
end)
|
|
end
|
|
end
|
|
|
|
if active then
|
|
self:_SetCurItemAsNaviTarget()
|
|
self:_UpdateContent()
|
|
else
|
|
if not isInit then
|
|
local index = self:_GetCurItemIndex()
|
|
if index ~= self.m_curItemIndex then
|
|
self:_OnClickItem(index)
|
|
else
|
|
self:_UpdateContent()
|
|
end
|
|
end
|
|
end
|
|
|
|
self.view.arrowNode:SetState(DeviceInfo.usingTouch and (active and "MobileExhibitNode" or "MobileBoothNode") or "Normal")
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._RefreshItemList = HL.Method() << function(self)
|
|
self:_UpdateItemInfoOrder()
|
|
self.m_curItemIndex = self:_GetCurItemIndex()
|
|
self:_UpdateItemChooseState(0)
|
|
self.view.emptyCell.isCurrentHint.gameObject:SetActive(self.m_curItemIndex == 0)
|
|
self.view.itemScrollList:UpdateCount(#self.m_itemInfos, true)
|
|
self:_SetCurItemAsNaviTarget()
|
|
self:_OnClickItem(self.m_curItemIndex)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._GetCurItemIndex = HL.Method().Return(HL.Number) << function(self)
|
|
local curItemId = GameInstance.player.spaceship:GetShowcaseItemAt(self:_GetCurSlotId())
|
|
if curItemId then
|
|
for k, v in ipairs(self.m_itemInfos) do
|
|
if v.id == curItemId then
|
|
return k
|
|
end
|
|
end
|
|
end
|
|
return 0
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._OnUpdateItemCell = HL.Method(HL.Table, HL.Number) << function(self, cell, index)
|
|
|
|
local itemCell = cell
|
|
local info = self.m_itemInfos[index]
|
|
|
|
itemCell.icon:LoadSprite(UIConst.UI_SPRITE_ITEM_BIG, info.data.iconId)
|
|
itemCell.nameTxt.text = info.data.name
|
|
self:_UpdateTagNode(itemCell.collectionTagNode, info.id)
|
|
itemCell.button.onClick:RemoveAllListeners()
|
|
itemCell.button.onClick:AddListener(function()
|
|
if self.m_showingItemList then
|
|
self:_OnClickItem(index)
|
|
end
|
|
end)
|
|
|
|
local slotId = GameInstance.player.spaceship:GetItemBelongShowcaseId(info.id)
|
|
local isCurrent = slotId == self:_GetCurSlotId()
|
|
itemCell.isCurrentHint.gameObject:SetActive(isCurrent)
|
|
if not slotId then
|
|
itemCell.placeStateController:SetState("Normal")
|
|
else
|
|
itemCell.placeStateController:SetState(isCurrent and "Normal" or "AlreadyPlaced")
|
|
itemCell.slotTxt.text = string.format(Language.LUA_SS_SHOWCASE_SLOT_FORMAT, Tables.spaceshipShowcaseTable[slotId].name)
|
|
end
|
|
self:_UpdateItemChooseState(index, itemCell)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateTagNode = HL.Method(HL.Table, HL.Opt(HL.String)) << function(self, tagNode, itemId)
|
|
if not tagNode.m_tagCells then
|
|
tagNode.m_tagCells = UIUtils.genCellCache(tagNode.tagCell)
|
|
end
|
|
if string.isEmpty(itemId) then
|
|
tagNode.m_tagCells:Refresh(1, function(cell, _)
|
|
cell.stateController:SetState("Empty")
|
|
end)
|
|
return
|
|
end
|
|
local data = Tables.spaceshipShowcaseItemTable[itemId]
|
|
tagNode.m_tagCells:Refresh(#data.tagIds, function(cell, index)
|
|
local tagId = data.tagIds[CSIndex(index)]
|
|
cell.stateController:SetState("Normal")
|
|
local tagData = Tables.tagDataTable[tagId]
|
|
if tagData then
|
|
cell.nameTxt.text = tagData.tagName
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._OnClickItem = HL.Method(HL.Number) << function(self, index)
|
|
local oldIndex = self.m_curItemIndex
|
|
self.m_curItemIndex = index
|
|
self:_UpdateItemChooseState(oldIndex)
|
|
self:_UpdateItemChooseState(index)
|
|
self:_UpdateContent()
|
|
self.m_level.showcaseItemManager:PreviewItemAt(self:_GetCurChooseItemId(), self:_GetCurSlotId())
|
|
self:_UpdateCameraState()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateItemChooseState = HL.Method(HL.Number, HL.Opt(HL.Table)) << function(self, index, cell)
|
|
if index == 0 then
|
|
self.view.emptyCell.chooseStateController:SetState(index == self.m_curItemIndex and "EmptyChoose" or "NotChoose")
|
|
else
|
|
cell = cell or self.m_getItemCell(index)
|
|
if cell then
|
|
cell.chooseStateController:SetState(index == self.m_curItemIndex and "NormalChoose" or "NotChoose")
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateContent = HL.Method() << function(self)
|
|
local curPlacedItemId = GameInstance.player.spaceship:GetShowcaseItemAt(self:_GetCurSlotId())
|
|
local itemId
|
|
if self.m_showingItemList then
|
|
if self.m_curItemIndex > 0 then
|
|
itemId = self.m_itemInfos[self.m_curItemIndex].id
|
|
end
|
|
else
|
|
itemId = curPlacedItemId
|
|
end
|
|
local node = self.view.itemInfoNode
|
|
if itemId then
|
|
local itemData = Tables.itemTable[itemId]
|
|
node.nameTxt.text = itemData.name
|
|
node.descTxt.text = itemData.decoDesc
|
|
self:_UpdateTagNode(node.tagNode, itemId)
|
|
else
|
|
node.nameTxt.text = Language.LUA_SS_SHOWCASE_EMPTY_NANE
|
|
node.descTxt.text = Language.LUA_SS_SHOWCASE_EMPTY_DESC
|
|
self:_UpdateTagNode(node.tagNode)
|
|
end
|
|
node.placementBtn.gameObject:SetActive(not self.m_showingItemList and not itemId)
|
|
node.replaceBtn.gameObject:SetActive(not self.m_showingItemList and itemId ~= nil)
|
|
node.isCurrentBtn.gameObject:SetActive(self.m_showingItemList and curPlacedItemId == itemId)
|
|
node.confirmBtn.gameObject:SetActive(self.m_showingItemList and curPlacedItemId ~= itemId)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._OnClickConfirm = HL.Method() << function(self)
|
|
local curSlotId = self:_GetCurSlotId()
|
|
local itemId
|
|
if self.m_curItemIndex > 0 then
|
|
itemId = self.m_itemInfos[self.m_curItemIndex].id
|
|
local oriSlotId = GameInstance.player.spaceship:GetItemBelongShowcaseId(itemId)
|
|
if oriSlotId == curSlotId then
|
|
return
|
|
end
|
|
if oriSlotId ~= nil then
|
|
local oriSlotName = Tables.spaceshipShowcaseTable[oriSlotId].name
|
|
local curSlotName = Tables.spaceshipShowcaseTable[curSlotId].name
|
|
Notify(MessageConst.SHOW_POP_UP, {
|
|
content = string.format(Language.LUA_SS_SHOWCASE_CONFIRM_MOVE_PLACED_ITEM, oriSlotName, curSlotName),
|
|
onConfirm = function()
|
|
|
|
self:_EventLogOnConfirm(itemId)
|
|
|
|
GameInstance.player.spaceship:ModifySpaceshipShowcase(curSlotId, itemId)
|
|
end
|
|
})
|
|
return
|
|
end
|
|
end
|
|
|
|
|
|
self:_EventLogOnConfirm(itemId)
|
|
|
|
GameInstance.player.spaceship:ModifySpaceshipShowcase(curSlotId, itemId)
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._EventLogOnConfirm = HL.Method(HL.Opt(HL.String)) << function(self, itemId)
|
|
|
|
local curSlotId = self:_GetCurSlotId()
|
|
local beforeIds = {}
|
|
local afterIds = {}
|
|
local places = {}
|
|
local curPlacedItemId = GameInstance.player.spaceship:GetShowcaseItemAt(curSlotId)
|
|
table.insert(beforeIds, curPlacedItemId == nil and '' or curPlacedItemId)
|
|
table.insert(afterIds, itemId == nil and '' or itemId)
|
|
table.insert(places, curSlotId)
|
|
EventLogManagerInst:GameEvent_PersonalDecoration(beforeIds, afterIds, places, "show_case", nil, nil)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._GetCurSlotId = HL.Method().Return(HL.String) << function(self)
|
|
return self.m_slotInfos[self.m_curSlotIndex].id
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._GetCurChooseItemId = HL.Method().Return(HL.Opt(HL.String)) << function(self)
|
|
if self.m_curItemIndex > 0 then
|
|
return self.m_itemInfos[self.m_curItemIndex].id
|
|
end
|
|
return nil
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._IsCurChooseIsCurrentPlaced = HL.Method().Return(HL.Boolean) << function(self)
|
|
local chooseItemId = self:_GetCurChooseItemId()
|
|
local curPlacedItemId = GameInstance.player.spaceship:GetShowcaseItemAt(self:_GetCurSlotId())
|
|
return chooseItemId == curPlacedItemId
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_camCtrl = HL.Field(CS.Beyond.Gameplay.View.SimpleCameraController)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_camTransposer = HL.Field(CS.Cinemachine.CinemachineTransposer)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_camComposer = HL.Field(CS.Cinemachine.CinemachineComposer)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_camTarget = HL.Field(CS.UnityEngine.Transform)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_lvData = HL.Field(CS.Beyond.Gameplay.SpaceShipSpecificData)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_camTween = HL.Field(HL.Any)
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._InitCamera = HL.Method() << function(self)
|
|
self.m_camTarget = self:_CreateEmptyWorldGameObject("SpaceshipShowcaseTarget").transform
|
|
self.m_camTarget.position = self.m_lvData.showcaseRootPos
|
|
|
|
self.m_camCtrl = CameraManager:LoadPersistentController("SpaceshipShowcaseCamera")
|
|
local vCam = self.m_camCtrl.virtualCamera
|
|
vCam.Follow = self.m_camTarget
|
|
vCam.LookAt = self.m_camTarget
|
|
self.m_camTransposer = CSUtils.GetCinemachineTransposer(vCam)
|
|
self.m_camComposer = CSUtils.GetCinemachineComposer(vCam)
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._ClearCamera = HL.Method() << function(self)
|
|
self:_ClearCamTween()
|
|
GameObject.Destroy(self.m_camTarget.gameObject)
|
|
self.m_camTarget = nil
|
|
CameraManager:RemoveCameraController(self.m_camCtrl)
|
|
self.m_camCtrl = nil
|
|
self.m_camTransposer = nil
|
|
self.m_camComposer = nil
|
|
end
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateCameraState = HL.Method(HL.Opt(HL.Boolean)) << function(self, noTween)
|
|
local slotInfo = self.m_lvData.showcaseSlotLocalPosInfoList[CSIndex(self.m_curSlotIndex)]
|
|
local localPos, localRot = slotInfo.Item1, slotInfo.Item2
|
|
|
|
local itemId = self:_GetCurChooseItemId()
|
|
local curItem = itemId and self.m_level.showcaseItemManager:GetLoadedItem(itemId)
|
|
|
|
|
|
local newRotation = Quaternion.LookRotation(Vector3(localPos.x, 0, localPos.z), Vector3.up)
|
|
|
|
|
|
local bodyOffsetY = localPos.y + (curItem and curItem.followExtraOffsetY or self.view.config.EMPTY_SLOT_FOLLOW_EXTRA_OFFSET_Y)
|
|
local aimOffsetY = localPos.y + (curItem and curItem.aimExtraOffsetY or self.view.config.EMPTY_SLOT_AIM_EXTRA_OFFSET_Y)
|
|
|
|
|
|
local bodyOffsetZ = localPos:XZ().magnitude + (curItem and curItem.followExtraOffsetZ or self.view.config.EMPTY_SLOT_FOLLOW_EXTRA_OFFSET_Z)
|
|
|
|
local newBodyOffset = Vector3(0, bodyOffsetY, bodyOffsetZ)
|
|
local newAimOffset = Vector3(0, aimOffsetY, 0)
|
|
self:_ClearCamTween()
|
|
if noTween then
|
|
self.m_camTarget.rotation = newRotation
|
|
self.m_camTransposer.m_FollowOffset = newBodyOffset
|
|
self.m_camComposer.m_TrackedObjectOffset = newAimOffset
|
|
else
|
|
local oldAngleY = self.m_camTarget.eulerAngles.y
|
|
local angleY = newRotation.eulerAngles.y
|
|
if math.abs(angleY - oldAngleY) > 180 then
|
|
if angleY > oldAngleY then
|
|
oldAngleY = oldAngleY + 360
|
|
else
|
|
oldAngleY = oldAngleY - 360
|
|
end
|
|
end
|
|
|
|
local oldBodyOffset = self.m_camTransposer.m_FollowOffset
|
|
local oldAimOffset = self.m_camComposer.m_TrackedObjectOffset
|
|
|
|
local percent = 0
|
|
self.m_camTween = DOTween.To(function()
|
|
return percent
|
|
end, function(value)
|
|
percent = value
|
|
self.m_camTarget.eulerAngles = Vector3(0, lume.lerp(oldAngleY, angleY, percent), 0)
|
|
self.m_camTransposer.m_FollowOffset = lume.lerp(oldBodyOffset, newBodyOffset, percent)
|
|
self.m_camComposer.m_TrackedObjectOffset = lume.lerp(oldAimOffset, newAimOffset, percent)
|
|
end, 1, self.view.config.CAM_MOVE_DURATION)
|
|
self.m_camTween:SetEase(CS.DG.Tweening.Ease.OutQuint)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._ClearCamTween = HL.Method() << function(self)
|
|
if self.m_camTween then
|
|
self.m_camTween:Kill()
|
|
self.m_camTween = nil
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_lowerSlotEffect = HL.Field(GameObject)
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl.m_upperSlotEffect = HL.Field(GameObject)
|
|
|
|
|
|
|
|
SpaceshipCollectionBoothCtrl._UpdateSlotEffect = HL.Method() << function(self)
|
|
local useLower, pos, rot = unpack(SpaceshipConst.SHOWCASE_SLOT_EFFECT_INFO[self.m_curSlotIndex])
|
|
self.m_lowerSlotEffect:SetActive(useLower)
|
|
self.m_upperSlotEffect:SetActive(not useLower)
|
|
local effect = useLower and self.m_lowerSlotEffect or self.m_upperSlotEffect
|
|
effect.transform.position = pos
|
|
effect.transform.eulerAngles = rot
|
|
end
|
|
|
|
|
|
HL.Commit(SpaceshipCollectionBoothCtrl)
|