3260 lines
98 KiB
Lua
3260 lines
98 KiB
Lua
local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')
|
|
local LuaNodeCache = require_ex('Common/Utils/LuaNodeCache')
|
|
local UILevelMapUtils = CS.Beyond.Gameplay.UILevelMapUtils
|
|
local ElementType = CS.Beyond.Gameplay.UILevelMapStaticElementType
|
|
local LineType = CS.Beyond.Gameplay.MarkLineType
|
|
local RenderTexture = CS.UnityEngine.RenderTexture
|
|
local Graphics = CS.UnityEngine.Graphics
|
|
local GL = CS.UnityEngine.GL
|
|
local Rect = CS.UnityEngine.Rect
|
|
local Stack = require_ex("Common/Utils/DataStructure/Stack")
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader = HL.Class('LevelMapLoader', UIWidgetBase)
|
|
|
|
local LOADER_DEFAULT_UPDATE_INTERVAL = 0.2
|
|
|
|
local NEED_UPDATE_MISSION_MARK_POS_SQR_MAGNITUDE = 0.002
|
|
|
|
local ACTION_DELAY_TIME = 3
|
|
|
|
local MIN_MARK_ORDER = 1
|
|
local MAX_MARK_ORDER = 6
|
|
local CUSTOM_MARK_ORDER = 6
|
|
local MARK_ORDER_VIEW_NAME_FORMAT = "order%d"
|
|
|
|
local MIST_DRAW_MATERIAL_PATH = "Assets/Beyond/DynamicAssets/Gameplay/UI/Materials/M_ui_mapmist_rendertexture_painter.mat"
|
|
|
|
local LOW_MEMORY_DEVICE_MIST_TEXTURE_LENGTH_RATIO = 0.5
|
|
|
|
|
|
LevelMapLoader.m_initialized = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_mapManager = HL.Field(CS.Beyond.Gameplay.MapManager)
|
|
|
|
|
|
LevelMapLoader.m_levelMapConfig = HL.Field(CS.Beyond.Gameplay.UILevelMapConfig)
|
|
|
|
|
|
LevelMapLoader.m_mistSystem = HL.Field(CS.Beyond.Gameplay.MistMapSystem)
|
|
|
|
|
|
LevelMapLoader.m_regionManager = HL.Field(CS.Beyond.Gameplay.MapRegionManager)
|
|
|
|
|
|
LevelMapLoader.m_dataUpdateInterval = HL.Field(HL.Number) << LOADER_DEFAULT_UPDATE_INTERVAL
|
|
|
|
|
|
LevelMapLoader.m_rootUpdateTick = HL.Field(HL.Number) << -1
|
|
|
|
|
|
LevelMapLoader.m_gridMaskUpdateTick = HL.Field(HL.Number) << -1
|
|
|
|
|
|
LevelMapLoader.m_animMistShowTimer = HL.Field(HL.Number) << -1
|
|
|
|
|
|
LevelMapLoader.m_mapId = HL.Field(HL.String) << ""
|
|
|
|
|
|
LevelMapLoader.m_levelId = HL.Field(HL.String) << ""
|
|
|
|
|
|
LevelMapLoader.m_markCache = HL.Field(Stack)
|
|
|
|
|
|
LevelMapLoader.m_customMarkCache = HL.Field(Stack)
|
|
|
|
|
|
LevelMapLoader.m_trackingMarkCache = HL.Field(Stack)
|
|
|
|
|
|
LevelMapLoader.m_gridCache = HL.Field(LuaNodeCache)
|
|
|
|
|
|
LevelMapLoader.m_gridSpriteCache = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_gridSpriteFolderCache = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_posTween = HL.Field(HL.Userdata)
|
|
|
|
|
|
LevelMapLoader.m_sizeTween = HL.Field(HL.Userdata)
|
|
|
|
|
|
LevelMapLoader.m_buildLevels = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_onMarkInstDataChangedCallback = HL.Field(HL.Function)
|
|
|
|
|
|
LevelMapLoader.m_markStaticDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_delayActionList = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_gridsMaskFollowTarget = HL.Field(RectTransform)
|
|
|
|
|
|
LevelMapLoader.m_isLowMemoryDevice = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.m_needUpdate = HL.Field(HL.Boolean) << true
|
|
|
|
|
|
LevelMapLoader.m_needOptimizePerformance = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_extraView = HL.Field(HL.Number) << 0
|
|
|
|
|
|
LevelMapLoader.m_needShowOtherLevelTracking = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_onMarkHover = HL.Field(HL.Function)
|
|
|
|
|
|
LevelMapLoader.m_onGridsLoadedStateChange = HL.Field(HL.Function)
|
|
|
|
|
|
LevelMapLoader.m_expectedStaticElementTypes = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_needListenMarkStateChange = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_needInteractableMark = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_initialMarkScale = HL.Field(Vector3)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.m_levelGrids = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedGridViewDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_hitLevels = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_hitGrids = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedPosition = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_gridMistSingleTextureLength = HL.Field(HL.Number) << 0
|
|
|
|
|
|
LevelMapLoader.m_gridMistDrawMaterial = HL.Field(HL.Userdata)
|
|
|
|
|
|
LevelMapLoader.m_gridMistRefreshData = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_animMistRefreshData = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_forbidMistRefreshAfterGridChange = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_waitMistRefreshAfterGridChange = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
LevelMapLoader.m_tierId = HL.Field(HL.Number) << 0
|
|
|
|
|
|
LevelMapLoader.m_tierIndex = HL.Field(HL.Number) << 0
|
|
|
|
|
|
LevelMapLoader.m_needShowMarkTier = HL.Field(HL.Boolean) << false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.m_staticElementInitializer = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_lineCaches = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_lineRoots = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedLineViewDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_buildElementsLevels = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedStaticElementViewDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedMarkViewDataMap = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_missionTrackingAreaCache = HL.Field(LuaNodeCache)
|
|
|
|
|
|
LevelMapLoader.m_loadedMissionTrackingMarks = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedMissionTrackingMarksPos = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedMissionTrackingAreas = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_loadedGeneralTrackingMarkId = HL.Field(HL.String) << ""
|
|
|
|
|
|
LevelMapLoader.m_generalTrackingMarkInOtherLevel = HL.Field(HL.String) << ""
|
|
|
|
|
|
LevelMapLoader.m_missionTrackingMarkInOtherLevel = HL.Field(HL.String) << ""
|
|
|
|
|
|
LevelMapLoader.m_gameplayAreaCache = HL.Field(LuaNodeCache)
|
|
|
|
|
|
LevelMapLoader.m_loadedGameplayAreas = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_tryLoadElementsList = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_switchMaskCells = HL.Field(HL.Forward("UIListCache"))
|
|
|
|
|
|
LevelMapLoader.m_waitVisibleInMistMarks = HL.Field(HL.Table)
|
|
|
|
|
|
LevelMapLoader.m_connectNodeLineGetter = HL.Field(HL.Table)
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.m_gridRectLength = HL.Field(HL.Number) << -1
|
|
|
|
|
|
LevelMapLoader.m_gridWorldLength = HL.Field(HL.Number) << -1
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnFirstTimeInit = HL.Override() << function(self)
|
|
self:RegisterMessage(MessageConst.ON_MAP_POWER_LINE_CHANGED, function()
|
|
self:_OnMarkLineInstDataChanged(LineType.Power)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_TRAVEL_LINE_CHANGED, function()
|
|
self:_OnMarkLineInstDataChanged(LineType.Travel)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_UD_PIPE_LINE_CHANGED, function()
|
|
self:_OnMarkLineInstDataChanged(LineType.UdPipe)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_MARK_RUNTIME_DATA_CHANGED, function(args)
|
|
local instId, isAdd = unpack(args)
|
|
self:_OnMarkInstDataChanged(instId, isAdd)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_MARK_RUNTIME_DATA_MODIFY, function(args)
|
|
local instId = unpack(args)
|
|
self:_OnMarkInstDataModified(instId)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_GAMEPLAY_AREA_ADDED, function(args)
|
|
local areaId = unpack(args)
|
|
self:_RefreshGameplayArea(areaId, true)
|
|
end)
|
|
self:RegisterMessage(MessageConst.ON_MAP_GAMEPLAY_AREA_REMOVED, function(args)
|
|
local areaId = unpack(args)
|
|
self:_RefreshGameplayArea(areaId, false)
|
|
end)
|
|
self:RegisterMessage(MessageConst.SHOW_CUSTOM_MARK_MULTI_DELETE, function(args)
|
|
self:_RefreshCustomMarkOrderActiveState(false)
|
|
end)
|
|
self:RegisterMessage(MessageConst.HIDE_CUSTOM_MARK_MULTI_DELETE, function(args)
|
|
self:_RefreshCustomMarkOrderActiveState(true)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._OnDestroy = HL.Override() << function(self)
|
|
if not self.m_initialized then
|
|
return
|
|
end
|
|
self.m_rootUpdateTick = LuaUpdate:Remove(self.m_rootUpdateTick)
|
|
self.m_gridMaskUpdateTick = LuaUpdate:Remove(self.m_gridMaskUpdateTick)
|
|
self.m_animMistShowTimer = self:_ClearTimer(self.m_animMistShowTimer)
|
|
self:_RemoveAllDelayActions()
|
|
self:_DisposeAllGridSprites()
|
|
self:_ClearLoaderGridMists()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.InitLevelMapLoader = HL.Method(HL.String, HL.Opt(HL.Table)) << function(self, levelId, customInfo)
|
|
self.m_initialized = false
|
|
|
|
if string.isEmpty(levelId) then
|
|
return
|
|
end
|
|
|
|
self.m_levelMapConfig = DataManager.uiLevelMapConfig
|
|
self.m_gridRectLength = self.m_levelMapConfig.gridRectLength
|
|
self.view.source.grid.rectTransform.sizeDelta = Vector2(self.m_gridRectLength, self.m_gridRectLength)
|
|
self.m_gridWorldLength = self.m_levelMapConfig.gridWorldLength
|
|
self.m_mapManager = GameInstance.player.mapManager
|
|
self.m_mistSystem = GameInstance.player.mistMapSystem
|
|
self.m_regionManager = GameWorld.mapRegionManager
|
|
self.m_isLowMemoryDevice = CS.Beyond.BeyondMemoryUtility.IsLowMemoryDevice()
|
|
local success, levelConfig = DataManager.levelConfigTable:TryGetData(levelId)
|
|
self.m_mapId = success and levelConfig.mapIdStr or ""
|
|
self.m_levelId = levelId
|
|
self.m_tierId = MapConst.BASE_TIER_ID
|
|
self.m_forbidMistRefreshAfterGridChange = false
|
|
self:_InitTableFields()
|
|
self:_InitCustomInfo(customInfo)
|
|
self:_InitLoaderCache()
|
|
self:_InitMistDrawMaterial()
|
|
|
|
if BEYOND_DEBUG_COMMAND and customInfo.isDebugMode then
|
|
self:_InitDebugMode(levelId)
|
|
return
|
|
end
|
|
|
|
self:_InitGridsMask()
|
|
self:_InitMarkStaticDataMap()
|
|
self:_InitStaticElementInitializer()
|
|
self:_InitLoaderComponent()
|
|
|
|
self:_InitLoaderUpdateThread()
|
|
self:_InitPermanentElementsInCurrentMap()
|
|
|
|
self:_FirstTimeInit()
|
|
|
|
self.m_initialized = true
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._InitLoaderComponent = HL.Method() << function(self)
|
|
self.view.loader:InitLoader(self.m_levelId, self.m_extraView)
|
|
if not self.m_needUpdate then
|
|
self.view.loader:PauseTick()
|
|
end
|
|
self.view.loader.onHitGridsChange:AddListener(function(addGrids, removeGrids)
|
|
self:_OnGridsLoadedStateChanged(addGrids, removeGrids)
|
|
end)
|
|
self.view.loader.onLevelChange:AddListener(function(levelId)
|
|
self:_OnLoaderLevelChanged(levelId)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._InitCustomInfo = HL.Method(HL.Table) << function(self, customInfo)
|
|
customInfo = customInfo or {}
|
|
self.m_extraView = customInfo.extraView or 0
|
|
self.m_needOptimizePerformance = customInfo.needOptimizePerformance or false
|
|
self.m_needShowOtherLevelTracking = customInfo.needShowOtherLevelTracking or false
|
|
self.m_onMarkInstDataChangedCallback = customInfo.onMarkInstDataChangedCallback or nil
|
|
self.m_expectedStaticElementTypes = customInfo.expectedStaticElements or {}
|
|
self.m_onMarkHover = customInfo.onMarkHover or nil
|
|
self.m_gridsMaskFollowTarget = customInfo.gridsMaskFollowTarget or nil
|
|
self.m_needUpdate = customInfo.needUpdate or false
|
|
self.m_needInteractableMark = customInfo.needInteractableMark or false
|
|
self.m_needListenMarkStateChange = customInfo.needListenMarkStateChange or false
|
|
self.m_onGridsLoadedStateChange = customInfo.onGridsLoadedStateChange or nil
|
|
|
|
local panelRectTransform = self:GetUICtrl().view.rectTransform
|
|
local markRectTransform = self.view.source.marks.levelMapMark.view.rectTransform
|
|
self.m_initialMarkScale = CS.Beyond.UI.UIUtils.GetNodeScaleOffset(panelRectTransform, markRectTransform)
|
|
local configScale = self.view.config.INITIAL_MARK_SCALE
|
|
self.m_initialMarkScale = Vector3(
|
|
configScale / self.m_initialMarkScale.x,
|
|
configScale / self.m_initialMarkScale.y,
|
|
configScale / self.m_initialMarkScale.z
|
|
)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._InitTableFields = HL.Method(HL.Opt(HL.Boolean)) << function(self, ignoreGlobal)
|
|
self.m_buildLevels = {}
|
|
self.m_levelGrids = {}
|
|
self.m_loadedGridViewDataMap = {}
|
|
self.m_hitLevels = {}
|
|
self.m_hitGrids = {}
|
|
self.m_buildElementsLevels = {}
|
|
self.m_delayActionList = {}
|
|
self.m_tryLoadElementsList = {}
|
|
|
|
if not ignoreGlobal then
|
|
self.m_loadedGridViewDataMap = {}
|
|
self.m_loadedPosition = {}
|
|
self.m_loadedStaticElementViewDataMap = {}
|
|
self.m_loadedLineViewDataMap = {}
|
|
self.m_loadedMarkViewDataMap = {}
|
|
self.m_loadedMissionTrackingMarks = {}
|
|
self.m_loadedMissionTrackingMarksPos = {}
|
|
self.m_loadedMissionTrackingAreas = {}
|
|
self.m_loadedGameplayAreas = {}
|
|
|
|
self.m_gridSpriteCache = {}
|
|
self.m_gridSpriteFolderCache = {}
|
|
self.m_markStaticDataMap = {}
|
|
|
|
self.m_gridMistRefreshData = {}
|
|
self.m_animMistRefreshData = {}
|
|
self.m_waitVisibleInMistMarks = {}
|
|
|
|
self.m_connectNodeLineGetter = {}
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitMarkStaticDataMap = HL.Method() << function(self)
|
|
self.m_markStaticDataMap = {}
|
|
for templateId, templateData in pairs(Tables.mapMarkTempTable) do
|
|
self.m_markStaticDataMap[templateId] = {
|
|
templateId = templateId,
|
|
visibleLayer = templateData.visibleLayer,
|
|
sortOrder = templateData.sortOrder,
|
|
filterType = templateData.markInfoType:GetHashCode(),
|
|
filterTypeEnum = templateData.markInfoType,
|
|
}
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitLoaderCache = HL.Method() << function(self)
|
|
local source = self.view.source
|
|
local element = self.view.element
|
|
|
|
|
|
source.gameObject:SetActive(false)
|
|
source.marks.levelMapMark.gameObject:SetActive(true)
|
|
source.marks.levelMapInteractableMark.gameObject:SetActive(true)
|
|
source.marks.levelMapCustomMark.gameObject:SetActive(true)
|
|
source.grid.gameObject:SetActive(true)
|
|
source.grid.image.sprite = nil
|
|
|
|
self.m_gridCache = LuaNodeCache(source.grid, element.loadedGrids)
|
|
|
|
self.m_missionTrackingAreaCache = LuaNodeCache(
|
|
source.mission.missionTrackingArea,
|
|
element.missionArea
|
|
)
|
|
|
|
self.m_gameplayAreaCache = LuaNodeCache(
|
|
source.gameplay.gameplayArea,
|
|
element.gameplayArea
|
|
)
|
|
|
|
local lineRoot = element.lineRoot
|
|
local lines = source.lines
|
|
self.m_lineCaches = {
|
|
[LineType.Power] = LuaNodeCache(lines.powerLine, lineRoot.powerLine),
|
|
[LineType.Travel] = LuaNodeCache(lines.travelLine, lineRoot.travelLine),
|
|
[LineType.DomainDepotDeliver] = LuaNodeCache(lines.deliverLine, lineRoot.domainDepotDeliverLine),
|
|
[LineType.UdPipe] = LuaNodeCache(lines.udPipeLine, lineRoot.udPipeLine),
|
|
}
|
|
self.m_lineRoots = {
|
|
[LineType.Power] = lineRoot.powerLine,
|
|
[LineType.Travel] = lineRoot.travelLine,
|
|
[LineType.DomainDepotDeliver] = lineRoot.domainDepotDeliverLine,
|
|
[LineType.UdPipe] = lineRoot.udPipeLine,
|
|
}
|
|
|
|
self:_InitLoaderMarkCache()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitLoaderMarkCache = HL.Method() << function(self)
|
|
if self.m_needInteractableMark then
|
|
self.m_customMarkCache = Stack()
|
|
end
|
|
self.m_markCache = Stack()
|
|
self.m_trackingMarkCache = Stack()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitStaticElementInitializer = HL.Method() << function(self)
|
|
|
|
local source = self.view.source
|
|
local element = self.view.element
|
|
local frontRoot = element.staticElementFrontRoot
|
|
local backRoot = element.staticElementBackRoot
|
|
local bottomRoot = element.staticElementBottomRoot
|
|
local gridRoot = element.staticElementGridRoot
|
|
|
|
local staticElements = source.staticElements
|
|
|
|
|
|
|
|
self.m_staticElementInitializer = {
|
|
[ElementType.SwitchButton] = {
|
|
cache = LuaNodeCache(staticElements.levelSwitchButton, backRoot.switchButton),
|
|
initializer = function(staticElement, settlementElementData)
|
|
staticElement.levelMapSwitchBtn:InitSwitchButton(
|
|
settlementElementData.targetLevelId, settlementElementData.directionAngle
|
|
)
|
|
end,
|
|
componentGetter = function(staticElement)
|
|
return staticElement.levelMapSwitchBtn
|
|
end,
|
|
needHideInTier = true,
|
|
},
|
|
[ElementType.NarrativeAreaText] = {
|
|
cache = LuaNodeCache(staticElements.narrativeAreaText, backRoot.narrativeAreaText),
|
|
initializer = function(staticElement, settlementElementData)
|
|
staticElement.text.text = Language[settlementElementData.textId]
|
|
end,
|
|
needHideInTier = true,
|
|
},
|
|
[ElementType.FacMainRegion] = {
|
|
cache = LuaNodeCache(staticElements.facMainRegion, bottomRoot.facMainRegion),
|
|
initializer = function(staticElement, settlementElementData)
|
|
staticElement.facMainRegion:InitMainRegion(settlementElementData.regionLevelId, settlementElementData.regionPanelIndex)
|
|
end,
|
|
componentGetter = function(staticElement)
|
|
return staticElement.facMainRegion
|
|
end,
|
|
refreshWithTier = function(staticElement, tierIndex, color)
|
|
staticElement.image.color = color
|
|
end
|
|
},
|
|
[ElementType.SettlementRegion] = {
|
|
cache = LuaNodeCache(staticElements.settlementRegion, bottomRoot.settlementRegion),
|
|
initializer = function(staticElement, settlementElementData)
|
|
local rectCenterPos = staticElement.rectTransform.anchoredPosition
|
|
local worldCenterPos = UILevelMapUtils.ConvertUILevelMapRectPosToWorldPos(
|
|
rectCenterPos, self.m_gridWorldLength, self.m_gridRectLength
|
|
)
|
|
staticElement.settlementRegion:InitSettlementRegion(settlementElementData.settlementId, worldCenterPos)
|
|
end,
|
|
componentGetter = function(staticElement)
|
|
return staticElement.settlementRegion
|
|
end,
|
|
refreshWithTier = function(staticElement, tierIndex, color)
|
|
if staticElement.settlementRegion:GetNeedRefreshSettlementRegionTier() then
|
|
staticElement.image.color = Color.white
|
|
staticElement.settlementRegion:RefreshSettlementRegionWithTier(tierIndex)
|
|
else
|
|
staticElement.image.color = color
|
|
end
|
|
end
|
|
},
|
|
[ElementType.Crane] = {
|
|
cache = LuaNodeCache(staticElements.crane, gridRoot.crane),
|
|
initializer = function(staticElement, settlementElementData)
|
|
staticElement.crane:InitCrane()
|
|
end,
|
|
componentGetter = function(staticElement)
|
|
return staticElement.crane
|
|
end,
|
|
needHideInTier = true,
|
|
},
|
|
[ElementType.Misty] = {
|
|
cache = LuaNodeCache(staticElements.misty, gridRoot.misty),
|
|
initializer = function(staticElement, settlementElementData)
|
|
staticElement.misty:InitMisty()
|
|
end,
|
|
componentGetter = function(staticElement)
|
|
return staticElement.misty
|
|
end,
|
|
isVisible = function(settlementElementData)
|
|
return CS.Beyond.UI.UILevelMapMisty.IsMistyVisible()
|
|
end,
|
|
},
|
|
}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitPermanentElementsInCurrentMap = HL.Method() << function(self)
|
|
self:_InitGameplayAreasInCurrentMap()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitGameplayAreasInCurrentMap = HL.Method() << function(self)
|
|
local success, areaDataDict = self.m_mapManager:GetGameplayAreaDataDictByMapId(self.m_mapId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
for areaId, _ in cs_pairs(areaDataDict) do
|
|
self:_RefreshGameplayArea(areaId, true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitLoaderUpdateThread = HL.Method() << function(self)
|
|
local uiCtrl = self:GetUICtrl()
|
|
|
|
self.m_rootUpdateTick = LuaUpdate:Add("Tick", function(deltaTime)
|
|
if uiCtrl:IsShow() then
|
|
self:_RefreshMissionTrackingMarksPosition()
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitGridsMask = HL.Method() << function(self)
|
|
if not NotNull(self.m_gridsMaskFollowTarget) then
|
|
self.view.element.gridsMask.gameObject:SetActive(false)
|
|
return
|
|
end
|
|
self.view.element.gridsMask.gameObject:SetActive(true)
|
|
self:_RefreshGridsMask()
|
|
self.m_gridMaskUpdateTick = LuaUpdate:Add("LateTick", function(deltaTime)
|
|
if self:GetUICtrl():IsShow() then
|
|
|
|
|
|
self:_RefreshGridsMask()
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._InitMistDrawMaterial = HL.Method() << function(self)
|
|
self.m_gridMistDrawMaterial = self.loader:LoadMaterial(MIST_DRAW_MATERIAL_PATH)
|
|
self.view.element.mist.gameObject:SetActive(false)
|
|
self.view.element.animMist.gameObject:SetActive(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._IsExpectedStaticElementType = HL.Method(HL.Userdata).Return(HL.Boolean) << function(self, type)
|
|
if not next(self.m_expectedStaticElementTypes) then
|
|
return true
|
|
end
|
|
return self.m_expectedStaticElementTypes[type] == true
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnGridsLoadedStateChanged = HL.Method(HL.Userdata, HL.Userdata) << function(self, addGrids, removeGrids)
|
|
|
|
|
|
|
|
for loaderData in cs_pairs(removeGrids) do
|
|
self:_RefreshGridsAndElements(loaderData, false)
|
|
end
|
|
|
|
|
|
for loaderData in cs_pairs(addGrids) do
|
|
self:_RefreshGridsAndElements(loaderData, true)
|
|
end
|
|
if addGrids.Count > 0 or removeGrids.Count > 0 then
|
|
self:_RefreshLoadedGridsColorWithTier()
|
|
|
|
|
|
if self.m_forbidMistRefreshAfterGridChange then
|
|
self.m_waitMistRefreshAfterGridChange = true
|
|
else
|
|
self:_RefreshGridMists(false)
|
|
self.m_waitMistRefreshAfterGridChange = false
|
|
end
|
|
end
|
|
|
|
self:_RefreshPermanentStaticElementsLoadedState()
|
|
|
|
if self.m_onGridsLoadedStateChange ~= nil then
|
|
self.m_onGridsLoadedStateChange()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnLoaderLevelChanged = HL.Method(HL.String) << function(self, levelId)
|
|
self.m_levelId = levelId
|
|
|
|
self:_RefreshGridDuplicatedState()
|
|
|
|
self:_RefreshGeneralTrackingMarkLevelState()
|
|
self:_RefreshMissionTrackingMarksLevelState()
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnMarkInstDataModified = HL.Method(HL.String) << function(self, markInstId)
|
|
local success, markRuntimeData = self.m_mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
local belongGridLoaderData = markRuntimeData.belongGrid
|
|
if belongGridLoaderData == nil or not self.view.loader:IsGridInHitList(belongGridLoaderData.gridId) then
|
|
return
|
|
end
|
|
self:_RefreshGridMark(markInstId, markRuntimeData, markRuntimeData.isVisible)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnMarkInstDataChanged = HL.Method(HL.String, HL.Boolean) << function(self, markInstId, isAdd)
|
|
local success, markRuntimeData = self.m_mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
local belongGridLoaderData = markRuntimeData.belongGrid
|
|
if belongGridLoaderData == nil or not self.view.loader:IsGridInHitList(belongGridLoaderData.gridId) then
|
|
return
|
|
end
|
|
self:_RefreshGridMark(markInstId, markRuntimeData, isAdd)
|
|
|
|
if self.m_onMarkInstDataChangedCallback ~= nil then
|
|
self.m_onMarkInstDataChangedCallback()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._OnMarkLineInstDataChanged = HL.Method(LineType) << function(self, lineType)
|
|
local needRefreshLines = {}
|
|
for _, gridData in pairs(self.m_loadedGridViewDataMap) do
|
|
local lines = gridData.loaderData.lines
|
|
if lines ~= nil and lines.Count > 0 then
|
|
for lineId, lineData in pairs(lines) do
|
|
if lineData.lineType == lineType then
|
|
if needRefreshLines[lineId] == nil then
|
|
needRefreshLines[lineId] = {
|
|
lineData = lineData,
|
|
loadCount = 1
|
|
}
|
|
else
|
|
needRefreshLines[lineId].loadCount = needRefreshLines[lineId].loadCount + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
local refreshFunc = function(lineData, count, needShow)
|
|
for _ = 1, count do
|
|
self:_RefreshGridLine(lineData, needShow)
|
|
end
|
|
end
|
|
|
|
|
|
for lineId, lineViewData in pairs(self.m_loadedLineViewDataMap) do
|
|
if needRefreshLines[lineId] == nil then
|
|
refreshFunc(lineViewData.lineData, lineViewData.loadCount, false)
|
|
end
|
|
end
|
|
|
|
|
|
for _, refreshLineData in pairs(needRefreshLines) do
|
|
refreshFunc(refreshLineData.lineData, refreshLineData.loadCount, false)
|
|
refreshFunc(refreshLineData.lineData, refreshLineData.loadCount, true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridsAndElements = HL.Method(HL.Userdata, HL.Boolean) << function(self, loaderData, isAdd)
|
|
if isAdd then
|
|
if not loaderData.isDuplicated then
|
|
self:_RefreshGrid(loaderData, true)
|
|
end
|
|
self:_RefreshGridMarks(loaderData, true)
|
|
self:_RefreshGridStaticElements(loaderData, true)
|
|
self:_RefreshGridLines(loaderData, true)
|
|
else
|
|
self:_RefreshGrid(loaderData, false)
|
|
self:_RefreshGridMarks(loaderData, false)
|
|
self:_RefreshGridStaticElements(loaderData, false)
|
|
self:_RefreshGridLines(loaderData, false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGrid = HL.Method(HL.Userdata, HL.Boolean, HL.Opt(HL.Function)) << function(self, loaderData, needShow, onShow)
|
|
local gridId = loaderData.gridId
|
|
|
|
local doGridDispose = function(gridData)
|
|
local gridCell = gridData.cell
|
|
gridCell.image.sprite = nil
|
|
gridCell.gameObject.name = "CachedGrid"
|
|
|
|
|
|
local spriteData = self.m_gridSpriteCache[gridId]
|
|
if self.m_needOptimizePerformance then
|
|
self:_AddDelayDisposeGridSprite(spriteData)
|
|
else
|
|
self:_DisposeGridSprite(spriteData, true)
|
|
end
|
|
|
|
self.m_gridCache:Cache(gridCell)
|
|
self.m_loadedGridViewDataMap[gridId] = nil
|
|
end
|
|
|
|
if needShow then
|
|
if self.m_loadedGridViewDataMap[gridId] == nil then
|
|
local gridCell = self.m_gridCache:Get()
|
|
self.m_loadedGridViewDataMap[gridId] = {
|
|
loaderData = loaderData,
|
|
cell = gridCell,
|
|
}
|
|
|
|
|
|
gridCell.rectTransform.anchoredPosition = loaderData.rectPos
|
|
gridCell.gameObject.name = gridId
|
|
|
|
|
|
if self.m_needOptimizePerformance then
|
|
UIUtils.changeAlpha(gridCell.image, 0)
|
|
self:_GetGridSprite(gridId, function(sprite)
|
|
|
|
local currGridData = self.m_loadedGridViewDataMap[gridId]
|
|
if currGridData ~= nil then
|
|
if NotNull(currGridData.cell.image) then
|
|
UIUtils.changeAlpha(currGridData.cell.image, 1)
|
|
currGridData.cell.image.sprite = sprite
|
|
if onShow ~= nil then
|
|
onShow(gridId)
|
|
end
|
|
else
|
|
doGridDispose(currGridData)
|
|
end
|
|
end
|
|
end)
|
|
else
|
|
gridCell.image.sprite = self:_GetGridSprite(gridId)
|
|
if onShow ~= nil then
|
|
onShow(gridId)
|
|
end
|
|
end
|
|
end
|
|
else
|
|
local gridData = self.m_loadedGridViewDataMap[gridId]
|
|
if gridData ~= nil then
|
|
doGridDispose(gridData)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridDuplicatedState = HL.Method() << function(self)
|
|
local getDuplicatedGridsFunc = function(targetLoaderData)
|
|
local grids = {}
|
|
for loaderData in cs_pairs(self.view.loader.hitGrids) do
|
|
if loaderData.isDuplicated and loaderData.globalGridId == targetLoaderData.globalGridId then
|
|
if self.m_loadedGridViewDataMap[loaderData.gridId] ~= nil then
|
|
table.insert(grids, loaderData)
|
|
end
|
|
end
|
|
end
|
|
return grids
|
|
end
|
|
|
|
for loaderData in cs_pairs(self.view.loader.hitGrids) do
|
|
if not loaderData.isDuplicated and self.m_loadedGridViewDataMap[loaderData.gridId] == nil then
|
|
|
|
self:_RefreshGrid(loaderData, true, function(gridId)
|
|
local gridData = self.m_loadedGridViewDataMap[gridId]
|
|
if gridData ~= nil then
|
|
local duplicatedGrids = getDuplicatedGridsFunc(gridData.loaderData)
|
|
if next(duplicatedGrids) then
|
|
for _, duplicatedLoaderData in pairs(duplicatedGrids) do
|
|
self:_RefreshGrid(duplicatedLoaderData, false)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridMarks = HL.Method(HL.Userdata, HL.Boolean) << function(self, loaderData, needShow)
|
|
local marks = loaderData.marks
|
|
if marks == nil or marks.Count == 0 then
|
|
return
|
|
end
|
|
for markInstId, markRuntimeData in pairs(marks) do
|
|
self:_RefreshGridMark(markInstId, markRuntimeData, needShow)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridMark = HL.Method(HL.String, HL.Userdata, HL.Boolean) << function(self, markInstId, markRuntimeData, needShow)
|
|
local invisibleInMist = not markRuntimeData.visibleInMist and markRuntimeData:IsInMist()
|
|
if invisibleInMist then
|
|
if needShow then
|
|
self.m_waitVisibleInMistMarks[markInstId] = true
|
|
else
|
|
self.m_waitVisibleInMistMarks[markInstId] = nil
|
|
end
|
|
return
|
|
end
|
|
|
|
if not markRuntimeData.isConstantState and self.m_needListenMarkStateChange then
|
|
if needShow then
|
|
markRuntimeData:AddStateChangeCallback("LoadedMark")
|
|
else
|
|
markRuntimeData:RemoveStateChangeCallback("LoadedMark")
|
|
end
|
|
end
|
|
|
|
if needShow and markRuntimeData.isVisible then
|
|
local templateId = markRuntimeData.templateId
|
|
local templateData = self.m_markStaticDataMap[templateId]
|
|
local order = templateData.sortOrder
|
|
|
|
local markViewData, markObj
|
|
local getFromCache
|
|
if self.m_loadedMarkViewDataMap[markInstId] then
|
|
markViewData = self.m_loadedMarkViewDataMap[markInstId]
|
|
markObj = markViewData.markObj
|
|
getFromCache = false
|
|
else
|
|
markViewData = {
|
|
instId = markInstId,
|
|
runtimeData = markRuntimeData,
|
|
sortOrder = order,
|
|
visibleLayer = templateData.visibleLayer,
|
|
filterType = templateData.filterType,
|
|
filterTypeEnum = templateData.filterTypeEnum,
|
|
isPowerRelated = false,
|
|
isTravelRelated = false,
|
|
}
|
|
markObj = self:_GetMarkFromCache(markViewData)
|
|
self.m_loadedMarkViewDataMap[markInstId] = markViewData
|
|
getFromCache = true
|
|
end
|
|
|
|
markViewData.markObj = markObj
|
|
markViewData.mark = markObj.view
|
|
|
|
markObj:InitLevelMapMark(markRuntimeData.rectPosition, markRuntimeData, self.m_needOptimizePerformance, not getFromCache)
|
|
|
|
|
|
if markRuntimeData.isPowerRelated ~= nil then
|
|
markViewData.isPowerRelated = markRuntimeData.isPowerRelated
|
|
end
|
|
if markRuntimeData.isTravelRelated ~= nil then
|
|
markViewData.isTravelRelated = markRuntimeData.isTravelRelated
|
|
end
|
|
|
|
|
|
self:_RefreshGridMarkTierState(markObj)
|
|
|
|
|
|
if self.m_onMarkHover ~= nil then
|
|
markObj:SetMarkOnHoverCallback(function(isHover)
|
|
self.m_onMarkHover(markInstId, isHover)
|
|
end)
|
|
end
|
|
|
|
|
|
if self.view.config.INITIAL_MARK_SCALE ~= 1 then
|
|
markObj.view.rectTransform.localScale = self.m_initialMarkScale
|
|
end
|
|
else
|
|
local markViewData = self.m_loadedMarkViewDataMap[markInstId]
|
|
if markViewData ~= nil and markViewData.markObj ~= nil then
|
|
local markObj = markViewData.markObj
|
|
self:_CacheMark(markViewData, markObj)
|
|
self.m_loadedMarkViewDataMap[markInstId] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshNonConstantStateMark = HL.Method(HL.String) << function(self, markInstId)
|
|
if self.m_loadedMarkViewDataMap[markInstId] then
|
|
local markObj = self.m_loadedMarkViewDataMap[markInstId].markObj
|
|
markObj:ResetMarkIcon()
|
|
else
|
|
self:_OnMarkInstDataChanged(markInstId, true)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridMarkTierState = HL.Method(HL.Any) << function(self, mark)
|
|
if mark == nil then
|
|
return
|
|
end
|
|
mark:RefreshMarkTierState(self.m_tierIndex, not self.m_needShowMarkTier)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridStaticElements = HL.Method(HL.Userdata, HL.Boolean) << function(self, loaderData, needShow)
|
|
local staticElements = loaderData.staticElements
|
|
if staticElements == nil or staticElements.Count == 0 then
|
|
return
|
|
end
|
|
for staticElementId, staticElementData in pairs(staticElements) do
|
|
if staticElementData ~= nil and self:_IsExpectedStaticElementType(staticElementData.type) then
|
|
if needShow then
|
|
local initializer = self.m_staticElementInitializer[staticElementData.type]
|
|
if initializer ~= nil then
|
|
local isVisible = initializer.isVisible == nil or initializer.isVisible(staticElementData)
|
|
if isVisible then
|
|
if self.m_loadedStaticElementViewDataMap[staticElementId] == nil then
|
|
|
|
local staticElement = initializer.cache:Get()
|
|
staticElement.gameObject:SetActive(true)
|
|
initializer.initializer(staticElement, staticElementData)
|
|
staticElement.rectTransform.anchoredPosition = self:_GetRectPosByWorldPos(staticElementData.position)
|
|
self.m_loadedStaticElementViewDataMap[staticElementId] = {
|
|
elementObj = staticElement,
|
|
initializer = initializer,
|
|
}
|
|
else
|
|
|
|
self:_RefreshStaticElementVisibleState(self.m_loadedStaticElementViewDataMap[staticElementId], "GridRefresh", true)
|
|
end
|
|
self:_RefreshLoadedStaticElementStateWithTier(self.m_loadedStaticElementViewDataMap[staticElementId])
|
|
end
|
|
end
|
|
else
|
|
local elementViewData = self.m_loadedStaticElementViewDataMap[staticElementId]
|
|
if elementViewData ~= nil then
|
|
|
|
self:_RefreshStaticElementVisibleState(elementViewData, "GridRefresh", false)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshStaticElementVisibleState = HL.Method(HL.Table, HL.String, HL.Boolean) << function(self, elementViewData, key, isVisible)
|
|
if elementViewData == nil then
|
|
return
|
|
end
|
|
if elementViewData.hideKeyList == nil then
|
|
elementViewData.hideKeyList = {}
|
|
end
|
|
if isVisible then
|
|
elementViewData.hideKeyList[key] = nil
|
|
else
|
|
elementViewData.hideKeyList[key] = true
|
|
end
|
|
elementViewData.elementObj.gameObject:SetActive(not next(elementViewData.hideKeyList))
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridLines = HL.Method(HL.Userdata, HL.Boolean) << function(self, loaderData, needShow)
|
|
local lines = loaderData.lines
|
|
if lines == nil or lines.Count == 0 then
|
|
return
|
|
end
|
|
|
|
for _, lineData in pairs(lines) do
|
|
self:_RefreshGridLine(lineData, needShow)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridLine = HL.Method(HL.Userdata, HL.Boolean) << function(self, lineData, needShow)
|
|
local lineType = lineData.lineType
|
|
local lineId = lineData.lineId
|
|
local lineCache = self.m_lineCaches[lineType]
|
|
if needShow then
|
|
local needAdd = self.m_loadedLineViewDataMap[lineId] == nil
|
|
if needAdd then
|
|
local line = lineCache:Get()
|
|
line.gameObject:SetActive(true)
|
|
self:_RefreshLineBasicTransform(line, lineData)
|
|
|
|
|
|
if lineType == LineType.Power then
|
|
line.image.color = lineData.hasPower and
|
|
self.view.config.POWER_LINE_VALID_COLOR or
|
|
self.view.config.POWER_LINE_INVALID_COLOR
|
|
end
|
|
|
|
self.m_loadedLineViewDataMap[lineId] = {
|
|
lineId = lineId,
|
|
lineData = lineData,
|
|
lineObj = line,
|
|
loadCount = 1,
|
|
}
|
|
line.gameObject.name = string.format("Line_%s", lineId)
|
|
else
|
|
self.m_loadedLineViewDataMap[lineId].loadCount = self.m_loadedLineViewDataMap[lineId].loadCount + 1
|
|
end
|
|
else
|
|
if self.m_loadedLineViewDataMap[lineId] ~= nil then
|
|
local viewData = self.m_loadedLineViewDataMap[lineId]
|
|
viewData.loadCount = math.max(0, viewData.loadCount - 1)
|
|
local needRemove = viewData.loadCount == 0
|
|
if needRemove then
|
|
local loadedLine = viewData.lineObj
|
|
loadedLine.gameObject:SetActive(false)
|
|
if loadedLine.levelMapLine ~= nil then
|
|
loadedLine.levelMapLine:ClearComponent()
|
|
end
|
|
loadedLine.gameObject.name = "CachedLine"
|
|
lineCache:Cache(loadedLine)
|
|
self.m_loadedLineViewDataMap[lineId] = nil
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLineBasicTransform = HL.Method(HL.Any, HL.Userdata) << function(self, line, lineData)
|
|
if line == nil or lineData == nil then
|
|
return
|
|
end
|
|
local startRectPos = self:_GetRectPosByWorldPos(lineData.startPosition)
|
|
local endRectPos = self:_GetRectPosByWorldPos(lineData.endPosition)
|
|
local direction = endRectPos - startRectPos
|
|
local length = direction.magnitude
|
|
line.rectTransform.sizeDelta = Vector2(length, line.rectTransform.rect.height)
|
|
line.rectTransform.anchoredPosition = (startRectPos + endRectPos) / 2
|
|
local angle = math.acos(Vector2.Dot(direction.normalized, Vector2.right)) * (180 / math.pi)
|
|
if direction.y < 0 then
|
|
angle = 360 - angle
|
|
end
|
|
line.rectTransform.localRotation = Quaternion.Euler(0, 0, angle)
|
|
if line.levelMapLine ~= nil then
|
|
line.levelMapLine:Init(length)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGameplayArea = HL.Method(HL.String, HL.Boolean) << function(self, areaId, needShow)
|
|
if needShow then
|
|
if self.m_loadedGameplayAreas[areaId] == nil then
|
|
local success, areaData = self.m_mapManager:GetGameplayAreaInstRuntimeData(areaId)
|
|
if success and areaData.mapId == self.m_mapId then
|
|
|
|
local gameplayArea = self.m_gameplayAreaCache:Get()
|
|
gameplayArea.rectTransform.anchoredPosition = self:_GetRectPosByWorldPos(areaData.position)
|
|
gameplayArea.gameObject:SetActive(true)
|
|
gameplayArea.levelMapGameplayArea:Init(areaData)
|
|
self.m_loadedGameplayAreas[areaId] = gameplayArea
|
|
end
|
|
end
|
|
else
|
|
if self.m_loadedGameplayAreas[areaId] ~= nil then
|
|
local gameplayArea = self.m_loadedGameplayAreas[areaId]
|
|
gameplayArea.levelMapGameplayArea:ClearComponent()
|
|
gameplayArea.gameObject:SetActive(false)
|
|
self.m_gameplayAreaCache:Cache(gameplayArea)
|
|
self.m_loadedGameplayAreas[areaId] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridMists = HL.Method(HL.Boolean, HL.Opt(HL.Table, HL.Function)) << function(self, usedForAnim, overrideMistIdList, onRefreshFinish)
|
|
local refreshData = self:_GetMistRefreshData(usedForAnim)
|
|
|
|
refreshData.loadedMists = {}
|
|
refreshData.loadedMistGrids = {}
|
|
local loadedMists = refreshData.loadedMists
|
|
local loadedMistGrids = refreshData.loadedMistGrids
|
|
|
|
for loaderData in cs_pairs(self.view.loader.hitGrids) do
|
|
if loaderData.needLoadMists then
|
|
local needLoadMistList = {}
|
|
for mistId, gridMistId in pairs(loaderData.mists) do
|
|
local needLoad = false
|
|
if overrideMistIdList then
|
|
if overrideMistIdList[mistId] then
|
|
needLoad = true
|
|
end
|
|
else
|
|
if not self.m_mistSystem:IsUnlockedMistMap(mistId) then
|
|
needLoad = true
|
|
end
|
|
end
|
|
if needLoad then
|
|
needLoadMistList[mistId] = gridMistId
|
|
end
|
|
end
|
|
if next(needLoadMistList) then
|
|
loadedMists[loaderData.gridId] = needLoadMistList
|
|
loadedMistGrids[loaderData.gridId] = loaderData
|
|
end
|
|
end
|
|
end
|
|
|
|
self:_RefreshLoadedGridMists(usedForAnim, onRefreshFinish)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedGridMists = HL.Method(HL.Boolean, HL.Opt(HL.Function)) << function(self, usedForAnim, onRefreshFinish)
|
|
local refreshData = self:_GetMistRefreshData(usedForAnim)
|
|
refreshData.transformData = {}
|
|
local loadedMists = refreshData.loadedMists
|
|
local loadedMistGrids = refreshData.loadedMistGrids
|
|
local textureCache = refreshData.textureCache
|
|
local mist = usedForAnim and self.view.element.animMist or self.view.element.mist
|
|
|
|
local tryInitMistSingleTextureLength = function(texture)
|
|
if self.m_gridMistSingleTextureLength <= 0 then
|
|
self.m_gridMistSingleTextureLength = texture.width
|
|
end
|
|
end
|
|
|
|
local invokeOnRefreshFinish = function(isMistVisible)
|
|
if not usedForAnim then
|
|
mist.gameObject:SetActive(isMistVisible)
|
|
end
|
|
|
|
if onRefreshFinish ~= nil then
|
|
onRefreshFinish()
|
|
end
|
|
end
|
|
|
|
if next(loadedMists) then
|
|
|
|
for gridId, mistList in pairs(loadedMists) do
|
|
for mistId, gridMistId in pairs(mistList) do
|
|
if textureCache[gridMistId] == nil then
|
|
local loaderData = loadedMistGrids[gridId]
|
|
local folder = UILevelMapUtils.GetUILevelMapMistsFolderByLevelId(loaderData.levelId, true)
|
|
local path = string.format("%s/%s.png", folder, gridMistId)
|
|
textureCache[gridMistId] = {
|
|
mistId = mistId,
|
|
gridMistId = gridMistId,
|
|
gridId = gridId,
|
|
}
|
|
if self.m_needOptimizePerformance then
|
|
if textureCache[gridMistId].handlerKey == nil then
|
|
textureCache[gridMistId].waitAsyncLoadFinish = true
|
|
textureCache[gridMistId].handlerKey = self.loader:LoadTextureAsync(path, function(texture)
|
|
tryInitMistSingleTextureLength(texture)
|
|
textureCache[gridMistId].texture = texture
|
|
textureCache[gridMistId].waitAsyncLoadFinish = nil
|
|
self:_TryFinishMistTextureAsyncLoad(refreshData)
|
|
end)
|
|
end
|
|
else
|
|
local texture, handlerKey = self.loader:LoadTexture(path)
|
|
tryInitMistSingleTextureLength(texture)
|
|
textureCache[gridMistId].handlerKey = handlerKey
|
|
textureCache[gridMistId].texture = texture
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if self.m_needOptimizePerformance then
|
|
|
|
table.insert(refreshData.waitInvokeRefreshFinishList, invokeOnRefreshFinish)
|
|
else
|
|
|
|
self:_RefreshMistsAfterLoadedTexture(usedForAnim)
|
|
invokeOnRefreshFinish(true)
|
|
end
|
|
else
|
|
invokeOnRefreshFinish(false)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._TryFinishMistTextureAsyncLoad = HL.Method(HL.Table) << function(self, refreshData)
|
|
if refreshData == nil then
|
|
return
|
|
end
|
|
|
|
if not next(refreshData.textureCache) then
|
|
return
|
|
end
|
|
|
|
for _, cacheData in pairs(refreshData.textureCache) do
|
|
if cacheData.waitAsyncLoadFinish then
|
|
return
|
|
end
|
|
end
|
|
self:_RefreshMistsAfterLoadedTexture(refreshData.usedForAnim)
|
|
self:_InvokeAllWaitInvokeMistRefreshFinish(refreshData)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._InvokeAllWaitInvokeMistRefreshFinish = HL.Method(HL.Table) << function(self, refreshData)
|
|
if refreshData == nil then
|
|
return
|
|
end
|
|
|
|
if not next(refreshData.waitInvokeRefreshFinishList) then
|
|
return
|
|
end
|
|
|
|
for _, onRefreshFinish in ipairs(refreshData.waitInvokeRefreshFinishList) do
|
|
onRefreshFinish(true)
|
|
end
|
|
|
|
refreshData.waitInvokeRefreshFinishList = {}
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._DisposeLoadedMistTexturesOnRefreshIfNeed = HL.Method(HL.Table) << function(self, refreshData)
|
|
if refreshData == nil then
|
|
return
|
|
end
|
|
|
|
local disposeAndClearCacheData = function(gridMistId)
|
|
local cacheData = refreshData.textureCache[gridMistId]
|
|
self:_DisposeLoadedGridMistTexture(cacheData)
|
|
refreshData.textureCache[gridMistId] = nil
|
|
end
|
|
|
|
|
|
local needClearGrids = {}
|
|
for gridMistId, cacheData in pairs(refreshData.textureCache) do
|
|
local gridId = cacheData.gridId
|
|
local needClear = refreshData.loadedMists[gridId] == nil or
|
|
refreshData.loadedMistGrids[gridId] == nil
|
|
if needClear then
|
|
if needClearGrids[gridId] == nil then
|
|
needClearGrids[gridId] = {}
|
|
end
|
|
table.insert(needClearGrids[gridId], gridMistId)
|
|
end
|
|
end
|
|
for gridId, needClearGridMists in pairs(needClearGrids) do
|
|
for _, gridMistId in ipairs(needClearGridMists) do
|
|
disposeAndClearCacheData(gridMistId)
|
|
end
|
|
refreshData.loadedMists[gridId] = nil
|
|
refreshData.loadedMistGrids[gridId] = nil
|
|
end
|
|
|
|
|
|
if not refreshData.usedForAnim then
|
|
for gridMistId, cacheData in pairs(refreshData.textureCache) do
|
|
local mistId = cacheData.mistId
|
|
local needClear = self.m_mistSystem:IsUnlockedMistMap(mistId)
|
|
if needClear then
|
|
disposeAndClearCacheData(gridMistId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._StopWaitingFinishRefreshMist = HL.Method() << function(self)
|
|
local refreshData = self:_GetMistRefreshData(false)
|
|
if refreshData == nil then
|
|
return
|
|
end
|
|
|
|
for _, cacheData in pairs(refreshData.textureCache) do
|
|
self:_DisposeLoadedGridMistTexture(cacheData)
|
|
end
|
|
refreshData.textureCache = {}
|
|
refreshData.waitLoadTextures = {}
|
|
refreshData.waitInvokeRefreshFinishList = {}
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._DisposeLoadedGridMistTexture = HL.Method(HL.Table) << function(self, cacheData)
|
|
if cacheData == nil then
|
|
return
|
|
end
|
|
cacheData.texture = nil
|
|
self.loader:DisposeHandleByKey(cacheData.handlerKey)
|
|
cacheData.handlerKey = nil
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMistsTextureState = HL.Method(HL.Table, HL.Boolean) << function(self, refreshData, usedForAnim)
|
|
if refreshData == nil then
|
|
return
|
|
end
|
|
|
|
local rt = refreshData.rt
|
|
local mist = usedForAnim and self.view.element.animMist or self.view.element.mist
|
|
|
|
local mistLength = self.m_gridMistSingleTextureLength
|
|
mistLength = mistLength > 0 and mistLength or self.m_gridRectLength
|
|
local ratio = mistLength / self.m_gridRectLength
|
|
if self.m_isLowMemoryDevice then
|
|
ratio = ratio * LOW_MEMORY_DEVICE_MIST_TEXTURE_LENGTH_RATIO
|
|
end
|
|
local viewLeft = self.view.loader.currViewLeftBottom.x
|
|
local viewRight = self.view.loader.currViewRightTop.x
|
|
local viewBottom = self.view.loader.currViewLeftBottom.y
|
|
local viewTop = self.view.loader.currViewRightTop.y
|
|
local width = (math.ceil((viewRight - viewLeft) / self.m_gridRectLength) + 1) * self.m_gridRectLength
|
|
local height = (math.ceil((viewTop - viewBottom) / self.m_gridRectLength) + 1) * self.m_gridRectLength
|
|
width = math.floor(width * ratio)
|
|
height = math.floor(height * ratio)
|
|
|
|
local needRefreshState = rt == nil or rt.width < width or rt.height < height
|
|
|
|
if needRefreshState then
|
|
if rt ~= nil then
|
|
|
|
RTManager.ReleaseRenderTexture(rt)
|
|
end
|
|
rt = RTManager.GetRenderTexture("LevelMapLoaderMistsRT", width, height, 0, true, true)
|
|
mist.rectTransform.sizeDelta = Vector2(width, height)
|
|
mist.rectTransform.localScale = Vector3.one / ratio
|
|
mist.image.texture = rt
|
|
refreshData.lowRatio = ratio
|
|
refreshData.rt = rt
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMistsAfterLoadedTexture = HL.Method(HL.Boolean) << function(self, usedForAnim)
|
|
local refreshData = self:_GetMistRefreshData(usedForAnim)
|
|
local mist = usedForAnim and self.view.element.animMist or self.view.element.mist
|
|
|
|
|
|
self:_DisposeLoadedMistTexturesOnRefreshIfNeed(refreshData)
|
|
if next(refreshData.textureCache) == nil then
|
|
return
|
|
end
|
|
|
|
|
|
self:_RefreshMistsTextureState(refreshData, usedForAnim)
|
|
|
|
|
|
local left, right, bottom, top
|
|
for gridId, _ in pairs(refreshData.loadedMists) do
|
|
local loaderData = refreshData.loadedMistGrids[gridId]
|
|
if left == nil then
|
|
left = loaderData.rectLeftBottom.x
|
|
right = loaderData.rectRightTop.x
|
|
bottom = loaderData.rectLeftBottom.y
|
|
top = loaderData.rectRightTop.y
|
|
else
|
|
left = loaderData.rectLeftBottom.x < left and loaderData.rectLeftBottom.x or left
|
|
right = loaderData.rectRightTop.x > right and loaderData.rectRightTop.x or right
|
|
bottom = loaderData.rectLeftBottom.y < bottom and loaderData.rectLeftBottom.y or bottom
|
|
top = loaderData.rectRightTop.y > top and loaderData.rectRightTop.y or top
|
|
end
|
|
end
|
|
local mistSize = mist.rectTransform.sizeDelta * mist.rectTransform.localScale.x
|
|
refreshData.transformData = {
|
|
left = left,
|
|
right = right,
|
|
bottom = bottom,
|
|
top = top,
|
|
}
|
|
mist.rectTransform.anchoredPosition = Vector2(left + mistSize.x / 2, top - mistSize.y / 2)
|
|
|
|
|
|
self:_ClearMistRenderTexture(usedForAnim)
|
|
|
|
|
|
local rt = refreshData.rt
|
|
local currTexture = RenderTexture.active
|
|
RenderTexture.active = rt
|
|
GL.PushMatrix()
|
|
GL.LoadPixelMatrix(0, rt.width, rt.height, 0)
|
|
table.sort(refreshData.textureCache, Utils.genSortFunction({ "gridMistId" }, true))
|
|
for gridMistId, _ in pairs(refreshData.textureCache) do
|
|
self:_RefreshMistWithLoadedTexture(gridMistId, usedForAnim)
|
|
end
|
|
GL.PopMatrix()
|
|
RenderTexture.active = currTexture
|
|
|
|
refreshData.textureCache = {}
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._ClearMistRenderTexture = HL.Method(HL.Boolean) << function(self, usedForAnim)
|
|
local refreshData = self:_GetMistRefreshData(usedForAnim)
|
|
local rt = refreshData.rt
|
|
if rt == nil then
|
|
return
|
|
end
|
|
|
|
local currTexture = RenderTexture.active
|
|
RenderTexture.active = rt
|
|
GL.Clear(true, true, Color.clear)
|
|
RenderTexture.active = currTexture
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMistWithLoadedTexture = HL.Method(HL.String, HL.Boolean) << function(self, gridMistId, usedForAnim)
|
|
local refreshData = self:_GetMistRefreshData(usedForAnim)
|
|
local lowRatio = refreshData.lowRatio
|
|
local transformData = refreshData.transformData
|
|
|
|
local cacheData = refreshData.textureCache[gridMistId]
|
|
local loaderData = refreshData.loadedMistGrids[cacheData.gridId]
|
|
local targetRect = Rect(
|
|
lowRatio * (loaderData.rectLeftBottom.x - transformData.left),
|
|
lowRatio * (transformData.top - loaderData.rectRightTop.y),
|
|
lowRatio * self.m_gridRectLength,
|
|
lowRatio * self.m_gridRectLength
|
|
)
|
|
Graphics.DrawTexture(targetRect, cacheData.texture, self.m_gridMistDrawMaterial)
|
|
|
|
self:_DisposeLoadedGridMistTexture(cacheData)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedStaticElementStateWithTier = HL.Method(HL.Table) << function(self, elementViewData)
|
|
local isInTier = self:_GetIsInTier()
|
|
local color = isInTier and self.m_levelMapConfig.gridBaseTierColor or Color.white
|
|
local elementObj = elementViewData.elementObj
|
|
local initializer = elementViewData.initializer
|
|
if initializer.needHideInTier then
|
|
self:_RefreshStaticElementVisibleState(elementViewData, "Tier", not isInTier)
|
|
elseif initializer.refreshWithTier ~= nil then
|
|
initializer.refreshWithTier(elementObj, self.m_tierIndex, color)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedStaticElementsStateWithTier = HL.Method() << function(self)
|
|
for _, elementViewData in pairs(self.m_loadedStaticElementViewDataMap) do
|
|
self:_RefreshLoadedStaticElementStateWithTier(elementViewData)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedGridsSpriteWithTier = HL.Method() << function(self)
|
|
for gridId, gridData in pairs(self.m_loadedGridViewDataMap) do
|
|
local sprite = self:_GetGridSprite(gridId)
|
|
gridData.cell.image.sprite = sprite
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedGridsColorWithTier = HL.Method() << function(self)
|
|
local isInTier = self:_GetIsInTier()
|
|
local tierColor = self.m_levelMapConfig.gridBaseTierColor
|
|
for gridId, gridData in pairs(self.m_loadedGridViewDataMap) do
|
|
local spriteData = self.m_gridSpriteCache[gridId]
|
|
local alpha = gridData.cell.image.color.a
|
|
local color
|
|
if not isInTier or (spriteData and spriteData.isTierSprite) then
|
|
color = Color.white
|
|
else
|
|
color = tierColor
|
|
end
|
|
color.a = alpha
|
|
gridData.cell.image.color = color
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshLoadedMarksWithTier = HL.Method() << function(self)
|
|
for _, markViewData in pairs(self.m_loadedMarkViewDataMap) do
|
|
local markObj = markViewData.markObj
|
|
self:_RefreshGridMarkTierState(markObj)
|
|
end
|
|
|
|
|
|
self:_RefreshMissionTrackingMarksWithTier()
|
|
self:_RefreshGeneralTrackingMarkWithTier()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMissionTrackingMarksWithTier = HL.Method() << function(self)
|
|
for _, missionTrackingMarkObj in pairs(self.m_loadedMissionTrackingMarks) do
|
|
local missionMarkObj = missionTrackingMarkObj
|
|
self:_RefreshGridMarkTierState(missionMarkObj)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGeneralTrackingMarkWithTier = HL.Method() << function(self)
|
|
self:_GetGeneralTrackingMarkIfNeed()
|
|
if string.isEmpty(self.m_loadedGeneralTrackingMarkId) then
|
|
return
|
|
end
|
|
self:_RefreshGridMarkTierState(self.view.element.trackingMarkRoot.generalTrackingMark)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGridsMask = HL.Method() << function(self)
|
|
if not self.view.element.gridsMask.gameObject.activeSelf then
|
|
return
|
|
end
|
|
local targetRect = self.m_gridsMaskFollowTarget.rect
|
|
self.view.element.gridsMask.sizeDelta = Vector2(targetRect.width, targetRect.height)
|
|
self.view.element.gridsMask.position = self.m_gridsMaskFollowTarget.position
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshPermanentStaticElementsLoadedState = HL.Method() << function(self)
|
|
for elementLoaderData in cs_pairs(self.view.loader.permanentStaticElements) do
|
|
if elementLoaderData.needLoadFlag then
|
|
if self.m_loadedStaticElementViewDataMap[elementLoaderData.elementId] == nil then
|
|
self:_LoadPermanentStaticElement(elementLoaderData)
|
|
else
|
|
local viewData = self.m_loadedStaticElementViewDataMap[elementLoaderData.elementId]
|
|
if viewData.delayUnloadKey ~= nil then
|
|
self:_RemoveMapDelayAction(viewData.delayUnloadKey)
|
|
end
|
|
end
|
|
else
|
|
if self.m_loadedStaticElementViewDataMap[elementLoaderData.elementId] ~= nil then
|
|
local viewData = self.m_loadedStaticElementViewDataMap[elementLoaderData.elementId]
|
|
if self.m_needOptimizePerformance then
|
|
local key = self:_AddMapDelayAction(
|
|
elementLoaderData.elementId,
|
|
function()
|
|
viewData.delayUnloadKey = nil
|
|
self:_UnloadPermanentStaticElement(elementLoaderData.elementId)
|
|
end
|
|
)
|
|
viewData.delayUnloadKey = key
|
|
else
|
|
self:_UnloadPermanentStaticElement(elementLoaderData.elementId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetMarkCache = HL.Method(HL.Table).Return(Stack) << function(self, markViewData)
|
|
local cache
|
|
if self.m_needInteractableMark then
|
|
local isCustom = markViewData.sortOrder == CUSTOM_MARK_ORDER
|
|
cache = isCustom and self.m_customMarkCache or self.m_markCache
|
|
else
|
|
cache = self.m_markCache
|
|
end
|
|
return cache
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetMarkSourceObj = HL.Method(HL.Table).Return(HL.Any) << function(self, markViewData)
|
|
local sourceObj
|
|
local markSource = self.view.source.marks
|
|
if self.m_needInteractableMark then
|
|
local isCustom = markViewData.sortOrder == CUSTOM_MARK_ORDER
|
|
sourceObj = isCustom and markSource.levelMapCustomMark or markSource.levelMapInteractableMark
|
|
else
|
|
sourceObj = markSource.levelMapMark
|
|
end
|
|
return sourceObj
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetMarkFromCache = HL.Method(HL.Table).Return(HL.Any) << function(self, markViewData)
|
|
local orderRoot = self:_GetMarkRootByOrder(markViewData.sortOrder)
|
|
local markCache, markSourceObj = self:_GetMarkCache(markViewData), self:_GetMarkSourceObj(markViewData)
|
|
local markObj
|
|
if markCache:Count() > 0 then
|
|
markObj = markCache:Pop()
|
|
else
|
|
markObj = Utils.wrapLuaNode(CSUtils.CreateObject(markSourceObj.gameObject, orderRoot))
|
|
end
|
|
if markObj.transform.parent ~= orderRoot then
|
|
markObj.transform:SetParent(orderRoot)
|
|
end
|
|
markObj.gameObject:SetActive(true)
|
|
return markObj
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._CacheMark = HL.Method(HL.Table, HL.Any) << function(self, markViewData, markObj)
|
|
local markCache = self:_GetMarkCache(markViewData)
|
|
markObj:ClearLevelMapMark()
|
|
markObj.gameObject:SetActive(false)
|
|
markCache:Push(markObj)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetTrackingMarkFromCache = HL.Method(HL.Boolean).Return(HL.Any) << function(self, isMissionTracking)
|
|
local trackingRoot = self.view.element.trackingMarkRoot
|
|
local root = isMissionTracking and trackingRoot.mission or trackingRoot.general
|
|
local sourceObj = self.view.source.marks.levelMapTrackingMark
|
|
local trackingMarkObj
|
|
if self.m_trackingMarkCache:Count() > 0 then
|
|
trackingMarkObj = self.m_trackingMarkCache:Pop()
|
|
else
|
|
trackingMarkObj = Utils.wrapLuaNode(CSUtils.CreateObject(sourceObj.gameObject, root))
|
|
end
|
|
if trackingMarkObj.transform.parent ~= root then
|
|
trackingMarkObj.transform:SetParent(root)
|
|
end
|
|
trackingMarkObj.gameObject:SetActive(true)
|
|
return trackingMarkObj
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._CacheTrackingMark = HL.Method(HL.Any) << function(self, trackingMarkObj)
|
|
trackingMarkObj:ClearLevelMapMark()
|
|
trackingMarkObj.gameObject:SetActive(false)
|
|
self.m_trackingMarkCache:Push(trackingMarkObj)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._GetGeneralTrackingMarkIfNeed = HL.Method() << function(self)
|
|
if self.view.element.trackingMarkRoot.generalTrackingMark ~= nil then
|
|
return
|
|
end
|
|
self.view.element.trackingMarkRoot.generalTrackingMark = self:_GetTrackingMarkFromCache(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMissionTrackingMarksLevelState = HL.Method() << function(self)
|
|
self.m_missionTrackingMarkInOtherLevel = ""
|
|
|
|
if self.m_loadedMissionTrackingMarks == nil then
|
|
return
|
|
end
|
|
|
|
for instId, missionTrackingMarkObj in pairs(self.m_loadedMissionTrackingMarks) do
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(instId)
|
|
if success then
|
|
local levelMapMark = missionTrackingMarkObj
|
|
local mark = missionTrackingMarkObj
|
|
if markRuntimeData.levelId == self.m_levelId then
|
|
levelMapMark:ResetMarkIcon()
|
|
mark:ResetMarkRectPosition()
|
|
levelMapMark:ToggleMarkHiddenState("TrackingOtherLevel", false)
|
|
else
|
|
if self.m_needShowOtherLevelTracking then
|
|
local missionImportance = markRuntimeData.missionInfo.missionImportance
|
|
local iconName
|
|
if missionImportance == GEnums.MissionImportance.High then
|
|
iconName = MapConst.MISSION_HIGH_IMPORTANCE_TRACK_OTHER_LEVEL_ICON_NAME
|
|
elseif missionImportance == GEnums.MissionImportance.Mid then
|
|
iconName = MapConst.MISSION_MID_IMPORTANCE_TRACK_OTHER_LEVEL_ICON_NAME
|
|
else
|
|
iconName = MapConst.MISSION_LOW_IMPORTANCE_TRACK_OTHER_LEVEL_ICON_NAME
|
|
end
|
|
local startLevelId, endLevelId = self.m_levelId, markRuntimeData.levelId
|
|
local trackPosition, trackLevel = MapUtils.getLevelTrackPositionAndLevel(startLevelId, endLevelId)
|
|
trackPosition = Vector3(trackPosition.x, trackPosition.y, trackPosition.z)
|
|
local trackRectPosition = self:_GetRectPosByWorldPos(trackPosition)
|
|
levelMapMark:OverrideMarkIcon(iconName)
|
|
mark:OverrideMarkRectPosition(trackRectPosition)
|
|
self.m_missionTrackingMarkInOtherLevel = trackLevel
|
|
else
|
|
levelMapMark:ToggleMarkHiddenState("TrackingOtherLevel", true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
self:_RefreshMissionTrackingMarksOffset()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGeneralTrackingMarkLevelState = HL.Method() << function(self)
|
|
self:_GetGeneralTrackingMarkIfNeed()
|
|
self:_RefreshGeneralTrackingMarkIsInOtherLevel("")
|
|
|
|
if string.isEmpty(self.m_loadedGeneralTrackingMarkId) then
|
|
return
|
|
end
|
|
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(self.m_loadedGeneralTrackingMarkId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
local levelMapMark = self.view.element.trackingMarkRoot.generalTrackingMark
|
|
local mark = self.view.element.trackingMarkRoot.generalTrackingMark
|
|
if markRuntimeData.levelId == self.m_levelId then
|
|
levelMapMark:ResetMarkIcon()
|
|
mark:ResetMarkRectPosition()
|
|
levelMapMark:ToggleMarkHiddenState("TrackingOtherLevel", false)
|
|
else
|
|
if self.m_needShowOtherLevelTracking then
|
|
levelMapMark:OverrideMarkIcon(MapConst.GENERAL_TRACK_OTHER_LEVEL_ICON_NAME)
|
|
local startLevelId, endLevelId = self.m_levelId, markRuntimeData.levelId
|
|
local trackPosition, trackLevel = MapUtils.getLevelTrackPositionAndLevel(startLevelId, endLevelId)
|
|
trackPosition = Vector3(trackPosition.x, trackPosition.y, trackPosition.z)
|
|
local trackRectPosition = self:_GetRectPosByWorldPos(trackPosition)
|
|
mark:OverrideMarkRectPosition(trackRectPosition)
|
|
self:_RefreshGeneralTrackingMarkIsInOtherLevel(trackLevel)
|
|
else
|
|
levelMapMark:ToggleMarkHiddenState("TrackingOtherLevel", true)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshGeneralTrackingMarkIsInOtherLevel = HL.Method(HL.String) << function(self, otherLevel)
|
|
self.m_generalTrackingMarkInOtherLevel = otherLevel
|
|
self:_RefreshMissionTrackingMarksOffset()
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMissionTrackingMarksOffset = HL.Method() << function(self)
|
|
local offsetPosition = Vector2(self.view.config.MISSION_TRACKING_MARK_OFFSET_X, self.view.config.MISSION_TRACKING_MARK_OFFSET_Y)
|
|
for instId, missionTrackingMarkObj in pairs(self.m_loadedMissionTrackingMarks) do
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(instId)
|
|
if success then
|
|
local needOffset = markRuntimeData.levelId ~= self.m_levelId and
|
|
self.m_generalTrackingMarkInOtherLevel == self.m_missionTrackingMarkInOtherLevel and
|
|
not string.isEmpty(self.m_generalTrackingMarkInOtherLevel)
|
|
missionTrackingMarkObj.view.content.anchoredPosition = needOffset and offsetPosition or Vector2.zero
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshMissionTrackingMarksPosition = HL.Method() << function(self)
|
|
if not self.m_mapManager.needRefreshMissionTrackingMarkPos then
|
|
return
|
|
end
|
|
if self.m_loadedMissionTrackingMarks == nil or not next(self.m_loadedMissionTrackingMarks) then
|
|
return
|
|
end
|
|
for instId, missionTrackingMarkObj in pairs(self.m_loadedMissionTrackingMarks) do
|
|
local lastWorldPos = self.m_loadedMissionTrackingMarksPos[instId]
|
|
local currWorldPos = missionTrackingMarkObj.markRuntimeData.position
|
|
if (currWorldPos - lastWorldPos).sqrMagnitude > NEED_UPDATE_MISSION_MARK_POS_SQR_MAGNITUDE then
|
|
local rectPos = self:_GetRectPosByWorldPos(currWorldPos)
|
|
missionTrackingMarkObj:OverrideMarkRectPosition(rectPos)
|
|
end
|
|
self.m_loadedMissionTrackingMarksPos[instId] = currWorldPos
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshWaitVisibleInMistMarksState = HL.Method() << function(self)
|
|
if self.m_waitVisibleInMistMarks == nil or next(self.m_waitVisibleInMistMarks) == nil then
|
|
return
|
|
end
|
|
for markInstId, _ in pairs(self.m_waitVisibleInMistMarks) do
|
|
local success, markRuntimeData = self.m_mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if success then
|
|
self:_RefreshGridMark(markInstId, markRuntimeData, true)
|
|
end
|
|
end
|
|
self.m_waitVisibleInMistMarks = {}
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RefreshCustomMarkOrderActiveState = HL.Method(HL.Boolean) << function(self, state)
|
|
for order = 1, CUSTOM_MARK_ORDER - 1 do
|
|
self:SetMarkOrderState(order, state)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetMarkRootByOrder = HL.Method(HL.Number).Return(RectTransform) << function(self, order)
|
|
return self.view.element.markRoot[string.format(MARK_ORDER_VIEW_NAME_FORMAT, order)]
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._GetIsInTier = HL.Method().Return(HL.Boolean) << function(self)
|
|
return self.m_tierId ~= MapConst.BASE_TIER_ID and self.m_tierIndex ~= MapConst.BASE_TIER_INDEX
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetGridSpriteIdWithTier = HL.Method(HL.String).Return(HL.String, HL.Boolean) << function(self, gridId)
|
|
local gridData = self.m_loadedGridViewDataMap[gridId]
|
|
if gridData == nil then
|
|
return gridId, false
|
|
end
|
|
|
|
if not self:_GetIsInTier() then
|
|
return gridId, false
|
|
end
|
|
|
|
if not gridData.loaderData.needLoadTiers then
|
|
return gridId, false
|
|
end
|
|
|
|
local success, gridTierId = gridData.loaderData.tiers:TryGetValue(self.m_tierId)
|
|
if not success then
|
|
return gridId, false
|
|
else
|
|
return gridTierId, true
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetRectPosByWorldPos = HL.Method(HL.Any, HL.Opt(HL.Boolean)).Return(Vector2) << function(self, worldPos, ignoreInverse)
|
|
local rectPos = UILevelMapUtils.ConvertUILevelMapWorldPosToRectPos(worldPos, self.m_gridWorldLength, self.m_gridRectLength)
|
|
if not ignoreInverse then
|
|
local needInverse = self.m_mapManager:IsLevelNeedInverse(self.m_levelId)
|
|
if needInverse then
|
|
rectPos = Vector2(rectPos.y, -rectPos.x)
|
|
end
|
|
end
|
|
return rectPos
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderCache = HL.Method(HL.Table, LuaNodeCache) << function(self, nodeTable, cache)
|
|
if nodeTable == nil then
|
|
return
|
|
end
|
|
|
|
for _, node in pairs(nodeTable) do
|
|
cache:Cache(node)
|
|
end
|
|
|
|
nodeTable = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderGridCache = HL.Method() << function(self)
|
|
if self.m_loadedGridViewDataMap == nil then
|
|
return
|
|
end
|
|
|
|
for _, gridData in pairs(self.m_loadedGridViewDataMap) do
|
|
gridData.cell.image.sprite = nil
|
|
self.m_gridCache:Cache(gridData.cell)
|
|
end
|
|
|
|
self.m_loadedGridViewDataMap = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderMarkCache = HL.Method() << function(self)
|
|
for _, markViewData in pairs(self.m_loadedMarkViewDataMap) do
|
|
self:_CacheMark(markViewData, markViewData.markObj)
|
|
end
|
|
|
|
self.m_loadedMarkViewDataMap = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderStaticElementCache = HL.Method() << function(self)
|
|
for _, staticElementViewData in pairs(self.m_loadedStaticElementViewDataMap) do
|
|
local initializer = staticElementViewData.initializer
|
|
if initializer.componentGetter ~= nil then
|
|
local component = initializer.componentGetter(staticElementViewData.elementObj)
|
|
if component ~= nil then
|
|
component:ClearComponent()
|
|
end
|
|
end
|
|
initializer.cache:Cache(staticElementViewData.elementObj)
|
|
end
|
|
|
|
self.m_loadedStaticElementViewDataMap = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderGameplayAreaCache = HL.Method() << function(self)
|
|
if self.m_loadedGameplayAreas == nil then
|
|
return
|
|
end
|
|
|
|
for _, node in pairs(self.m_loadedGameplayAreas) do
|
|
node.levelMapGameplayArea:ClearComponent()
|
|
self.m_gameplayAreaCache:Cache(node)
|
|
end
|
|
|
|
self.m_loadedGameplayAreas = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderLinesCache = HL.Method() << function(self)
|
|
for _, lineViewData in pairs(self.m_loadedLineViewDataMap) do
|
|
local lineCache = self.m_lineCaches[lineViewData.lineData.lineType]
|
|
local lineObj = lineViewData.lineObj
|
|
if lineObj.levelMapLine ~= nil then
|
|
lineObj.levelMapLine:ClearComponent()
|
|
end
|
|
lineCache:Cache(lineObj)
|
|
end
|
|
|
|
self.m_loadedLineViewDataMap = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderCachesState = HL.Method() << function(self)
|
|
self:_ClearLoaderGridCache()
|
|
self:_ClearLoaderStaticElementCache()
|
|
self:_ClearLoaderMarkCache()
|
|
self:_ClearLoaderGameplayAreaCache()
|
|
self:_ClearLoaderLinesCache()
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetGridSpriteFolder = HL.Method(HL.String).Return(HL.String) << function(self, levelId)
|
|
if self.m_gridSpriteFolderCache[levelId] == nil then
|
|
self.m_gridSpriteFolderCache[levelId] = UILevelMapUtils.GetUILevelMapGridsFolderByLevelId(levelId, false)
|
|
end
|
|
return self.m_gridSpriteFolderCache[levelId]
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetGridSprite = HL.Method(HL.String, HL.Opt(HL.Function)).Return(HL.Opt(HL.Userdata)) << function(self, gridId, onComplete)
|
|
local spriteData = self.m_gridSpriteCache[gridId]
|
|
if spriteData == nil then
|
|
local gridData = self.m_loadedGridViewDataMap[gridId]
|
|
if gridData ~= nil then
|
|
local folder = self:_GetGridSpriteFolder(gridData.loaderData.levelId)
|
|
local gridSpriteId, isTierSprite = self:_GetGridSpriteIdWithTier(gridId)
|
|
spriteData = { gridId = gridId, isTierSprite = isTierSprite, gridSpriteId = gridSpriteId }
|
|
self.m_gridSpriteCache[gridId] = spriteData
|
|
if onComplete ~= nil then
|
|
local handlerKey = self.loader:LoadSpriteAsync(UIUtils.getSpritePath(folder, gridSpriteId), function(sprite)
|
|
|
|
spriteData.sprite = sprite
|
|
onComplete(sprite)
|
|
end)
|
|
spriteData.handlerKey = handlerKey
|
|
else
|
|
local sprite, key = self.loader:LoadSprite(UIUtils.getSpritePath(folder, gridSpriteId))
|
|
spriteData.handlerKey = key
|
|
spriteData.sprite = sprite
|
|
self.m_gridSpriteCache[gridId] = spriteData
|
|
return spriteData.sprite
|
|
end
|
|
end
|
|
else
|
|
local gridSpriteId, isTierSprite = self:_GetGridSpriteIdWithTier(gridId)
|
|
if spriteData.isTierSprite ~= isTierSprite or spriteData.gridSpriteId ~= gridSpriteId then
|
|
|
|
self:_DisposeGridSprite(spriteData, false)
|
|
local gridData = self.m_loadedGridViewDataMap[gridId]
|
|
local folder = self:_GetGridSpriteFolder(gridData.loaderData.levelId)
|
|
|
|
local sprite, key = self.loader:LoadSprite(UIUtils.getSpritePath(folder, gridSpriteId))
|
|
spriteData.isTierSprite = isTierSprite
|
|
spriteData.sprite = sprite
|
|
spriteData.handlerKey = key
|
|
spriteData.gridSpriteId = gridSpriteId
|
|
end
|
|
|
|
if spriteData.delayDisposeKey ~= nil then
|
|
self:_RemoveMapDelayAction(spriteData.delayDisposeKey)
|
|
end
|
|
|
|
if onComplete ~= nil then
|
|
onComplete(spriteData.sprite)
|
|
else
|
|
return spriteData.sprite
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._GetMistRefreshData = HL.Method(HL.Boolean).Return(HL.Table) << function(self, usedForAnim)
|
|
local data = usedForAnim and self.m_animMistRefreshData or self.m_gridMistRefreshData
|
|
if not next(data) then
|
|
|
|
data.usedForAnim = usedForAnim
|
|
data.loadedMists = {}
|
|
data.loadedMistGrids = {}
|
|
data.textureCache = {}
|
|
data.lowRatio = 0
|
|
data.waitLoadTextures = {}
|
|
data.waitInvokeRefreshFinishList = {}
|
|
data.transformData = {}
|
|
end
|
|
return usedForAnim and self.m_animMistRefreshData or self.m_gridMistRefreshData
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._AddDelayDisposeGridSprite = HL.Method(HL.Table) << function(self, spriteData)
|
|
if spriteData == nil then
|
|
return
|
|
end
|
|
local key = self:_AddMapDelayAction(
|
|
spriteData.gridId,
|
|
function()
|
|
if spriteData ~= nil then
|
|
self:_DisposeGridSprite(spriteData, true)
|
|
end
|
|
spriteData.delayDisposeKey = nil
|
|
end
|
|
)
|
|
spriteData.delayDisposeKey = key
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._DisposeGridSprite = HL.Method(HL.Table, HL.Boolean) << function(self, spriteData, needRemoveData)
|
|
if spriteData == nil then
|
|
return
|
|
end
|
|
|
|
spriteData.sprite = nil
|
|
self.loader:DisposeHandleByKey(spriteData.handlerKey)
|
|
spriteData.handlerKey = nil
|
|
if needRemoveData then
|
|
self.m_gridSpriteCache[spriteData.gridId] = nil
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._DisposeAllGridSprites = HL.Method() << function(self)
|
|
if self.m_gridSpriteCache == nil then
|
|
return
|
|
end
|
|
for _, spriteData in pairs(self.m_gridSpriteCache) do
|
|
self:_DisposeGridSprite(spriteData, false)
|
|
end
|
|
self.m_gridSpriteCache = {}
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._ClearLoaderGridMists = HL.Method() << function(self)
|
|
if self.m_gridMistRefreshData ~= nil and self.m_gridMistRefreshData.rt ~= nil then
|
|
RTManager.ReleaseRenderTexture(self.m_gridMistRefreshData.rt)
|
|
self.m_gridMistRefreshData.rt = nil
|
|
end
|
|
self.m_gridMistRefreshData = {}
|
|
self.view.element.mist.gameObject:SetActive(false)
|
|
|
|
if self.m_animMistRefreshData ~= nil and self.m_animMistRefreshData.rt ~= nil then
|
|
RTManager.ReleaseRenderTexture(self.m_animMistRefreshData.rt)
|
|
self.m_animMistRefreshData.rt = nil
|
|
end
|
|
self.m_animMistRefreshData = {}
|
|
self.view.element.animMist.gameObject:SetActive(false)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._AddMapDelayAction = HL.Method(HL.String, HL.Function).Return(HL.Any) << function(self, key, callback)
|
|
if self.m_delayActionList[key] ~= nil then
|
|
local action = self.m_delayActionList[key]
|
|
action.timer = self:_ClearTimer(action.timer)
|
|
action.timer = self:_StartTimer(ACTION_DELAY_TIME, function()
|
|
self:_InvokeMapDelayAction(key)
|
|
end)
|
|
return key
|
|
end
|
|
|
|
self.m_delayActionList[key] = {
|
|
timer = self:_StartTimer(ACTION_DELAY_TIME, function()
|
|
self:_InvokeMapDelayAction(key)
|
|
end),
|
|
callback = callback
|
|
}
|
|
return key
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._RemoveMapDelayAction = HL.Method(HL.String) << function(self, key)
|
|
local action = self.m_delayActionList[key]
|
|
if action == nil then
|
|
return
|
|
end
|
|
action.timer = self:_ClearTimer(action.timer)
|
|
self.m_delayActionList[key] = nil
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader._RemoveAllDelayActions = HL.Method() << function(self)
|
|
for _, action in pairs(self.m_delayActionList) do
|
|
action.timer = self:_ClearTimer(action.timer)
|
|
end
|
|
self.m_delayActionList = {}
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._InvokeMapDelayAction = HL.Method(HL.String) << function(self, key)
|
|
local action = self.m_delayActionList[key]
|
|
if action == nil then
|
|
return
|
|
end
|
|
action.callback()
|
|
self:_RemoveMapDelayAction(key)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._LoadPermanentStaticElement = HL.Method(HL.Userdata) << function(self, permanentElementData)
|
|
if permanentElementData == nil then
|
|
return
|
|
end
|
|
|
|
local staticElementData = permanentElementData.elementData
|
|
if staticElementData == nil or not self:_IsExpectedStaticElementType(staticElementData.type) then
|
|
return
|
|
end
|
|
|
|
local initializer = self.m_staticElementInitializer[staticElementData.type]
|
|
if initializer == nil then
|
|
return
|
|
end
|
|
|
|
if initializer.isVisible ~= nil and not initializer.isVisible(staticElementData) then
|
|
return
|
|
end
|
|
|
|
local staticElementId = staticElementData.id
|
|
local staticElement = initializer.cache:Get()
|
|
staticElement.gameObject:SetActive(true)
|
|
staticElement.rectTransform.anchoredPosition = permanentElementData.rectPos
|
|
initializer.initializer(staticElement, staticElementData)
|
|
self.m_loadedStaticElementViewDataMap[staticElementId] = {
|
|
elementObj = staticElement,
|
|
initializer = initializer,
|
|
}
|
|
self:_RefreshLoadedStaticElementStateWithTier(self.m_loadedStaticElementViewDataMap[staticElementId])
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._UnloadPermanentStaticElement = HL.Method(HL.String) << function(self, staticElementId)
|
|
local elementViewData = self.m_loadedStaticElementViewDataMap[staticElementId]
|
|
if elementViewData == nil then
|
|
return
|
|
end
|
|
|
|
GameObject.Destroy(elementViewData.elementObj.gameObject)
|
|
self.m_loadedStaticElementViewDataMap[staticElementId] = nil
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader._AddDelayLoadPermanentStaticElement = HL.Method(HL.Userdata) << function(self, staticElementData)
|
|
if staticElementData == nil then
|
|
return
|
|
end
|
|
|
|
local staticElementId = staticElementData.id
|
|
local loadDistance = staticElementData.loadDistance
|
|
self.m_tryLoadElementsList[staticElementId] = {
|
|
staticElementData = staticElementData,
|
|
loadDistance = loadDistance,
|
|
targetPosX = staticElementData.position.x,
|
|
targetPosY = staticElementData.position.z,
|
|
isLoaded = false,
|
|
}
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderWithMarkPosition = HL.Method(HL.String) << function(self, markInstId)
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if not success then
|
|
return
|
|
end
|
|
self.view.viewRect.anchoredPosition = self:_GetRectPosByWorldPos(markRuntimeData.position)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderWithLevelCenterPosition = HL.Method(HL.String, Vector2, HL.Opt(HL.Table)).Return(HL.Userdata) << function(
|
|
self, levelId, offset, tweenInfo)
|
|
local success, levelLoaderData = self.m_mapManager:GetLoaderLevelDataByLevelId(levelId)
|
|
if not success then
|
|
return nil
|
|
end
|
|
|
|
local center = (levelLoaderData.rectLeftBottom + levelLoaderData.rectRightTop) / 2.0 + offset
|
|
if tweenInfo then
|
|
self.m_posTween = self.view.viewRect:DOAnchorPos(center, tweenInfo.duration):SetEase(tweenInfo.ease):OnUpdate(function()
|
|
self.view.loader:DoLoaderHitCheck(true)
|
|
self:_RefreshGridsMask()
|
|
end)
|
|
return self.m_posTween
|
|
else
|
|
self.view.viewRect.anchoredPosition = center
|
|
return nil
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderViewSizeByGridsCount = HL.Method(HL.Number, HL.Number, HL.Opt(HL.Table)).Return(HL.Userdata) << function(
|
|
self, horizontalCount, verticalCount, tweenInfo)
|
|
local size = Vector2(
|
|
horizontalCount * self.m_gridRectLength,
|
|
verticalCount * self.m_gridRectLength
|
|
)
|
|
if tweenInfo ~= nil then
|
|
self.m_sizeTween = self.view.viewRect:DOSizeDelta(size, tweenInfo.duration):SetEase(tweenInfo.ease)
|
|
return self.m_sizeTween
|
|
else
|
|
self.view.viewRect.sizeDelta = size
|
|
return nil
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderDataUpdateInterval = HL.Method(HL.Number) << function(self, interval)
|
|
self.m_dataUpdateInterval = interval
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderElementsShownState = HL.Method(HL.Boolean) << function(self, isShown)
|
|
local element = self.view.element
|
|
element.staticElementBackRoot.gameObject:SetActive(isShown)
|
|
element.staticElementFrontRoot.gameObject:SetActive(isShown)
|
|
element.lineRoot.gameObject:SetActive(isShown)
|
|
element.markRoot.gameObject:SetActive(isShown)
|
|
element.trackingMarkRoot.gameObject:SetActive(isShown)
|
|
element.staticElementGridRoot.switchMask.gameObject:SetActive(isShown)
|
|
element.player.gameObject:SetActive(isShown)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetMarkOrderState = HL.Method(HL.Number, HL.Boolean) << function(self, orderNum, state)
|
|
self:_GetMarkRootByOrder(orderNum).gameObject:SetActive(state)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderLevel = HL.Method(HL.String) << function(self, levelId)
|
|
self.view.loader:ChangeLoaderLevel(levelId, true)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetGeneralTrackingMarkState = HL.Method(HL.String) << function(self, markInstId)
|
|
self:_GetGeneralTrackingMarkIfNeed()
|
|
local generalTrackingMarkObj = self.view.element.trackingMarkRoot.generalTrackingMark
|
|
generalTrackingMarkObj.gameObject:SetActive(false)
|
|
generalTrackingMarkObj:RefreshTrackingMarkState(false)
|
|
self.m_loadedGeneralTrackingMarkId = markInstId
|
|
self:_RefreshGeneralTrackingMarkIsInOtherLevel("")
|
|
|
|
if string.isEmpty(markInstId) then
|
|
return
|
|
end
|
|
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
if markRuntimeData.mapId ~= self.m_mapId then
|
|
return
|
|
end
|
|
|
|
if markRuntimeData.levelId ~= self.m_levelId and not self.m_needShowOtherLevelTracking then
|
|
return
|
|
end
|
|
|
|
generalTrackingMarkObj:InitLevelMapMark(self:_GetRectPosByWorldPos(markRuntimeData.position), markRuntimeData)
|
|
generalTrackingMarkObj:RefreshTrackingMarkState(true)
|
|
generalTrackingMarkObj.gameObject:SetActive(true)
|
|
|
|
self:_RefreshGeneralTrackingMarkLevelState()
|
|
self:_RefreshGeneralTrackingMarkWithTier()
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetMissionTrackingMarkState = HL.Method(HL.Table) << function(self, markInstIdList)
|
|
for _, missionTrackingMarkObj in pairs(self.m_loadedMissionTrackingMarks) do
|
|
missionTrackingMarkObj.gameObject:SetActive(false)
|
|
self:_CacheTrackingMark(missionTrackingMarkObj)
|
|
end
|
|
self.m_loadedMissionTrackingMarks = {}
|
|
self.m_loadedMissionTrackingMarksPos = {}
|
|
|
|
for _, missionTrackingArea in pairs(self.m_loadedMissionTrackingAreas) do
|
|
missionTrackingArea.levelMapMissionArea:ClearComponent()
|
|
missionTrackingArea.gameObject:SetActive(false)
|
|
self.m_missionTrackingAreaCache:Cache(missionTrackingArea)
|
|
end
|
|
self.m_loadedMissionTrackingAreas = {}
|
|
|
|
if markInstIdList == nil then
|
|
return
|
|
end
|
|
|
|
for _, markInstId in pairs(markInstIdList) do
|
|
local success, markRuntimeData = GameInstance.player.mapManager:GetMarkInstRuntimeData(markInstId)
|
|
if success and markRuntimeData.mapId == self.m_mapId and (markRuntimeData.levelId == self.m_levelId or self.m_needShowOtherLevelTracking) then
|
|
|
|
local missionTrackingMarkObj = self:_GetTrackingMarkFromCache(true)
|
|
local rectPos = self:_GetRectPosByWorldPos(markRuntimeData.position)
|
|
missionTrackingMarkObj:InitLevelMapMark(rectPos, markRuntimeData)
|
|
missionTrackingMarkObj:RefreshTrackingMarkState(true)
|
|
self.m_loadedMissionTrackingMarks[markInstId] = missionTrackingMarkObj
|
|
self.m_loadedMissionTrackingMarksPos[markInstId] = markRuntimeData.position
|
|
|
|
|
|
if markRuntimeData.trackData ~= nil and markRuntimeData.trackData.guidingArea > 0 then
|
|
local missionTrackingArea = self.m_missionTrackingAreaCache:Get()
|
|
missionTrackingArea.rectTransform.anchoredPosition = rectPos
|
|
missionTrackingArea.gameObject:SetActive(true)
|
|
missionTrackingArea.levelMapMissionArea:Init(markRuntimeData, missionTrackingMarkObj.gameObject)
|
|
self.m_loadedMissionTrackingAreas[markInstId] = missionTrackingArea
|
|
|
|
if missionTrackingArea.levelMapMissionArea.needUseCenterPosition then
|
|
local centerPos = self:_GetRectPosByWorldPos(markRuntimeData.trackData.guidingAreaCenter)
|
|
missionTrackingArea.rectTransform.anchoredPosition = centerPos
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
self:_RefreshMissionTrackingMarksLevelState()
|
|
self:_RefreshMissionTrackingMarksWithTier()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderLineVisibleStateByType = HL.Method(HL.Userdata, HL.Boolean) << function(self, lineType, isVisible)
|
|
local root = self.m_lineRoots[lineType]
|
|
if root == nil then
|
|
return
|
|
end
|
|
root.gameObject:SetActive(isVisible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderLineVisibleState = HL.Method(HL.Boolean) << function(self, isVisible)
|
|
for _, root in pairs(self.m_lineRoots) do
|
|
root.gameObject:SetActive(isVisible)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderPlayerVisibleState = HL.Method(HL.Boolean) << function(self, isVisible)
|
|
self.view.element.player.gameObject:SetActive(isVisible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetLoaderTierId = HL.Method(HL.Number) << function(self, tierId)
|
|
self.m_tierId = tierId
|
|
self.m_tierIndex = self.m_regionManager:GetTierIndex(tierId)
|
|
self:_RefreshLoadedMarksWithTier()
|
|
self:_RefreshLoadedStaticElementsStateWithTier()
|
|
self:_RefreshLoadedGridsSpriteWithTier()
|
|
self:_RefreshLoadedGridsColorWithTier()
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.SetNeedOptimizePerformance = HL.Method(HL.Boolean) << function(self, active)
|
|
self.m_needOptimizePerformance = active
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleLoaderNeedShowMarkTier = HL.Method(HL.Boolean) << function(self, needShowTier)
|
|
self.m_needShowMarkTier = needShowTier
|
|
self:_RefreshLoadedMarksWithTier()
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleLoaderGeneralTrackingVisibleState = HL.Method(HL.Boolean) << function(self, visible)
|
|
self.view.element.trackingMarkRoot.general.gameObject:SetActive(visible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleLoaderMissionTrackingVisibleState = HL.Method(HL.Boolean) << function(self, visible)
|
|
self.view.element.trackingMarkRoot.mission.gameObject:SetActive(visible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleLoaderSwitchMaskVisibleState = HL.Method(HL.Boolean) << function(self, visible)
|
|
self.view.element.staticElementGridRoot.switchMask.gameObject:SetActive(visible)
|
|
self.view.element.staticElementBackRoot.switchButton.gameObject:SetActive(visible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleLoaderLineRootVisibleState = HL.Method(HL.Boolean) << function(self, visible)
|
|
self.view.element.lineRoot.gameObject:SetActive(visible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetLoaderViewRectWidthAndHeight = HL.Method(HL.Boolean).Return(HL.Number, HL.Number) << function(self, getTarget)
|
|
if getTarget and self.m_sizeTween ~= nil and self.m_sizeTween:IsPlaying() then
|
|
local size = self.m_sizeTween.endValue
|
|
return size.x, size.y
|
|
else
|
|
local rect = self.view.viewRect.rect
|
|
return rect.width, rect.height
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetWorldPositionByRectPosition = HL.Method(Vector2).Return(Vector3) << function(self, rectPos)
|
|
return UILevelMapUtils.ConvertUILevelMapRectPosToWorldPos(rectPos, self.m_gridWorldLength, self.m_gridRectLength)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetMarkRectTransformByInstId = HL.Method(HL.String).Return(Unity.RectTransform) << function(self, instId)
|
|
local markViewData = self.m_loadedMarkViewDataMap[instId]
|
|
if markViewData == nil or markViewData.mark == nil then
|
|
return nil
|
|
end
|
|
return markViewData.mark.rectTransform
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetMarkOrderRoot = HL.Method(HL.Number).Return(RectTransform) << function(self, order)
|
|
return self:_GetMarkRootByOrder(order)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.GetLoadedMarkViewDataMap = HL.Method().Return(HL.Table) << function(self)
|
|
return self.m_loadedMarkViewDataMap
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetLoadedMarkViewDataByInstId = HL.Method(HL.String).Return(HL.Table) << function(self, instId)
|
|
if not self.m_loadedMarkViewDataMap or not next(self.m_loadedMarkViewDataMap) then
|
|
return
|
|
end
|
|
return self.m_loadedMarkViewDataMap[instId]
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.GetLoadedMarkByInstId = HL.Method(HL.String).Return(HL.Any) << function(self, instId)
|
|
local markViewData = self.m_loadedMarkViewDataMap[instId]
|
|
if markViewData == nil or markViewData.markObj == nil then
|
|
return nil
|
|
end
|
|
return markViewData.markObj
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.GetGeneralTrackingMark = HL.Method().Return(HL.Any) << function(self)
|
|
|
|
return self.view.element.trackingMarkRoot.generalTrackingMark
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.GetMissionTrackingMarks = HL.Method().Return(HL.Any) << function(self)
|
|
local marks = {}
|
|
for instId, loadedMark in pairs(self.m_loadedMissionTrackingMarks) do
|
|
|
|
marks[instId] = loadedMark
|
|
end
|
|
return marks
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.UpdateAndRefreshAll = HL.Method() << function(self)
|
|
self.view.loader:DoLoaderHitCheck(true)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshMarkStateAfterMistUnlocked = HL.Method() << function(self)
|
|
self:_RefreshWaitVisibleInMistMarksState()
|
|
|
|
if self.m_onMarkInstDataChangedCallback ~= nil then
|
|
|
|
self.m_onMarkInstDataChangedCallback()
|
|
end
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshCharacterPosition = HL.Method() << function(self)
|
|
local playerNode = self.view.element.player
|
|
playerNode.rectTransform.anchoredPosition = self.m_mapManager.characterRectPosition
|
|
playerNode.playerArrow.localEulerAngles = Vector3(0.0, 0.0, -self.m_mapManager.characterForwardAngle)
|
|
playerNode.playerView.localEulerAngles = Vector3(0.0, 0.0, -self.m_mapManager.characterViewForwardAngle)
|
|
end
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshElementsHiddenStateInOtherLevel = HL.Method() << function(self)
|
|
for loaderData in cs_pairs(self.view.loader.hitGrids) do
|
|
local staticElements = loaderData.staticElements
|
|
local marks = loaderData.marks
|
|
local lines = loaderData.lines
|
|
local gridInCurrOtherLevel = loaderData.levelId == self.m_levelId
|
|
|
|
if staticElements ~= nil and staticElements.Count > 0 then
|
|
for staticElementId, _ in pairs(staticElements) do
|
|
local elementViewData = self.m_loadedStaticElementViewDataMap[staticElementId]
|
|
if elementViewData ~= nil then
|
|
self:_RefreshStaticElementVisibleState(elementViewData, "LoaderOtherLevelHide", gridInCurrOtherLevel)
|
|
end
|
|
end
|
|
end
|
|
|
|
if marks ~= nil and marks.Count > 0 then
|
|
for markInstId, _ in pairs(marks) do
|
|
local markViewData = self.m_loadedMarkViewDataMap[markInstId]
|
|
if markViewData ~= nil then
|
|
local markObj = markViewData.markObj
|
|
local needHide = not gridInCurrOtherLevel
|
|
local markRuntimeData = markViewData.runtimeData
|
|
if markRuntimeData.connectFromNodeIdList ~= nil then
|
|
if needHide then
|
|
local otherLevelConnectRefreshFunc = function(connectNodeIdList)
|
|
for connectNodeId in cs_pairs(connectNodeIdList) do
|
|
local _, connectMarkInstId = self.m_mapManager:GetFacMarkInstIdByNodeId(
|
|
markRuntimeData.chapterId,
|
|
connectNodeId
|
|
)
|
|
local connectMarkViewData = self.m_loadedMarkViewDataMap[connectMarkInstId]
|
|
if connectMarkViewData ~= nil then
|
|
local inCurrentLevel = markRuntimeData.levelId == self.m_levelId or
|
|
connectMarkViewData.runtimeData.levelId == self.m_levelId
|
|
if inCurrentLevel then
|
|
needHide = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if markRuntimeData.connectFromNodeIdList.Count > 0 then
|
|
otherLevelConnectRefreshFunc(markRuntimeData.connectFromNodeIdList)
|
|
end
|
|
if markRuntimeData.connectToNodeIdList.Count > 0 then
|
|
otherLevelConnectRefreshFunc(markRuntimeData.connectToNodeIdList)
|
|
end
|
|
end
|
|
end
|
|
|
|
markObj:ToggleMarkHiddenState("LoaderOtherLevelHide", needHide)
|
|
end
|
|
end
|
|
end
|
|
|
|
for lineId, _ in pairs(lines) do
|
|
local lineViewData = self.m_loadedLineViewDataMap[lineId]
|
|
if lineViewData ~= nil then
|
|
local needHide = not gridInCurrOtherLevel
|
|
if needHide then
|
|
local lineData = lineViewData.lineData
|
|
if lineData.startBelongGrid.gridId ~= lineData.endBelongGrid.gridId then
|
|
needHide = lineData.startBelongGrid.levelId ~= self.m_levelId and lineData.endBelongGrid.levelId ~= self.m_levelId
|
|
end
|
|
end
|
|
lineViewData.lineObj.gameObject:SetActive(not needHide)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshLevelSwitchMaskState = HL.Method(HL.String) << function(self, levelId)
|
|
local success, cfg = self.m_levelMapConfig.levelConfigInfos:TryGetValue(levelId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
if self.m_switchMaskCells == nil then
|
|
self.m_switchMaskCells = UIUtils.genCellCache(self.view.element.staticElementGridRoot.switchMask.maskCell)
|
|
end
|
|
|
|
local maskDataList = {}
|
|
for _, staticElementData in pairs(cfg.staticElements) do
|
|
if staticElementData.type == ElementType.SwitchMask then
|
|
table.insert(maskDataList, {
|
|
position = staticElementData.position,
|
|
targetLevelId = staticElementData.targetLevelId,
|
|
targetLevelSpriteName = staticElementData.targetLevelSpriteName,
|
|
isUnlocked = GameInstance.player.mapManager:IsLevelUnlocked(staticElementData.targetLevelId)
|
|
})
|
|
end
|
|
end
|
|
if #maskDataList == nil then
|
|
return
|
|
end
|
|
|
|
self.m_switchMaskCells:Refresh(#maskDataList, function(cell, index)
|
|
local maskData = maskDataList[index]
|
|
|
|
cell.button.onClick:RemoveAllListeners()
|
|
cell.button.onClick:AddListener(function()
|
|
if maskData.isUnlocked then
|
|
Notify(MessageConst.ON_LEVEL_MAP_SWITCH_BTN_CLICKED, maskData.targetLevelId);
|
|
else
|
|
Notify(MessageConst.SHOW_TOAST, Language.LUA_OPEN_MAP_LEVEL_LOCKED)
|
|
end
|
|
end)
|
|
|
|
cell.image:LoadSprite(MapConst.UI_MAP_SWITCH_MASK_PATH, maskData.targetLevelSpriteName)
|
|
cell.image:SetNativeSize()
|
|
cell.image.alphaHitTestMinimumThreshold = 0.01
|
|
cell.image.color = maskData.isUnlocked and Color.white or self.view.config.LOCKED_SWITCH_MASK_COLOR
|
|
|
|
cell.rectTransform.anchoredPosition = self:_GetRectPosByWorldPos(maskData.position)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleForbidMistRefreshAfterGridChange = HL.Method(HL.Boolean) << function(self, forbid)
|
|
self.m_forbidMistRefreshAfterGridChange = forbid
|
|
if forbid then
|
|
self:_StopWaitingFinishRefreshMist()
|
|
else
|
|
if self.m_waitMistRefreshAfterGridChange then
|
|
self:_RefreshGridMists(false)
|
|
end
|
|
end
|
|
self.m_waitMistRefreshAfterGridChange = false
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshMistState = HL.Method(HL.Opt(HL.Function)) << function(self, onRefreshFinish)
|
|
self:_RefreshGridMists(false, nil, function()
|
|
if onRefreshFinish ~= nil then
|
|
onRefreshFinish()
|
|
end
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.RefreshAnimationMistState = HL.Method(HL.Table, HL.Opt(HL.Function)) << function(self, mistList, onRefreshFinish)
|
|
self:_RefreshGridMists(true, mistList, onRefreshFinish)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ToggleAnimationMistNodeVisibleState = HL.Method(HL.Boolean) << function(self, isVisible)
|
|
self.view.element.animMist.gameObject:SetActive(isVisible)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.PlayMistsUnlockedAnimation = HL.Method(HL.Opt(HL.Function)) << function(self, onComplete)
|
|
local animMist = self.view.element.animMist
|
|
|
|
local recoverAnimState = function(onRecoverFinish)
|
|
animMist.animationWrapper:PlayWithTween("levelmaploader_mist_unlock_in", function()
|
|
if onRecoverFinish ~= nil then
|
|
onRecoverFinish()
|
|
end
|
|
end)
|
|
animMist.materialAnimation:ForceUpdate()
|
|
end
|
|
|
|
recoverAnimState(function()
|
|
self.m_animMistShowTimer = self:_ClearTimer(self.m_animMistShowTimer)
|
|
self.m_animMistShowTimer = self:_StartTimer(self.view.config.ANIM_MIST_SHOW_DURATION, function()
|
|
animMist.animationWrapper:PlayWithTween("levelmaploader_mist_unlock_out", function()
|
|
self:_ClearMistRenderTexture(true)
|
|
recoverAnimState()
|
|
if onComplete ~= nil then
|
|
onComplete()
|
|
end
|
|
end)
|
|
self.m_animMistShowTimer = self:_ClearTimer(self.m_animMistShowTimer)
|
|
end)
|
|
end)
|
|
end
|
|
|
|
|
|
|
|
|
|
LevelMapLoader.ResetToTargetMapAndLevel = HL.Method(HL.String) << function(self, levelId)
|
|
local success, levelConfig = DataManager.levelConfigTable:TryGetData(levelId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
self.m_mapId = levelConfig.mapIdStr
|
|
self.m_levelId = levelId
|
|
self:_RemoveAllDelayActions()
|
|
self:_ClearLoaderCachesState()
|
|
self:_DisposeAllGridSprites()
|
|
self:_ClearLoaderGridMists()
|
|
self:_InitTableFields(true)
|
|
|
|
|
|
self.view.loader:ClearLoaderCheckState()
|
|
self.view.loader:ChangeLoaderCheckLevels(self.m_levelId)
|
|
self.view.loader:ChangeLoaderLevel(self.m_levelId)
|
|
|
|
self:_InitPermanentElementsInCurrentMap()
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if BEYOND_DEBUG_COMMAND then
|
|
|
|
|
|
|
|
LevelMapLoader._InitDebugMode = HL.Method(HL.String) << function(self, levelId)
|
|
local success, levelConfig = DataManager.levelConfigTable:TryGetData(levelId)
|
|
if not success then
|
|
return
|
|
end
|
|
|
|
local worldLeftBottom = levelConfig.rectLeftBottom
|
|
local worldRightTop = levelConfig.rectRightTop
|
|
local rectLeftBottom = self:_GetRectPosByWorldPos(Vector3(worldLeftBottom.x, 0, worldLeftBottom.y), true)
|
|
local rectRightTop = self:_GetRectPosByWorldPos(Vector3(worldRightTop.x, 0, worldRightTop.y), true)
|
|
local horizontalCount = (rectRightTop.x - rectLeftBottom.x) / self.m_gridRectLength
|
|
local verticalCount = (rectRightTop.y - rectLeftBottom.y) / self.m_gridRectLength
|
|
|
|
self.m_gridCache = LuaNodeCache(self.view.source.grid, self.view.element.loadedGrids)
|
|
for i = 0, horizontalCount - 1 do
|
|
for j = 0, verticalCount - 1 do
|
|
local gridCell = self.m_gridCache:Get()
|
|
local gridRectPosX = rectLeftBottom.x + (i + 0.5) * self.m_gridRectLength
|
|
local gridRectPosY = rectLeftBottom.y + (j + 0.5) * self.m_gridRectLength
|
|
gridCell.rectTransform.anchoredPosition = Vector2(gridRectPosX, gridRectPosY)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
HL.Commit(LevelMapLoader)
|
|
return LevelMapLoader |