local EventSystem = require 'Event/EventSystem'
local BattleEffect = require("Battle/Logic/BattleEffect/BattleEffect")
local LevelFunction = require("Battle/Logic/Level/LevelFunction/LevelFunction")
local BossChallengeLevelFunction = require("Battle/Logic/Level/LevelFunction/BossChallengeLevelFunction")
local SyncLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncLevelFunction")
local SyncTeamPVPLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncTeamPVPLevelFunction")
local SyncFourForceLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncFourForceLevelFunction")
local SyncWorldBossLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncWorldBossLevelFunction")
local SyncWarZoneWorldBossLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncWarZoneWorldBossLevelFunction")
local SyncTownLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncTownLevelFunction")
local SceneQuizTownLevelFunction = require("Battle/Logic/Level/LevelFunction/SceneQuizTownLevelFunction")
local SoloFightLevelFunction = require("Battle/Logic/Level/LevelFunction/SoloFightLevelFunction") -- 1组3v3演武
local NineVsNineLevelFunction = require("Battle/Logic/Level/LevelFunction/NineVsNineLevelFunction") -- 3组3v3演武
local ClimbTowerLevelFunction = require("Battle/Logic/Level/LevelFunction/ClimbTowerLevelFunction")
local NationClimbTowerLevelFunction = require("Battle/Logic/Level/LevelFunction/NationClimbTowerLevelFunction")
local SlgGvELevelFunction = require("Battle/Logic/Level/LevelFunction/SlgGvELevelFunction")
local SyncTeamPVELevelFunction = require("Battle/Logic/Level/LevelFunction/SyncTeamPVELevelFunction")
local SyncTeamDifficultLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncTeamDifficultLevelFunction")
local ResourceLevelFunction = require("Battle/Logic/Level/LevelFunction/ResourceLevelFunction")
local SyncGuildBossLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncGuildBossLevelFunction")
local GuildBossTownLevelFunction = require("Battle/Logic/Level/LevelFunction/GuildBossTownLevelFunction")
local SyncGuildWarMapResourcesLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncGuildWarMapResourcesLevelFunction")
local SyncGuildWarMapSideLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncGuildWarMapSideLevelFunction")
local SyncGuildWarMapMiddleLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncGuildWarMapMiddleLevelFunction")
local SyncTestLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncTestLevelFunction")
local SyncSoloLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncSoloLevelFunction")
local SyncUnfairSoloLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncUnfairSoloLevelFunction")
local GoldHeroBaseLevelFunction = require("Battle/Logic/Level/LevelFunction/GoldHeroBaseLevelFunction")
local GoldHeroCooperateLevelFunction = require("Battle/Logic/Level/LevelFunction/GoldHeroCooperateLevelFunction")
local FightThroneTownLevelFunction = require("Battle/Logic/Level/LevelFunction/FightThroneTownLevelFunction")
local FightThroneFirstFloorLevelFunction = require("Battle/Logic/Level/LevelFunction/FightThroneFirstFloorLevelFunction")
local FightThroneSecondFloorLevelFunction = require("Battle/Logic/Level/LevelFunction/FightThroneSecondFloorLevelFunction")
local FightThroneThirdFloorLevelFunction = require("Battle/Logic/Level/LevelFunction/FightThroneThirdFloorLevelFunction")

local FormulaCalculator = require("Battle/Logic/Missile/FormulaCalculator")
local SyncDigTreasureLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncDigTreasureLevelFunction")
local DigTreasureLevelFunction = require("Battle/Logic/Level/LevelFunction/DigTreasureLevelFunction")
local SyncEscortLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncEscortLevelFunction")
local DemonGodLevelFunction = require("Battle/Logic/Level/LevelFunction/DemonGodLevelFunction")
local GoldHeroTrialLevelFunction = require"Battle/Logic/Level/LevelFunction/GoldHeroTrialLevelFunction"
local SyncCountryPVPLevelFunction = require"Battle/Logic/Level/LevelFunction/SyncCountryPVPLevelFunction"
local SyncDragonArteryLevelFunction = require"Battle/Logic/Level/LevelFunction/SyncDragonArteryLevelFunction"
local DragonArteryWaitingAreaLevelFunction = require"Battle/Logic/Level/LevelFunction/DragonArteryWaitingAreaLevelFunction"
local SyncCountryEveningBossLevelFunction = require"Battle/Logic/Level/LevelFunction/SyncCountryEveningBossLevelFunction"
local SyncFairSoloTournamentLevelFunction = require"Battle/Logic/Level/LevelFunction/SyncFairSoloTournamentLevelFunction"
local AttackCityLevelFunction = require"Battle/Logic/Level/LevelFunction/AttackCityLevelFunction"
local SyncUnfairTeamPVPLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncUnfairTeamPVPLevelFunction")
local StormChallengeLevelFunction = require("Battle/Logic/Level/LevelFunction/StormChallengeLevelFunction")
local SyncFourCountryChaosLevelFunction = require"Battle/Logic/Level/LevelFunction/SyncFourCountryChaosLevelFunction"
local SyncCityWarMainFirstStageLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncCityWarMainFirstStageLevelFunction")
local SyncCityWarMainSecondStageLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncCityWarMainSecondStageLevelFunction")
local SyncCityWarSideLevelFunction = require("Battle/Logic/Level/LevelFunction/SyncCityWarSideLevelFunction")
local ExpelMonsterLevelFunction = require("Battle/Logic/Level/LevelFunction/ExpelMonsterLevelFunction")
local RogueLikeLevelFunction = require("Battle/Logic/Level/LevelFunction/RogueLikeLevelFunction")
local HeroAwakePlayerLevelFunction = require("Battle/Logic/Level/LevelFunction/HeroAwakePlayerLevelFunction")
local HeroAwakeBossLevelFunction = require("Battle/Logic/Level/LevelFunction/HeroAwakeBossLevelFunction")
--[[
    DummyLevel:切换到一个虚拟关卡，该关卡被设计为没有角色，没有Layout数据，只用于承载一些实现在指定scene的表现功能
    使用原因：考虑到直接loadScene会导致一些问题，同时为保证一致性。对一些需要切换scene的需求，可以通过切换DummyLevel处理，同时也可以根据需求扩展其他功能
    使用场景：1、播放一个Timeline，需要加载对应的scene ...
]]--
-- 虚拟关卡LevelFunction
local DummyLevelFunction = require("Battle/Logic/Level/LevelFunction/DummyLevelFunction")
-- 虚拟关卡的默认LevelInfoData数据
local DummyLevelData =
{
    LevelID = 0,
    SceneMapID = 0,
    LevelType = -1,
    ScenePath = nil
}

local Infrast = require("Infrast/Infrast")
--local BattleEventSystem = require"Battle/Logic/Event/BattleEventSystem"
local LuaConst=LuaConst

local LevelManager =  { isPlayingTimeline = false}

--只能放不会引发不一致的非战斗数据，不需要由战斗清理
local persistPrivate = {
    levelFuncHandle = {},
    levelFuncNormal = nil,
    recordFrameCmdArray = {}, -- 单机玩法记录的校验的帧数据
    switchLevelIdQueue = {},
    levelSwitchContext = nil, -- 换成切换关卡时使用的上下文
    loadUpdateAgent = nil, -- loading时的更新代理
    IsReplayBattle = false, -- 回放战斗中
    CurInfoData = nil,
    CurCombineLevelData = nil,
    autoPassCutscene = false,   --这个值因为只影响timeline(纯视图层)，并且只会在改变设置或登录的时候被设值，所以必须是持久化的缓存，所以只能放在persistPrivate里
    persistSummaryTime = false,
    summaryTime = FP.newV1(0),
}


--↓↓↓↓↓↓↓↓↓↓↓private数据↓↓↓↓↓↓↓↓↓↓
--会引发不一致的private数据，需要恰当地清理
local private = {}

--标记了private里能够合法存放的值
local privateLegalValueDic = {
    levelPause = true,
    timerList = true,
    cutsceneAutoPassTime = true,
    needCheckNotSyncLevel = true,
    IsInLevelWatchBattle = true,
    IsReplayRecordInSwitchLevel = true,
    clientIntermediateParamsBytes = true,
    switchHeroCd = true,
    PlayerIsOnHorse = true,
    --来自服务器的数据
    serverGs = true,
    severBossHp = true,
    serverMaxBossHp = true,
    BattleAnchorPos = true,
    attrInfos = true,
    subjugateDataPVEID = true,
    serverSaveRecordBytes = true,
    bossLevel = true,
    climbTowerId = true,
    gsGroupId = true,
    hasNextLevel = true,
    MatchStage = true,
    ServerLevel = true,
    battleStatueInfoList = true,
    preBattleResults = true,
    battleTime = true,
    monsterHpInfos = true,
    newBattleInfoIntParam = true,
    battleEndTime = true,  
    slgData = true,
    switchInGMSDic = true,
    openServerDays = true,
}

local privateMetatable = {}
privateMetatable.__newindex = function(self, key, val)
    rawset(self, key, val)
    if type(val) ~= "function" and (not privateLegalValueDic[key]) then
        logging.error(LTAG.ERROR, "HYW : 严重警告！ 禁止对 LevelManager 的 private 随意增加字段，如果需要增加，请按照标准流程增加并做好清理避免缓存污染！字段名 : ", key, " 值 : ", val)
    end
end
setmetatable(private, privateMetatable)

local CLEARED_FLAG = {}
--清理private缓存数据
private.ClearPrivateValue = function()
    for k,v in pairs(privateLegalValueDic) do --pairs safe，纯数据操作
        private[k] = CLEARED_FLAG
    end
end

--重新初始化private缓存数
private.InitPrivateValue = function()
    private.levelPause = false
    private.timerList = {}
    private.cutsceneAutoPassTime = -1 --此需求不考虑同步玩法，先做成number类型
    private.needCheckNotSyncLevel = false --  需要校验的离线副本
    private.IsInLevelWatchBattle = false -- 在关卡观战中
    private.IsReplayRecordInSwitchLevel = false --切换关卡记录的回放
    private.clientIntermediateParamsBytes = nil --关卡间传递的参数(bytes格式)
    private.switchHeroCd = nil
    private.PlayerIsOnHorse = nil

    --来自服务器的数据，默认值全部为nil
    private.serverGs = nil
    private.severBossHp = nil
    private.serverMaxBossHp = nil
    private.BattleAnchorPos = nil
    private.attrInfos = nil
    private.subjugateDataPVEID = nil
    private.serverSaveRecordBytes = nil
    private.bossLevel = nil
    private.climbTowerId = nil
    private.gsGroupId = nil
    private.hasNextLevel = nil
    private.MatchStage = nil
    private.ServerLevel = nil
    private.preBattleResults = nil
    private.battleStatueInfoList = nil
    private.battleTime = nil
    private.monsterHpInfos = nil
    private.newBattleInfoIntParam = nil
    private.battleEndTime = nil
    private.slgData = nil
    private.switchInGMSDic = nil
    private.openServerDays = nil
end


private.InitPrivateValue()
--#region ↑↑↑↑↑↑↑↑↑↑↑↑private数据↑↑↑↑↑↑↑↑↑↑↑↑

--服务器发过来的唯一id，带有分线信息，规则为 "sceneID:line"
LevelManager.CurUniqueSceneID = 0
LevelManager.InGuideLevel = false


local enter_scene_pb = require("Proto/enter_scene_pb")
LevelManager.ScenePlayerStateEnum = {
    Common = enter_scene_pb.CommonState,
    Watch = enter_scene_pb.WatchState,
}

--S2CRoleEnterScene服务器传过来的玩家状态
--目前是在一站到底玩法内标识进来场景的玩家是参赛者还是观战者，可以通过枚举扩展
LevelManager.ScenePlayerState = LevelManager.ScenePlayerStateEnum.Common

persistPrivate.CurInfoData = nil
persistPrivate.CurCombineLevelData = nil

--返回的是LevelInfoData表的数据
function LevelManager.GetCurInfoData()
    return persistPrivate.CurInfoData
end

function LevelManager.Init()
    LevelManager._levelLogicData = {
        SceneLoaded = false,
        LogicLoadingStep = LuaConst.Enum_LoadingStep.None
    }

    persistPrivate.levelFuncNormal = LevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.BossChallenge] = BossChallengeLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SubjectMonthBossChallenge] = BossChallengeLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SoloFight] = SoloFightLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.NineVsNineFight] = NineVsNineLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncPVP] = SyncLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamBoss] = SyncLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamPVP] = SyncTeamPVPLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamPVPPractice] = SyncTeamPVPLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamFairChampionship] = SyncTeamPVPLevelFunction    
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncWorldBoss] = SyncWorldBossLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.TOWN] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SatelliteTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncFourForce] = SyncFourForceLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.ClimbTower] = ClimbTowerLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.NationClimbTower] = NationClimbTowerLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SlgGvE] = SlgGvELevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamPVE] = SyncTeamPVELevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.Resource] = ResourceLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncGuildBoss] = SyncGuildBossLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GuildBossTown] = GuildBossTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossHeroMatchTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossHeroMatchTown3V3] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossFairSoloTournamentTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.TeamFairChampionshipTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SingleFairSoloTournamentTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GuildWarWaitingArea] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncGuildWarMapResources] = SyncGuildWarMapResourcesLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncGuildWarMapLeft] = SyncGuildWarMapSideLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncGuildWarMapRight] = SyncGuildWarMapSideLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncGuildWarMapMiddle] = SyncGuildWarMapMiddleLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncRebelStrike] = SyncTeamPVELevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GuildPartyMap] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SceneQuizTown] = SceneQuizTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SingleSceneQuizTown] = SceneQuizTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTestLevel] = SyncTestLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncTeamDifficultLevel] = SyncTeamDifficultLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncSolo] = SyncSoloLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncSoloPractice] = SyncSoloLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncUnfairSolo] = SyncUnfairSoloLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.DigNormal] = DigTreasureLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncDigTeamPVE] = SyncDigTreasureLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.AdvancedDigNormal] = DigTreasureLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GoldHeroExperience] = GoldHeroBaseLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GoldHeroCooperate] = GoldHeroCooperateLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.DemonGod] = DemonGodLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.GoldHeroTrail] = GoldHeroTrialLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossEscortTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SingleEscortTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncPlanesEscort] = SyncEscortLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossServerTown] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.FightThroneTown] = FightThroneTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.CrossFightThroneTown] = FightThroneTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.FightThroneFirstFloor] = FightThroneFirstFloorLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.FightThroneSecondFloor] = FightThroneSecondFloorLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.FightThroneThirdFloor] = FightThroneThirdFloorLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncUnfairTeamPVP] = SyncUnfairTeamPVPLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncWarZoneWorldBoss] = SyncWarZoneWorldBossLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCountryPVP] = SyncCountryPVPLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncWantedPVE] = SyncTeamPVELevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.DragonArtery] = SyncDragonArteryLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.DragonArteryWaitingArea] = DragonArteryWaitingAreaLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.DragonArteryRegistArea] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncFairSoloTournament] = SyncFairSoloTournamentLevelFunction    
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCountryEveningBoss] = SyncCountryEveningBossLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.AttackCity] = AttackCityLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.StormChallenge] = StormChallengeLevelFunction
	persistPrivate.levelFuncHandle[LuaConst.LevelType.LootMine] = AttackCityLevelFunction
	persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncFourCountryChaos] = SyncFourCountryChaosLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCityWarMainFirstStage] = SyncCityWarMainFirstStageLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCityWarMainSecondStage] = SyncCityWarMainSecondStageLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCityWarSide] = SyncCityWarSideLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCityWarMainWaitingArea] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.SyncCityWarSideWaitingArea] = SyncTownLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.ExpelMonster] = ExpelMonsterLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.RogueLike] = RogueLikeLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.HeroAwakePlayer] = HeroAwakePlayerLevelFunction
    persistPrivate.levelFuncHandle[LuaConst.LevelType.HeroAwakeBoss] = HeroAwakeBossLevelFunction
    BattleEventSystem.Init()
end
--region ******************* Update *******************

function LevelManager.OnUpdateLoading()
    if persistPrivate.loadUpdateAgent then
        persistPrivate.loadUpdateAgent()
    end
end

function private.OnUpdateLoading()
    local logicData = LevelManager._levelLogicData
    local LoadingStep = LuaConst.Enum_LoadingStep
    local isServer = logicData.IsServer
    if logicData.LogicLoadingStep == LoadingStep.WaitSceneLoadingOk then
        if isServer or logicData.SceneLoaded then
            logicData.LogicLoadingStep = LoadingStep.InitLevelMap
        end
    elseif logicData.LogicLoadingStep == LoadingStep.InitLevelMap then
        LuaShoveManager.InitLevel()
        LevelItemManager.BeforeInitLevel(persistPrivate.CurInfoData.LevelID)
        LevelManager.CurLevelFunc:InitLevel()
        FormulaCalculator.OnInitLevel(persistPrivate.CurInfoData.LevelType)
        logicData.LogicLoadingStep = LoadingStep.InitLevelLayout
    elseif logicData.LogicLoadingStep == LoadingStep.InitLevelLayout then
        LevelItemManager.AfterInitLevel(persistPrivate.CurInfoData.LevelID,persistPrivate.CurCombineLevelData)
        LevelEvaluationManager.InitLevel(persistPrivate.CurInfoData.LevelID)
        logicData.LogicLoadingStep = LoadingStep.InitPlayer
    elseif logicData.LogicLoadingStep == LoadingStep.InitPlayer then
        LevelPlayerManager.CreatePlayers()
        ExpLevelManager.PreloadAssets()
        logicData.LogicLoadingStep = LoadingStep.ReadyEnterLevel
    elseif logicData.LogicLoadingStep == LoadingStep.ReadyEnterLevel then
        --if ExpLevelManager.IsPreloadAssetsCompleted() then
        if true then
            private.ReadyEnterLevel() --LoadFinished
            logicData.LogicLoadingStep = LoadingStep.EnterLevel
        else
            --TODO 等待加载完成但不够优雅，理想状态下加载过程中可以去干别的事情
        end
    elseif logicData.LogicLoadingStep == LoadingStep.EnterLevel then
        NetManager.SetNetMsgPaused(false)
        if not LevelManager.IsSyncLevel() then
            --同步玩法 需要等readymsg回复了对应协议后再执行                   
            private.BeginLevel()
            LevelManager.SetLoadingLevelEnd()
        end        
    end
    ExpLevelManager.OnUpdate(logicData)
end

function private.OnUpdateLoadingDummy()
    local logicData = LevelManager._levelLogicData
    local LoadingStep = LuaConst.Enum_LoadingStep
    if logicData.LogicLoadingStep == LoadingStep.WaitSceneLoadingOk then
        if logicData.SceneLoaded then
            logicData.LogicLoadingStep = LoadingStep.EnterLevel
        end
    elseif logicData.LogicLoadingStep == LoadingStep.EnterLevel then
        LevelManager.CurLevelFunc:InitLevel()
        private.BeginLevel()
        LevelManager.SetLoadingLevelEnd()
    end
    ExpLevelManager.OnUpdate(logicData)
end

function LevelManager.OnUpdate_InLevel()
    LevelManager.UpdateTimer()
    LevelManager.CurLevelFunc:OnUpdate()
end

function LevelManager.OnLateUpdate_InLevel()
    if LevelManager.CurLevelFunc then
        LevelManager.CurLevelFunc:OnLateUpdate()
    end
end

function LevelManager.UpdateTimer()
    for i=#private.timerList,1,-1 do
        private.timerList[i]._delayFrame = private.timerList[i]._delayFrame - 1
        if private.timerList[i]._delayFrame <= 0 then
            local callback = private.timerList[i]._callback
            table.remove(private.timerList,i)
            callback()  --这样更安全，主要怕callback的堆栈出异常导致private.timerList无法清除
        end
    end
end

function LevelManager.AddTimer(callback,delayTime)
    local timer = {_delayFrame = delayTime,_callback = callback}
    table.insert(private.timerList,timer)
end

function LevelManager.ClearTimer()
    table.clearArray(private.timerList)
end
--endregion Update

--region ******************* SwitchLevel *******************

function private.GetLoadSceneCount()
    return #persistPrivate.switchLevelIdQueue;
end

--如果有下个要加载的场景，择加载
function private.CheckLoadNextLevel()
    if persistPrivate.switchLevelIdQueue and persistPrivate.switchLevelIdQueue[1] then
        local levelInfo = table.remove(persistPrivate.switchLevelIdQueue, 1)
        LevelManager.SwitchLevel(levelInfo.levelId,levelInfo.randomSeed,levelInfo.needCheck, levelInfo.isNormalScene)
    end
end

function private.IsLevelLoadingOver()
    local loadState = LevelManager._levelLogicData.LogicLoadingStep
    if loadState == LuaConst.Enum_LoadingStep.None then
        return true
    end
    if LevelManager.IsSyncLevel() then
        if loadState == LuaConst.Enum_LoadingStep.EnterLevel then
            return true
        elseif loadState == LuaConst.Enum_LoadingStep.FastPlay then
            return true
        end
    end
    return false
end

---@public 切换到组合关卡
---@param combineID 组合关卡id, 索引CombinationLevel
function LevelManager.SwitchCombinationLevel(combineID, randomSeed, needCheck, isNormalScene)
    local combinationLevel = DataSheetManager.CombinationLevel:GetDataByID(combineID)
    persistPrivate.CurCombineLevelData = combinationLevel
    private.SwitchLevel(combinationLevel.LevelID, randomSeed, needCheck, isNormalScene)
end

---@public 切换关卡
---@param levelID 关卡id, 索引LevelInfoData
function LevelManager.SwitchLevel(levelID, randomSeed, needCheck,isNormalScene)
    local levelInfoData = DataSheetManager.LevelInfoData:GetDataByLevelID(levelID)
    if persistPrivate.CurInfoData and not USE_LUA_STANDALONE and levelInfoData and LevelManager.IsNeedSpecialLoadingLevel(levelInfoData.LevelType) then
        CTL.Loading.OpenSpecialLoadingView()
        private.SwitchLevel(levelID, randomSeed, needCheck,isNormalScene, true)
        return
    end
    
    persistPrivate.CurCombineLevelData = nil
    private.SwitchLevel(levelID, randomSeed, needCheck,isNormalScene)
end

---@public 切换到一个虚拟关卡DummyLevel
---@param scenePath 虚拟关卡使用的场景
function LevelManager.SwitchDummyLevel(scenePath, isPlotReview)
    LevelManager.ExitLevel()
    --设置Dummy数据
    DummyLevelData.LevelType = LuaConst.LevelType.SpecialLevelType
    DummyLevelData.ScenePath = scenePath
    private.SetCurInfoData(DummyLevelData)
    LevelManager.CurLevelFunc = DummyLevelFunction:new()
    --设置loading
    LevelManager._levelLogicData.LogicLoadingStep = LuaConst.Enum_LoadingStep.WaitSceneLoadingOk
    LevelManager._levelLogicData.SceneLoaded = false
    if isPlotReview then
        CTL.Loading.BeginLoading(MDL.Loading.LoadingTypeEnum.PlotReview)
    else
        CTL.Loading.BeginLoading(MDL.Loading.LoadingTypeEnum.InGame)
    end
    persistPrivate.loadUpdateAgent = private.OnUpdateLoadingDummy
    --设置开始加载
    AppLoadingProxy.LoadScene(scenePath)
end

---@public 切换到上一次缓存的关卡
function LevelManager.RecoverLevel()
    local context = persistPrivate.levelSwitchContext
    if not context then
        logging.error(LTAG.ERROR, "当前没有可以恢复的关卡数据")
        return
    end
    -- 这里需要通过服务器进行传送。保证数据的正常
    CTL.Level.ConveyLevelByLevelID(context.levelId, true)
end

function private.SwitchLevel(levelID, randomSeed, needCheck, isNormalScene)
    local levelInfoData = DataSheetManager.LevelInfoData:GetDataByLevelID(levelID)
    if not levelInfoData then
        logging.error(LTAG.ERROR, "没有根据LevelID找到相应的LevelInfoData！", levelID)
        return
    end
    local levelSwitchContext = { levelId=levelID, randomSeed = randomSeed, needCheck = needCheck, isNormalScene=isNormalScene, infoData = levelInfoData}
    private.IsReplayRecordInSwitchLevel = persistPrivate.IsReplayBattle
    --有正在加载的场景的时候加入队列
    if not private.IsLevelLoadingOver() then
        --这里添加一个判断，因为在进入副本的过程中如果断线，重连上之后会再次有切换地图的消息
        logging.error(LTAG.ERROR, "SwitchLevel One More Times,levelID =" .. levelID ,",LoadingStep = ",LevelManager._levelLogicData.LogicLoadingStep ,"CurLevelID = ",persistPrivate.CurInfoData.LevelID)
        table.insert(persistPrivate.switchLevelIdQueue, levelSwitchContext)
        return
    end
    if not USE_LUA_STANDALONE then
        NetManager.SetNetMsgPaused(true)
    end
    local curScene    
    if persistPrivate.CurInfoData then
        curScene = persistPrivate.CurInfoData.ScenePath
        LevelManager.ExitLevel()
    end
    persistPrivate.levelSwitchContext = levelSwitchContext
    
    LevelManager.SetNeedCheckNotSyncLevel(needCheck)
    local randomSeed = randomSeed
    if randomSeed == nil or randomSeed == 0 then
        if needCheck then
            logging.error(LTAG.ERROR, "[gws] :发现本应该校验的战斗 ，服务器居然没有发随机种子！")
        end
        randomSeed = math.random(99999)
    end

    --↓因为底层有一个巨大的修改，loading期间不再处理msg，所以很多地方都得把代码提前，这段代码是从 private.OnEnterFubenResponse 里提前到这里
    if levelInfoData.LevelType == LuaConst.LevelType.NORMAL and not needCheck then
        NotSyncBattleSetter.SetLevelData(CTL.LevelSelect.GetLevelCutsceneAutoPassTimeByLevelInfoData(levelInfoData))
    end
    --↑

    LogicRandom.SetRandomPool(randomSeed);
    persistPrivate.loadUpdateAgent = private.OnUpdateLoading
    if USE_LUA_STANDALONE or (LevelManager.IsNeedNoLoadingScene(LevelManager.LevelType) or LevelManager.IsNeedNoLoadingScene(levelInfoData.LevelType) ) --判断进入或退出的关卡是位面副本【校验程序也需要不走loading】
            and curScene == levelInfoData.ScenePath then --判断进入和退出的关卡是同一个场景
        local playerPos
        local playerDir
        if LogicUpdateManager._curEntity then
            logging.error(LTAG.ERROR, "[gws]:预计这部分代码应该是废弃了 ，如果执行此处逻辑，则需要view代码！此log不出现则以后删除这部分代码")
            playerPos = LogicUpdateManager._curEntity.components.move.LogicPos
            playerDir = LogicUpdateManager._curEntity.components.move.LogicRotateDir
        end
        private.InitLevel_NoLoading(levelInfoData,playerPos,playerDir) -- 不用担心同步玩法，这个pos和dir都用不上（用服务器传过来）
    elseif LevelManager.IsReplayBattle() and CTL.Replay.IsPlayAgain() then
        private.InitLevel_NoLoading(levelInfoData)
    else
        private.InitLevel_Loading(levelInfoData)
    end

    ExpLevelManager.TrySetPhysics()
end

function private.SetCurInfoData(levelInfoData)
    persistPrivate.CurInfoData = levelInfoData
    private.RefreshCacheData()
end
--在设置levelInfoData的时候刷新一些数据并缓存起来，以节省性能
function private.RefreshCacheData()
    if persistPrivate.CurInfoData then
        LevelManager.LevelType = persistPrivate.CurInfoData.LevelType
    else
        LevelManager.LevelType = LuaConst.LevelType.NONE
    end

    LevelManager.LevelFeatureData = LevelManager.LevelType >0 and DataSheetManager.LevelFeatureData:GetDataByLevelFeatureID(LevelManager.LevelType) or nil
    if LevelManager.LevelFeatureData then
        
        if LevelManager.LevelFeatureData.SwitchHeroCD == 0 then
            private.switchHeroCd = DataSheetManager.ConstData:GetDataByID("SwitchHeroCD").IntValue
        else
            private.switchHeroCd = LevelManager.LevelFeatureData.SwitchHeroCD
        end
    end
    LevelManager.IsTown = LevelManager.LevelType == LuaConst.LevelType.TOWN
        or LevelManager.LevelType == LuaConst.LevelType.GuildPartyMap  --成镇关卡，仅为主城
        or LevelManager.LevelType == LuaConst.LevelType.CrossEscortTown
        or LevelManager.LevelType == LuaConst.LevelType.SingleEscortTown
        or LevelManager.LevelType == LuaConst.LevelType.CrossServerTown --跨服主城
		or LevelManager.LevelType == LuaConst.LevelType.SatelliteTown
        or LevelManager.LevelType == LuaConst.LevelType.CrossHeroMatchTown
        or LevelManager.LevelType == LuaConst.LevelType.CrossFairSoloTournamentTown
        or LevelManager.LevelType == LuaConst.LevelType.SingleFairSoloTournamentTown
        or LevelManager.LevelType == LuaConst.LevelType.CrossHeroMatchTown3V3
        or LevelManager.LevelType == LuaConst.LevelType.TeamFairChampionshipTown
end

--设置服务器开服天数
function LevelManager.SetOpenServerDays(serverDays)
    private.openServerDays = serverDays
end
--获取服务器开服天数
function LevelManager.GetOpenServerDays()
    return private.openServerDays
end

--设置服务器等级
function LevelManager.SetServerLevel(serverLevel)
    private.ServerLevel = serverLevel
end
--设置是否有下一个关卡
function LevelManager.SetHasNextLevel(hasNext)
    private.hasNextLevel = hasNext
end
--是否有下一个关卡
function LevelManager.GetHasNextLevel()
    return private.hasNextLevel
end
--获取服务器等级，可能返回nil
function LevelManager.GetServerLevel(serverLevel)
    return private.ServerLevel
end
--设置服务器战力
function LevelManager.SetServerGs(serverGs)
    private.serverGs = serverGs
end

--设置服务器保存的GMS开关
function LevelManager.SetSwitchInGMS(switchInGMSList)
    private.switchInGMSDic = {}
    for i,switch in ipairs(switchInGMSList) do
        private.switchInGMSDic[switch.SwitchType] = switch.SwitchState == 0 --  0-开，1-关
    end
end
--获取服务器保存的GMS开关中某个开关的值
function LevelManager.GetSwitchInGMS(switchInGMSType)
    if private.switchInGMSDic[switchInGMSType] == nil then
        logging.error(LTAG.ERROR, "[gws] 在获取战斗相关的GMS开关时，未发现枚举： ", switchInGMSType)
        return false
    end
    return private.switchInGMSDic[switchInGMSType]
end

-- attrInfos 是
function LevelManager.SetServerAttrInfos(attrInfos)
    private.attrInfos = attrInfos
end

function LevelManager.GetServerAttrInfos()
    return private.attrInfos
end

--设置赛制阶段
function LevelManager.SetMatchStage(matchStage)
    private.MatchStage = matchStage
end
--获取赛制阶段
function LevelManager.GetMatchStage()
    return private.MatchStage
end

--设置不影响战斗的数据
function LevelManager.SetNotBattleInfo(notBattleInfo)
    LevelManager.lineId = notBattleInfo.lineId
    LevelManager.campName1 = notBattleInfo.campName1
    LevelManager.campName2 = notBattleInfo.campName2
end

function LevelManager.SetMonsterHpInfos(monsterHpInfos)
    private.monsterHpInfos = monsterHpInfos
end

function LevelManager.GetMonsterHpInfos()
    return private.monsterHpInfos
end

function LevelManager.SetNewBattleInfoIntParam(newBattleInfoIntParam)
    private.newBattleInfoIntParam = newBattleInfoIntParam
end

function LevelManager.GetNewBattleInfoIntParam()
    return private.newBattleInfoIntParam
end

function LevelManager.SetPreBattleResult(preBattleResults)
    private.preBattleResults = preBattleResults
end

function LevelManager.GetPreBattleResult()
    return private.preBattleResults
end
--服务器发过来的关卡时长
function LevelManager.SetBattleTime(time)
    private.battleTime = time
end
--服务器发过来的关卡时长
function LevelManager.GetBattleTime()
    return private.battleTime
end

--服务器发过来的关卡结束时间戳
function LevelManager.SetBattleEndTime(time)
    private.battleEndTime = time
end
--服务器发过来的关卡结束时间戳
function LevelManager.GetBattleEndTime()
    return private.battleEndTime
end

function LevelManager.SetBattleStatueInfoList(list)
    private.battleStatueInfoList = list
end
-- private.battleStatueInfoList 是 repeated common.RoleSceneBasic 类型
function LevelManager.GetBattleStatueInfoList()
    return private.battleStatueInfoList
end

function LevelManager.GetLineId()
    return LevelManager.lineId
end

--设置劫镖等关卡的战斗中心位置
function LevelManager.SetBattleAnchorPos(pos)
    private.BattleAnchorPos = FP.newV2(0,0):Rawset(pos.X,pos.Z)
end
--获取劫镖等关卡的战斗中心位置
function LevelManager.GetBattleAnchorPos()
    return private.BattleAnchorPos
end

function LevelManager.GetServerGs()
    return private.serverGs or 0
end

function LevelManager.SetServerBossHp(bossHp, maxBossHp)
    private.severBossHp = bossHp
    private.serverMaxBossHp = maxBossHp
end

function LevelManager.GetServerBossHp()
    return private.severBossHp, private.serverMaxBossHp
end

function LevelManager.SetGsGroupId(value)
    private.gsGroupId = value
end

function LevelManager.GetGsGroupId()
    return private.gsGroupId
end

function LevelManager.SetBossLevel(value)
    private.bossLevel = value
end

function LevelManager.GetBossLevel()
    return private.bossLevel
end

function LevelManager.ClearMsgCache()
    private.serverGs = nil
    private.severBossHp = nil
    private.serverMaxBossHp = nil
    private.BattleAnchorPos = nil
    private.attrInfos = nil
end

--重设静态的private数据
function LevelManager.ResetPrivateValue()
    LevelManager.ClearMsgCache()
    private.ClearPrivateValue()

    for k,v in pairs(private) do --pairs save
        if type(v) ~= "function" and v ~= CLEARED_FLAG then
            logging.error(LTAG.ERROR, "HYW : 严重警告！存在没有清理干净的缓存 : ", k, " : ",  v, "  很可能造成战斗不一致！！")
        end
    end

    private.InitPrivateValue()

    for k,v in pairs(private) do--pairs save
        if type(v) ~= "function" and v == CLEARED_FLAG then
            logging.error(LTAG.ERROR, "HYW : 严重警告！存在没有正确初始化的private数据 : ", k, " : ",  v)
        end
    end
end

--单机玩法的协议被处理前，在这个时间点清理缓存比较合适
function LevelManager.BeforeRoleEnterSceneResp()
    LevelManager.ResetPrivateValue()
end

--联机玩法的协议被处理前，在这个时间点清理缓存比较合适
function LevelManager.BeforeHandleInitFubenInfo()
    LevelManager.ResetPrivateValue()
end

function private.InitLevel_Loading(levelInfoData)
    private.InitLevel(levelInfoData)
    LevelManager._levelLogicData.SceneLoaded = false
    if private.GetLoadSceneCount() <= 0 then
        LevelManager._levelLogicData.LogicLoadingStep = LuaConst.Enum_LoadingStep.WaitSceneLoadingOk
        local walkPlane = levelInfoData.WalkPlane~="" and levelInfoData.WalkPlane or levelInfoData.ScenePath
        BattleExt.SetLevelMapInfo(levelInfoData.LevelID, walkPlane)     --地图的格子信息 ;设置寻路数据
        ExpLevelManager.LoadLevel(levelInfoData)
        local customHeight = LuaConst.LevelCustomHeight[walkPlane]
        CTL.Setting.SetCustomTerrainHeight(customHeight)
    else
        CTL.Loading.BeginLoading(MDL.Loading.LoadingTypeEnum.InGame)
        LevelManager._levelLogicData.LogicLoadingStep = LuaConst.Enum_LoadingStep.InitLevelMap
    end

end

--InitLevel_NoLoading等价于不切场景的切关模式！！！
-- 没有loading 过程 ，需要把loading过程的代码执行下
function private.InitLevel_NoLoading(levelInfoData,pos,dir)
    EventSystem.Dispatch(EventID.Level_CloseAllBaseUI)
    private.InitLevel(levelInfoData)
    if USE_LUA_STANDALONE then
        local walkPlane = levelInfoData.WalkPlane~="" and levelInfoData.WalkPlane or levelInfoData.ScenePath
        BattleExt.SetLevelMapInfo(levelInfoData.LevelID, walkPlane)     --地图的格子信息 ;设置寻路数据
    end
    LuaShoveManager.InitLevel(true)
    LevelItemManager.BeforeInitLevel(levelInfoData.LevelID)
    LevelManager.CurLevelFunc:InitLevel()
    FormulaCalculator.OnInitLevel(levelInfoData.LevelType)
    LevelItemManager.AfterInitLevel(levelInfoData.LevelID,persistPrivate.CurCombineLevelData)
    LevelEvaluationManager.InitLevel(levelInfoData.LevelID)
    LevelPlayerManager.CreatePlayers(pos,dir)
    private.ReadyEnterLevel() -- LoadFinished
    if not LevelManager.IsSyncLevel() then
        --同步玩法 需要等readymsg回复了对应协议后再执行                   
        private.BeginLevel(true)        
    end
    LevelManager.SetLoadingLevelEnd()
    
end

function private.InitLevel(levelInfoData)
    SystemManager.BeforeLevelInit()
    --这个会先于LevelFunction:InitLevel
    EventSystem.Dispatch(EventID.UI_ChannelChat_OnCloseWindow)
    private.levelPause = false
    LevelManager.isPlayingTimeline = false
    private.SetCurInfoData(levelInfoData)
    LevelPlayerManager.OnInitLevel()
    LevelManager.CurLevelFunc = (persistPrivate.levelFuncHandle[levelInfoData.LevelType] or persistPrivate.levelFuncNormal):new()
    SyncMoveManager.SetEntityMoveEnable(LevelManager.IsStateSyncMoveLevel())
    LuaInputManager.Init()

    ExpLevelManager.SetupPsLOD(levelInfoData.LevelType)

    SystemManager.OnLevelInited()
    logging.crit(LTAG.CRIT, "OnLevelLoaded", levelInfoData.LevelID, levelInfoData.LevelType, levelInfoData.ScenePath)
end

function private.InitLevelFinished()
    private.CastLevelStartEffects()
end

function private.CastLevelStartEffects()
    if LevelManager.LevelFeatureData then
        for i,effectID in ipairs(LevelManager.LevelFeatureData.StartEffects) do
            if effectID and effectID > 0 then
                BattleEffect.ExecuteByEffectId(effectID)
            end
        end
    end
end

--endregion SwitchLevel

--region ******************* Level *******************
function LevelManager.OnShutdown()
    if persistPrivate.CurInfoData then
        AppLoadingProxy.UnloadCurrentScene()
    end
    if LevelManager.CurLevelFunc then
        LevelManager.CurLevelFunc:StopLevel()
    end
    LevelManager.ExitLevel()
    if UnityEngine.Time.timeScale ~=1 then -- 在一些正在加速玩法中，突然回登录时 ，速度没降下来
        UnityEngine.Time.timeScale = 1
    end
end

--注意：在 SwitchLevel 前设置的数据，在下面的代码不能清理
function LevelManager.ExitLevel()    
    if persistPrivate.CurInfoData then
        EventSystem.Dispatch(EventID.BI_LevelHigh,BIManager.BIType.LevelAvgFPS,persistPrivate.CurInfoData.LevelID, persistPrivate.CurInfoData.ScenePath)
        EventSystem.Dispatch(EventID.BI_LevelHigh,BIManager.BIType.PlayerOnlineTime)
    end
    LevelManager.ClearTimer()
    LevelManager.SetIsInLevelWatchBattle(false)
    if LevelManager.CurLevelFunc then
        if persistPrivate.persistSummaryTime then
            persistPrivate.persistSummaryTime = false
        else
            persistPrivate.summaryTime:Reset()
        end
        persistPrivate.recordFrameCmdArray = {}
        
        ExpLevelManager.SetupPsLOD(nil)

        LogicUpdateManager.StopFightUpdate()
        --主视角调用
        if LevelManager.IsNoBattleLevel() and LogicUpdateManager._curEntity and LogicUpdateManager._curEntity.components.buff:CheckHasBuffState(LuaConst.SpecialBuffs.InRiding) then
            private.PlayerIsOnHorse = true
        end
        MultiplayManager.ExitLevel()
        ExpLevelManager.ExitLevel()
        LevelPlayerManager.ExitLevel()
        BattleEventSystem.ExitLevel() -- 不能晚于entity死亡
        LevelItemManager.ExitLevel()
        SystemManager.ExitLevel()
        LevelEvaluationManager.ExitLevel()
        LuaShoveManager.ExitLevel()
        SyncMoveManager.ExitLevel()
        LogicUpdateManager.ExitLevel()
        CampManager.OnExitLevel()
        ExpSystemManager.Clear()
        ExpLevelManager.ClearLevel()
        FormulaCalculator.OnExitLevel()
        LevelManager.CurLevelFunc = nil
    end
end
--同步玩法中调用不会引发不一致，已经做了特殊处理了，同步玩法中LevelManager.PauseLevel不会执行逻辑代码
function LevelManager.PauseLevel(pause,battleRoomID)
    if LevelManager.IsReplayBattle() then
        private.levelPause = pause
        LogicUpdateManager.PauseEntity(pause)
        EventSystem.Dispatch(EventID.Level_Pause,pause)
        if GameAppInfo.IsVersionGreaterThan111000() then
            AuxUtil.AnimBaking_SetTimeScale(pause and 0 or 1)
        end
        return
    end
    
    if LevelManager.IsSyncLevel() then
        --if LevelPlayerManager.IsMainPlayerFirstOnlinePlayer() then --主视角safe，因为后续都是非战斗内核用的数据或者事件  --注掉了，因为IsMainPlayerFirstOnlinePlayer的数据初始化太晚并且太慢，这里访问会出现非法值、过期值。而下面的代码又很重要，不能不调。所以这里不过滤，大家一起发
            if pause then
                --暂停一定要调，不然不会回调timeline的callback，导致Decision_PveFight不运行(ShouldBlockAI因为LevelItemManager.IsShowingTimeline()为true而一只保持true)
                LevelManager.isPlayingTimeline = true
                EventSystem.Dispatch(EventID.Level_Pause_Sync, battleRoomID)  --联机玩法暂停需要依赖服务器，此处请求发送TCP给服务器请求暂停，服务器通过停止推帧来实现暂停
            else
                if LevelPlayerManager.IsMainPlayerFirstOnlinePlayer() or LevelPlayerManager.IsMainPlayerTeamLeader() then --主视角safe --恢复要求没那么严格，没人调也行，所以这里加个过滤
                    EventSystem.Dispatch(EventID.Level_Resume_Sync, battleRoomID) --联机玩法恢复暂停需要依赖服务器，此处请求发送TCP给服务器请求恢复，服务器通过恢复推帧来实现恢复
                end
            end
        --end
    else
        if private.levelPause == pause then
            return
        end
        private.levelPause = pause
        LogicUpdateManager.PauseEntity(pause)
        EventSystem.Dispatch(EventID.Level_Pause,pause)
        if GameAppInfo.IsVersionGreaterThan111000() then
            AuxUtil.AnimBaking_SetTimeScale(pause and 0 or 1)
        end
    end
end

function LevelManager.SetServerClientIntermediateParamsBytes(bytes)
    --logging.error(LTAG.ERROR, "HYW : SetClientIntermediateParamsBytes : " .. tostring(bytes))
    private.clientIntermediateParamsBytes = bytes
end
function LevelManager.GetServerClientIntermediateParamsBytes()
    return private.clientIntermediateParamsBytes
end
function LevelManager.SetClimbTowerId(climbTowerId)
    private.climbTowerId = climbTowerId
end
function LevelManager.GetClimbTowerId()
    return private.climbTowerId
end

function LevelManager.GetSlgGveData()
    return private.slgData
end

function LevelManager.SetSlgGveData(landId, thiefId, buffIdForFightingEnemy, openDayId)
    private.slgData = { landId = landId, thiefId = thiefId, buffIdForFightingEnemy = buffIdForFightingEnemy, openDayId = openDayId }
end

function private.ReadyEnterLevel()
    LevelManager.CurLevelFunc:OnLoadFinished()
    private.InitLevelFinished()
    if not LevelManager.IsFreeToEnterAndLeaveLevel() then
        ExpLevelManager.ReadyEnterLevel(persistPrivate.CurInfoData)
    end
    AuxUtil.BuglyAgentSetScene(LevelManager.GetCurLevelID())
    AuxUtil.BuglyAgentAddSceneData("LevelId", LevelManager.GetCurLevelID())
end

function LevelManager.EnterSyncLevel()
    private.BeginLevel()
    local serverFrame = KCPTransport.GetCurserverFrame()
    if serverFrame < LogicUpdateManager.GetMaxFastPlayFrameNum() then
        logging.log(LTAG.LOG ,"[EnterSyncLevel] - LoadingStep =none : frame num is less then 400 ; frame num =" ,serverFrame)
    else
        if LogicUpdateManager._serverReplenishFrame == -1 then -- 玩家首次进入时服务器的帧已经过了20秒 。在手机上很难出现，除非是闪退或者网络卡顿。
            EventSystem.Dispatch(EventID.BI_LevelMiddle,BIManager.BIType.SyncBattle,"[sync]FirstEnterTooLate" , serverFrame)
            LogicUpdateManager.SetServerReplenishFrame(serverFrame) --设置快速补帧的值 ，不做表现  ；
        end
        LevelManager._levelLogicData.LogicLoadingStep = LuaConst.Enum_LoadingStep.FastPlay
        logging.log(LTAG.LOG ,"[EnterSyncLevel] -LoadingStep =FastPlay : frame num is bigger then 400 ; frame num =" ,serverFrame)
    end
end

function LevelManager.SetLoadingLevelEnd()
    if USE_LUA_STANDALONE then --如果是服务器检验程序 ，不要这些逻辑
        return
    end
    NetManager.SetNetMsgPaused(false)
    if LevelManager._levelLogicData.LogicLoadingStep ~= LuaConst.Enum_LoadingStep.None then
        LevelManager._levelLogicData.LogicLoadingStep = LuaConst.Enum_LoadingStep.None
        LevelManager.StartRealEnterScene()
        private.CheckLoadNextLevel()
    end
end

--真正的进入场景
function LevelManager.StartRealEnterScene()
    ExpLevelManager.StartRealEnterScene()
    EventSystem.Dispatch(EventID.Level_RealEnterLevel)
end

function LevelManager.AddSummaryTime(delta, persist)
    persistPrivate.summaryTime:Add(delta)
    persistPrivate.persistSummaryTime = persist
end

function LevelManager.GetSummaryTime()
    if persistPrivate.summaryTime == nil or persistPrivate.summaryTime == FP.Const.Zero then
        logging.error(LTAG.ERROR, "HYW : 调用LevelManager.GetSummaryTime时机不对！只有在关卡结束后才能调用LevelManager.GetSummaryTime")
    end
    return persistPrivate.summaryTime
end

function private.BeginLevel(noLoading)
    if LevelManager.CurLevelCanRideHorse() then
        if LevelManager.IsNoBattleLevel()  then -- 离开主城时骑马，回到主城也要骑马
            if private.PlayerIsOnHorse then
                --主视角调用
                SystemManager.ExecuteRideHorse(LogicUpdateManager._curEntity, true)
            end
            private.PlayerIsOnHorse = false        
        end
    end
    ExpLevelManager.PreEnterLevel(persistPrivate.CurInfoData.LevelID, persistPrivate.CurCombineLevelData)
    LevelManager.CurLevelFunc:BeginLevel()
    
    if not LevelManager.IsTown then
        ExpLevelManager.InitShowGuide()
    end
    if not LevelManager.IsSyncLevel() then -- 如果有的同步玩法需要打开 ，那就在各自的levelfunction搞
        ExpLevelManager.EnterLevel(persistPrivate.CurInfoData)            
    end
    
    if noLoading then
        ExpLevelManager.ShowNoLoadingEffect()
    end
    EventSystem.Dispatch(EventID.Level_BeginLevel)
end

--endregion Level

function LevelManager.SetCutsceneAutoPass(isAutoPass)
    persistPrivate.autoPassCutscene = isAutoPass
end

function LevelManager.GetCutsceneAutoPassTime()
    return persistPrivate.autoPassCutscene and private.cutsceneAutoPassTime or -1
end

function LevelManager.SetLevelData(cutSceneAutoPassTime)
    private.cutsceneAutoPassTime = cutSceneAutoPassTime
end

function LevelManager.SetServerSaveRecordBytes(bytes)
    if not LevelManager.ShouldKeepSyncLevel() then
        private.serverSaveRecordBytes = bytes
    else
        logging.error(LTAG.ERROR, "HYW : 尝试在联机或者需要校验的玩法中设置关卡存档！目前不支持这样做！请记住入口并立刻联系战斗程序！")
    end
end

function LevelManager.GetServerSaveRecordBytes()
    return private.serverSaveRecordBytes
end

function LevelManager.ConsumeServerSaveRecordBytes()
    local ret = private.serverSaveRecordBytes
    private.serverSaveRecordBytes = nil
    return ret
end

-- 主线关卡
--levelID就是BarrierChosen的MissionDataID，是LevelInfo表的ID
function LevelManager.GetBarrierChosenIDByLevelID(levelID)
    for _,data in DataSheetManager.BarrierChosenData:GetEnumerator() do
        --策划保证，BarrierChosenData表里不会有任何重复的MissonDataID的元素，所以这里可以这样搞
        for i,id in ipairs(data.MissonDataID) do
            if id == levelID then
                return data
            end
        end
    end

    return nil
end

function LevelManager.IsLevelPause()
    return private.levelPause
end

function LevelManager.CheckCurLevelType(levelType)
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.LevelType == levelType
end

function LevelManager.GetCurLevelID()
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.LevelID or -1
end

function LevelManager.CurLevelCanRideHorse()
    return persistPrivate.CurInfoData.HorseAble
end

function LevelManager.GetCurLevelCameraID()
    local camera1ID = persistPrivate.CurInfoData.DefaultCameraID[1]
    local camera2ID = persistPrivate.CurInfoData.DefaultCameraID[2] or 0
    return camera1ID, camera2ID
end

--获取关卡推荐战力
function LevelManager.GetLevelGs()
    return LevelManager.CurLevelFunc:GetLevelGs()
end

--服务器推过来的PVE压制ID
function LevelManager.SetSubjugateDataPVEID(subjugateDataPVEID)
    private.subjugateDataPVEID = subjugateDataPVEID
end

function LevelManager.GetSubjugateDataPVEID()
    if private.subjugateDataPVEID then
        return private.subjugateDataPVEID  ----服务器推过来的PVE压制ID
    end
    return LevelManager.CurLevelFunc:GetSubjugateDataPVEID()
end

function LevelManager.IsSoloFight()
    return LevelManager.LevelType == LuaConst.LevelType.SoloFight
end

function LevelManager.IsNineVsNineFightLevel(levelType) -- 群雄演武
    local type = levelType or LevelManager.LevelType
    return type == LuaConst.LevelType.NineVsNineFight
end

function LevelManager.IsAttackCity()
    return LevelManager.LevelType == LuaConst.LevelType.AttackCity
end

function LevelManager.IsLootMine()
    return LevelManager.LevelType == LuaConst.LevelType.LootMine
end

-- isSyncPvE 但是不要循环复活功能
function LevelManager.IsSyncTeamPVENotRevive()
    return LevelManager.LevelType == LuaConst.LevelType.SyncTeamDifficultLevel
        or LevelManager.LevelType == LuaConst.LevelType.SyncWantedPVE
end

--是否是多人难度副本
function LevelManager.IsSyncTeamDifficult()
    return LevelManager.LevelType == LuaConst.LevelType.SyncTeamDifficultLevel
end
--是否是小黑屋无双关卡
function LevelManager.IsLittleBlackRoomMusouLevel()
    return not (LevelManager.IsSyncLevel() or LevelManager.IsSoloFight() or LevelManager.IsNineVsNineFightLevel())  --这里注意单机校验的关卡是可以播小黑屋的
end

-- 是否是不走loading的副本：包括普通位面和同步位面
function LevelManager.IsNeedNoLoadingScene(type)
    return type == LuaConst.LevelType.GuildBossTown
            or type == LuaConst.LevelType.Planes
            or type == LuaConst.LevelType.DigPlanes
            or type == LuaConst.LevelType.ClimbTower
            or type == LuaConst.LevelType.NationClimbTower
            or type == LuaConst.LevelType.SyncPlanesEscort
            or type == LuaConst.LevelType.SyncCountryPVP
            or type == LuaConst.LevelType.SyncWantedPVE
end

function LevelManager.IsSingleEscortTown()
    return LevelManager.LevelType == LuaConst.LevelType.SingleEscortTown
end

function LevelManager.IsSyncPlanesEscort()
    return LevelManager.LevelType == LuaConst.LevelType.SyncPlanesEscort
end

-- 是否是公平玩法
function LevelManager.IsFairLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVP 
    or LevelManager.LevelType == LuaConst.LevelType.SyncSolo
    or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVPPractice
    or LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice
    or LevelManager.LevelType == LuaConst.LevelType.BossChallenge
    or LevelManager.LevelType == LuaConst.LevelType.SubjectMonthBossChallenge
    or LevelManager.LevelType == LuaConst.LevelType.FairNormalPVE
    or LevelManager.LevelType == LuaConst.LevelType.SyncFairSoloTournament
    or LevelManager.LevelType == LuaConst.LevelType.SyncTeamFairChampionship
    or LevelManager.LevelType == LuaConst.LevelType.SyncFourCountryChaos
end
-- 需要把帧数据保存到本地
function LevelManager.NeedSaveFrameDatasLevel(levelTyp)
    local levelType = levelTyp or LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncTeamPVP
            or levelType == LuaConst.LevelType.SyncSolo
            or levelType == LuaConst.LevelType.BossChallenge
            or levelType == LuaConst.LevelType.SyncSoloPractice
            or levelType == LuaConst.LevelType.SyncTeamPVPPractice
            --or levelType == LuaConst.LevelType.RogueLike
end

function LevelManager.IsPracticeLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice 
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVPPractice
end

function LevelManager.IsSyncSolo()
    return LevelManager.LevelType == LuaConst.LevelType.SyncSolo or LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice
end

function LevelManager.IsClimbTower()
    return LevelManager.LevelType == LuaConst.LevelType.ClimbTower or LevelManager.LevelType == LuaConst.LevelType.NationClimbTower
end

function LevelManager.IsSolo()
    return LevelManager.LevelType == LuaConst.LevelType.SyncSolo 
            or LevelManager.LevelType == LuaConst.LevelType.SoloFight
            or LevelManager.LevelType == LuaConst.LevelType.SyncUnfairSolo
            or LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice
            or LevelManager.LevelType == LuaConst.LevelType.SyncFairSoloTournament
end

function LevelManager.IsSyncTeamPVE()
    return LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVE
end

-- 不要剔除子弹特效的关卡
function LevelManager.IsNoCullingExpMissileLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncSolo                        -- 同步1v1
            or LevelManager.LevelType == LuaConst.LevelType.SoloFight                   -- 1v1
            or LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice            -- 1v1切磋
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVP                 -- 3v3
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVPPractice         -- 3v3切磋
            or LevelManager.LevelType == LuaConst.LevelType.SyncFairSoloTournament      -- 天下会武
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamFairChampionship    -- 巅峰对决（天下会武3v3）
            or LevelManager.LevelType == LuaConst.LevelType.SyncUnfairTeamPVP           -- 天地群雄3v3
            or LevelManager.LevelType == LuaConst.LevelType.SyncUnfairSolo              -- 天地群雄1v1
end

function LevelManager.IsSyncRebelStrike()
    return LevelManager.LevelType == LuaConst.LevelType.SyncRebelStrike
end

-- 不要裁剪entity的关卡
function LevelManager.IsNoCullingLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncSolo
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVP
            or LevelManager.LevelType == LuaConst.LevelType.SyncUnfairSolo
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVPPractice
            or LevelManager.LevelType == LuaConst.LevelType.SyncSoloPractice
            or LevelManager.LevelType == LuaConst.LevelType.SyncFairSoloTournament
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamFairChampionship
            or LevelManager.LevelType == LuaConst.LevelType.SyncUnfairTeamPVP
            or LevelManager.LevelType == LuaConst.LevelType.NineVsNineFight
end

-- 战斗等待区关卡：形象为主城形象，但是存储有战斗三军数据。
-- 主城形象存在 LevelPlayerManager.PlayersArmyTable[LuaConst.STANDALONE_PLAYER_PlayID]
-- 战斗三军数据存在 LevelPlayerManager.PlayersArmyTable[LuaConst.BATTLE_WAIT_PLAYER_PlayID]
local Const_BattleWaitLevelDic = {
    [LuaConst.LevelType.GuildWarWaitingArea] = true,
    [LuaConst.LevelType.DragonArteryRegistArea] = true,
    [LuaConst.LevelType.SyncCityWarMainWaitingArea] = true,
    [LuaConst.LevelType.SyncCityWarSideWaitingArea] = true,
    [LuaConst.LevelType.FightThroneTown] = true,
    [LuaConst.LevelType.CrossFightThroneTown] = true,
}
function LevelManager.IsBattleWaitLevel(targetLevelType)
    local levelType = targetLevelType or LevelManager.LevelType
    return Const_BattleWaitLevelDic[levelType] == true
end

function LevelManager.GetCurLevelType()
    return LevelManager.LevelType
end

function LevelManager.GetCurLevelName()
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.ScenePath or ""
end

function LevelManager.GetWaitOtherPlayerType()
    return LevelManager.LevelFeatureData.WaitOtherPlayerType
end

function LevelManager.GetLevelDifficulty()
    return LevelManager.CurLevelFunc:GetLevelDifficulty()
end

--获取公式自适应变量
function LevelManager.GetFormulaAdaptiveVariable()
    return LevelManager.CurLevelFunc:GetFormulaAdaptiveVariable()
end
--获取公式自适应的分段
function LevelManager.GetFormulaAdaptiveVariableRange(variable)
    return LevelManager.CurLevelFunc:GetFormulaAdaptiveVariableRange(variable)
end

function LevelManager.SwitchAutoFight(entity)
    LevelManager.CurLevelFunc:SwitchAutoFight(entity)
end

function LevelManager.OnSetCurEntity(entity,oldEntity)
    LevelManager.CurLevelFunc:OnSetCurEntity(entity,oldEntity)
end

function LevelManager.SwtichForceTargetByIndex(entity,index)
    return LevelManager.CurLevelFunc:SwtichForceTargetByIndex(entity,index)
end

function LevelManager.StartAutoFight(entity, isSystemLevel)
    LevelManager.CurLevelFunc:StartAutoFight(entity, isSystemLevel)
end

function LevelManager.StopAutoFight(entity)
    LevelManager.CurLevelFunc:StopAutoFight(entity)
end

function LevelManager.GetRobotAI(entity)
    -- if LevelManager.LevelType == LuaConst.LevelType.SyncFourForce then
    --     return LuaConst.FourForceRobotAIID
    -- else
    --     return LuaConst.PVPRobotAIID
    -- end
    return LevelManager.CurLevelFunc:GetRobotAI(entity)
end

--在线城镇关卡，仅为城镇(城市）
function LevelManager.IsOnlineTown()
    return (
            LevelManager.LevelType == LuaConst.LevelType.TOWN
            or LevelManager.LevelType == LuaConst.LevelType.GuildPartyMap
            or LevelManager.LevelType == LuaConst.LevelType.CrossEscortTown
            or LevelManager.LevelType == LuaConst.LevelType.SingleEscortTown
            or LevelManager.LevelType == LuaConst.LevelType.CrossServerTown
            or LevelManager.LevelType == LuaConst.LevelType.SatelliteTown
            or LevelManager.LevelType == LuaConst.LevelType.CrossHeroMatchTown
            or LevelManager.LevelType == LuaConst.LevelType.CrossFairSoloTournamentTown
            or LevelManager.LevelType == LuaConst.LevelType.SingleFairSoloTournamentTown
            or LevelManager.LevelType == LuaConst.LevelType.CrossHeroMatchTown3V3
            or LevelManager.LevelType == LuaConst.LevelType.TeamFairChampionshipTown
        )
        and LogicUpdateManager.IsOnlinePlay
end

function LevelManager.IsSatelliteTown()
    return LevelManager.LevelType == LuaConst.LevelType.SatelliteTown
end

--非战斗关卡(主城类型关卡)，使用状态同步的关卡
function LevelManager.IsNoBattleLevel(targetLevelType)
    local levelType = targetLevelType or LevelManager.LevelType
    return levelType == LuaConst.LevelType.TOWN or
            levelType == LuaConst.LevelType.GuildBossTown or
            levelType == LuaConst.LevelType.GuildPartyMap or
            levelType == LuaConst.LevelType.GuildWarWaitingArea or
            levelType == LuaConst.LevelType.CrossEscortTown or
            levelType == LuaConst.LevelType.SingleEscortTown or
            levelType == LuaConst.LevelType.CrossServerTown or
            levelType == LuaConst.LevelType.SatelliteTown or
            levelType == LuaConst.LevelType.FightThroneTown or
            levelType == LuaConst.LevelType.CrossFightThroneTown or
            levelType == LuaConst.LevelType.DragonArteryWaitingArea or
            levelType == LuaConst.LevelType.DragonArteryRegistArea or
            levelType == LuaConst.LevelType.CrossHeroMatchTown or
            levelType == LuaConst.LevelType.CrossFairSoloTournamentTown or
            levelType == LuaConst.LevelType.SingleFairSoloTournamentTown or
            levelType == LuaConst.LevelType.SceneQuizTown or
            levelType == LuaConst.LevelType.SingleSceneQuizTown or
            levelType == LuaConst.LevelType.CrossHeroMatchTown3V3 or
            levelType == LuaConst.LevelType.SingleSceneQuizTownor or
            levelType == LuaConst.LevelType.TeamFairChampionshipTown or 
            levelType == LuaConst.LevelType.SyncCityWarMainWaitingArea or
            levelType == LuaConst.LevelType.SyncCityWarSideWaitingArea 
end

function LevelManager.IsSyncLevel()
    if LevelManager.CurLevelFunc then
        return LevelManager.CurLevelFunc.isSyncLevel
    end
end

function LevelManager.IsNeedSpecialLoadingLevel(levelType)
    return levelType == LuaConst.LevelType.SyncWorldBoss 
            or levelType == LuaConst.LevelType.SyncWarZoneWorldBoss
            or levelType == LuaConst.LevelType.SyncCountryEveningBoss
end

function LevelManager.CurLevelIsNeedSpecialLoadingLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncWorldBoss
            or levelType == LuaConst.LevelType.SyncWarZoneWorldBoss
            or levelType == LuaConst.LevelType.SyncCountryEveningBoss
end

--是否是需要保持一致性的关卡，包括联机玩法和需要服务器校验的单机玩法
function LevelManager.ShouldKeepSyncLevel()
    return LevelManager.IsSyncLevel() or LevelManager.IsNeedCheckNotSyncLevel()
end

--是否是需要用到服务器传来的位置创建自己(如果有单独的levelFunction，可在其里面写 self.usePlayerInfoPos =true)
function LevelManager.IsUsePlayerInfoPos()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.DragonArteryRegistArea
        or levelType == LuaConst.LevelType.SyncCityWarMainWaitingArea
        or levelType == LuaConst.LevelType.SyncCityWarSideWaitingArea
end

--是否是状态同步移动的关卡
function LevelManager.IsStateSyncMoveLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.TOWN  or 
        levelType == LuaConst.LevelType.GuildPartyMap or
    	levelType == LuaConst.LevelType.GuildBossTown or
    	levelType == LuaConst.LevelType.GuildWarWaitingArea or
        levelType == LuaConst.LevelType.CrossEscortTown or
        levelType == LuaConst.LevelType.SingleEscortTown or
        levelType == LuaConst.LevelType.CrossServerTown or
        levelType == LuaConst.LevelType.FightThroneTown or
        levelType == LuaConst.LevelType.CrossFightThroneTown or
        levelType == LuaConst.LevelType.SatelliteTown or
        levelType == LuaConst.LevelType.DragonArteryWaitingArea or
        levelType == LuaConst.LevelType.DragonArteryRegistArea or
        levelType == LuaConst.LevelType.CrossHeroMatchTown or
        levelType == LuaConst.LevelType.CrossFairSoloTournamentTown or
        levelType == LuaConst.LevelType.SingleFairSoloTournamentTown or
        levelType == LuaConst.LevelType.TeamFairChampionshipTown or
        levelType == LuaConst.LevelType.SceneQuizTown or
        levelType == LuaConst.LevelType.SingleSceneQuizTown or
        levelType == LuaConst.LevelType.CrossHeroMatchTown3V3 or
        levelType == LuaConst.LevelType.SyncCityWarMainWaitingArea or
        levelType == LuaConst.LevelType.SyncCityWarSideWaitingArea 
end

--是否是位面副本
function LevelManager.IsPlanesLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.Planes
            or levelType == LuaConst.LevelType.DigPlanes
            or levelType == LuaConst.LevelType.SyncWantedPVE
end

--策划定义的PVP玩法。 pvp玩法 不等价于 联机玩法。比如 1v1，是pvp玩法，但不用联机
function LevelManager.IsPVPLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncTeamPVP          -- 3v3
            or levelType == LuaConst.LevelType.SyncTeamPVPPractice --3v3切磋
            or levelType == LuaConst.LevelType.SyncSoloPractice    --1v1切磋
            or levelType == LuaConst.LevelType.SyncWorldBoss    -- 世界boss
            or levelType == LuaConst.LevelType.SyncFourForce    -- 四军之战（已废弃）
            or levelType == LuaConst.LevelType.SyncGuildBoss    -- 军团Boss
            or levelType == LuaConst.LevelType.SoloFight        -- 1v1
            or levelType == LuaConst.LevelType.SyncGuildWarMapLeft          --军团战左战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapMiddle        --军团战中战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapRight         --军团战右战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapResources     --军团战资源战场
            or levelType == LuaConst.LevelType.SyncTestLevel                --同步测试关
            or levelType == LuaConst.LevelType.SyncSolo                     --同步1v1
            or levelType == LuaConst.LevelType.SyncWarZoneWorldBoss         --战区世界boss
            or levelType == LuaConst.LevelType.SyncPlanesEscort             -- 抢镖战斗
            or levelType == LuaConst.LevelType.SyncUnfairSolo             -- 天地群雄
            or levelType == LuaConst.LevelType.SyncCountryPVP               --国战场景对战
            or levelType == LuaConst.LevelType.DragonArtery                 -- 龙脉战
            or levelType == LuaConst.LevelType.SyncCountryEveningBoss       -- 晚间boss
            or levelType == LuaConst.LevelType.SyncFairSoloTournament       -- 天下会武
            or levelType == LuaConst.LevelType.SyncTeamFairChampionship       -- 巅峰对决（天下会武3v3）
            or levelType == LuaConst.LevelType.AttackCity                   -- 攻城略地
            or levelType == LuaConst.LevelType.LootMine                     -- 掠夺矿场
            or levelType == LuaConst.LevelType.SyncUnfairTeamPVP            -- 天地群雄3v3
            or levelType == LuaConst.LevelType.SyncFourCountryChaos         -- 四国乱斗
            or levelType == LuaConst.LevelType.NineVsNineFight              --群雄演武
end

--是否需要使用官职
function LevelManager.IsUseCountryJobBuffLevel()
    return LevelManager.LevelFeatureData.UseCountryJob
end

--需要使用PVP定制模型的关卡
function LevelManager.IsNeedUsePVPModelLevel()
    return LevelManager.LevelFeatureData.UsePVPModel
end

--需要显示光效
function LevelManager.IsShowHeroLightEffect()
    return LevelManager.LevelFeatureData.IsShowLightEffect
end

--是否显示国家头顶UI
function LevelManager.IsShowHeadUI_Country()
    return LevelManager.LevelFeatureData.IsShowCountry
end

--是否显示势力头顶UI
function LevelManager.IsShowHeadUI_Guild()
    return LevelManager.LevelFeatureData.IsShowGuild
end

--是否显示称号头顶UI
function LevelManager.IsShowHeadUI_Title()
    return LevelManager.LevelFeatureData.IsShowTitle
end

--是否显示敌人特定的子弹的范围圈
function LevelManager.IsShowEnemyMissile()
    return LevelManager.LevelFeatureData.IsShowEnemyMissile
end


--需要显示随从
function LevelManager.IsShowRetinue()
    return LevelManager.LevelFeatureData.CanCallRetinue
end

-- 需要显示宠物
function LevelManager.CurLevelCanUsePet()
    return LevelManager.LevelType ~= LuaConst.LevelType.Resource
end

function LevelManager.IsSyncWorldBossLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncWorldBoss
end

function LevelManager.IsWarZoneWorldBossLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncWarZoneWorldBoss
end

function LevelManager.IsSyncGuildBossLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncGuildBoss
end

function LevelManager.IsSyncCountryPVPLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCountryPVP
end

function LevelManager.IsGuildWarLevelType(levelType)
    return levelType == LuaConst.LevelType.SyncGuildWarMapLeft          --军团战左战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapMiddle        --军团战中战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapRight         --军团战右战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapResources     --军团战资源战场
end

function LevelManager.IsGuildWarLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncGuildWarMapLeft          --军团战左战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapMiddle        --军团战中战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapRight         --军团战右战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapResources     --军团战资源战场
end

function LevelManager.IsSyncFairSoloTournamentLevel(levelType)
    local levelType = levelType or LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncFairSoloTournament
end

function LevelManager.IsFightThroneLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.FightThroneFirstFloor
        or levelType == LuaConst.LevelType.FightThroneSecondFloor
        or levelType == LuaConst.LevelType.FightThroneThirdFloor
end

function LevelManager.IsFightThroneTown(levelType)
    local levelType = levelType or LevelManager.LevelType
    return levelType == LuaConst.LevelType.FightThroneTown or levelType == LuaConst.LevelType.CrossFightThroneTown
end

function LevelManager.IsSceneQuizTown()
    return LevelManager.LevelType == LuaConst.LevelType.SceneQuizTown or LevelManager.LevelType == LuaConst.LevelType.SingleSceneQuizTown
end

--是否是随进随出关卡
function LevelManager.IsFreeToEnterAndLeaveLevel()
    local levelType = LevelManager.LevelType
    return LevelManager.CurLevelFunc.isFreeToEnterAndLeave
        or levelType == LuaConst.LevelType.SyncWorldBoss 
        or levelType == LuaConst.LevelType.SyncGuildBoss 
        or levelType == LuaConst.LevelType.SyncGuildWarMapLeft          --军团战左战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapMiddle        --军团战中战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapRight         --军团战右战场
        or levelType == LuaConst.LevelType.SyncGuildWarMapResources     --军团战资源战场
        or levelType == LuaConst.LevelType.SyncTestLevel                --同步测试关
        or levelType == LuaConst.LevelType.SyncWarZoneWorldBoss         --战区世界boss
        or levelType == LuaConst.LevelType.DragonArtery
        or levelType == LuaConst.LevelType.SyncCountryEveningBoss
        or levelType == LuaConst.LevelType.SyncCityWarMainFirstStage --长安争夺战主战场第1层
        or levelType == LuaConst.LevelType.SyncCityWarMainSecondStage --长安争夺战主战场第1层
        or levelType == LuaConst.LevelType.SyncCityWarSide --长安争夺战主战场第1层
end

function LevelManager.IsGuildWarWaitingArea( )
    return LevelManager.LevelType ==  LuaConst.LevelType.GuildWarWaitingArea
end

function LevelManager.IsShowHeroLifeBarLevel()
    return LevelManager.IsSyncLevel() 
            or LevelManager.IsSoloFight() 
            or LevelManager.LevelType == LuaConst.LevelType.ClimbTower
            or LevelManager.LevelType == LuaConst.LevelType.NationClimbTower
            or LevelManager.LevelType == LuaConst.LevelType.AttackCity
            or LevelManager.LevelType == LuaConst.LevelType.LootMine
            or LevelManager.LevelType == LuaConst.LevelType.NineVsNineFight
            or LevelManager.LevelType == LuaConst.LevelType.RogueLike
            or LevelManager.LevelType == LuaConst.LevelType.HeroAwakePlayer
end

--显示名字的状态同步的场景
function LevelManager.IsShowHeroNameInNoBattleLevel()
    return BattleDataGetter.IsFightThroneTown() or BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.DragonArteryWaitingArea) or BattleDataGetter.CheckCurLevelType(LuaConst.LevelType.DragonArteryRegistArea)
            or LevelManager.IsSceneQuizTown()
end


function LevelManager.IsDragonArteryLevel()
    return LevelManager.LevelType == LuaConst.LevelType.DragonArtery
end


function LevelManager.IsDragonArteryType()
    return LevelManager.LevelType == LuaConst.LevelType.DragonArtery
            or LevelManager.LevelType == LuaConst.LevelType.DragonArteryWaitingArea
            or LevelManager.LevelType == LuaConst.LevelType.DragonArteryRegistArea
end

function LevelManager.IsCountryEveningBossLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCountryEveningBoss
end

function LevelManager.IsCityWarLevel()
    return LevelManager.IsCityWarMainLevel() or LevelManager.IsCityWarSideLevel()
end

function LevelManager.IsCityWarMainLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarMainFirstStage
    or LevelManager.LevelType == LuaConst.LevelType.SyncCityWarMainSecondStage
end

function LevelManager.IsCityWarSideLevel()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarSide
end

function LevelManager.IsCityWarFirstStage()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarMainFirstStage
end

function LevelManager.IsCityWarSecondStage()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarMainSecondStage
end

function LevelManager.IsSyncCityWarMainWaitingArea()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarMainWaitingArea
end

function LevelManager.IsSyncCityWarSideWaitingArea()
    return LevelManager.LevelType == LuaConst.LevelType.SyncCityWarSideWaitingArea
end


--是否是单主将玩法
function LevelManager.IsOneHeroLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncTeamPVP 
        or levelType == LuaConst.LevelType.SyncTeamPVPPractice 
        or levelType == LuaConst.LevelType.SyncFourForce
        or levelType == LuaConst.LevelType.SyncFourCountryChaos
end
-- 是否是 选一个主将复活的关卡
function LevelManager.IsSelectOneReviveLevel()
    return LevelManager.CurLevelFunc.LevelReviveType == LuaConst.LevelReviveType.SelectOne
end
--在 选择复活的关卡中，是否显示队友头像
function LevelManager.IsShowTeammateInSelectOneReviveLevel()
    return LevelManager.CurLevelFunc.LevelReviveType == LuaConst.LevelReviveType.SelectOne and LevelManager.CurLevelFunc.ShowTeammateIcon
end
--是否是实验室关卡
function LevelManager.IsMonsterTest()
    return LevelManager.LevelType == LuaConst.LevelType.MonsterTest or LevelManager.LevelType == LuaConst.LevelType.SyncTestLevel or LevelManager.LevelType == LuaConst.LevelType.TestLevel
end

--是否是主线关卡
function LevelManager.IsNormal(  )
    return LevelManager.LevelType == LuaConst.LevelType.NORMAL
end

--是否是日常任务的副本(目前都是位面副本 2022年11月14日)
function LevelManager.IsDaily()
    return LevelManager.LevelType == LuaConst.LevelType.Planes
end

-- 是否是主播PC包
local Const_GameStreamerLevelDic = {[320501] = true,}
function LevelManager.IsGameStreamerLevel()
    return Const_GameStreamerLevelDic[persistPrivate.CurInfoData.LevelID]
end

function LevelManager.IsDigPlanes()
    return LevelManager.LevelType == LuaConst.LevelType.DigPlanes
end

function LevelManager.IsPersonalBoss()
    return LevelManager.LevelType == LuaConst.LevelType.PersonalBoss
end

function LevelManager.IsSyncTeamPVP() -- SyncUnfairTeamPVP 不要放入
    return LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVP
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamPVPPractice
            or LevelManager.LevelType == LuaConst.LevelType.SyncTeamFairChampionship    
end

--是否是官职PVE关卡
function LevelManager.IsOfficalPositionLevel()
    return LevelManager.LevelType == LuaConst.LevelType.OfficialPosition
end

function LevelManager.IsGuildPartyLevel()
    return LevelManager.LevelType == LuaConst.LevelType.GuildPartyMap
end

function LevelManager.IsDemonGodLevel()
    return LevelManager.LevelType == LuaConst.LevelType.DemonGod
end

--是否是突破被动生效的关卡类型
function LevelManager.IsDevelopEffectLevel()
    return not LevelManager.IsNoBattleLevel()
        and not LevelManager.IsResourceLevel()      --策划要求资源关不要加培养buff（2021年9月13日）
        --and not LevelManager.LevelType == LuaConst.LevelType.Biography --武将列传是替换阵容的，无法使用突破被动
        --and not LevelManager.IsMonsterTest() --实验室无法使用突破被动
end
--是否是单机战斗关卡
local StandaloneBattleLevelDic = {
    [LuaConst.LevelType.NORMAL] = true,
    [LuaConst.LevelType.FairNormalPVE] = true,
    [LuaConst.LevelType.BossChallenge] = true,
    [LuaConst.LevelType.SubjectMonthBossChallenge] = true,
    [LuaConst.LevelType.Planes] = true,
    [LuaConst.LevelType.DigPlanes] = true,
    [LuaConst.LevelType.Biography] = true,
    [LuaConst.LevelType.ClimbTower] = true,
    [LuaConst.LevelType.NationClimbTower] = true,
    [LuaConst.LevelType.SoloFight] = true,
    [LuaConst.LevelType.Resource] = true,
    [LuaConst.LevelType.OfficialPosition] = true,
    [LuaConst.LevelType.Nobility] = true,
    [LuaConst.LevelType.GoldHeroExperience] = true,
    [LuaConst.LevelType.GoldHeroCooperate] = true,
    [LuaConst.LevelType.DigNormal] = true,
    [LuaConst.LevelType.AdvancedDigNormal] = true,
    [LuaConst.LevelType.PersonalBoss] = true,
    [LuaConst.LevelType.GoldHeroTrail] = true,
    [LuaConst.LevelType.AttackCity] = true,
    [LuaConst.LevelType.StormChallenge] = true,
    [LuaConst.LevelType.LootMine] = true,
    [LuaConst.LevelType.NineVsNineFight] = true,
    [LuaConst.LevelType.ExpelMonster] = true,
    [LuaConst.LevelType.SlgGvE] = true,
    [LuaConst.LevelType.HeroAwakeBoss] = true,
    [LuaConst.LevelType.HeroAwakePlayer] = true,
    [LuaConst.LevelType.RogueLike] = true,
}
function LevelManager.IsStandaloneBattleLevel()
    local levelType = LevelManager.LevelType
    if levelType == nil then
        return false
    end
    --【注意】这里的levelType在正常登录进入游戏时会为nil
    return StandaloneBattleLevelDic[levelType] == true
end

-- 不需要功能：“ 没有锻铸的情况下，使用默认锻铸点 ”  的关卡
function LevelManager.IsNotDefaultFoundryLevel()
    return LevelManager.LevelType == LuaConst.LevelType.RogueLike
end

function LevelManager.IsGoldHeroTrail()
    return LevelManager.LevelType == LuaConst.LevelType.GoldHeroTrail
end

function LevelManager.IsBossChallenge() 
    return LevelManager.LevelType == LuaConst.LevelType.BossChallenge
end

function LevelManager.IsRogueLike()
    return LevelManager.LevelType == LuaConst.LevelType.RogueLike
end

--是否是资源关
function LevelManager.IsResourceLevel()
    return LevelManager.LevelType == LuaConst.LevelType.Resource
end

--是否是金将体验关
function LevelManager.IsGoldHeroExperience()
    return LevelManager.LevelType == LuaConst.LevelType.GoldHeroExperience
end
--是否是金将协同关
function LevelManager.IsGoldHeroCooperate()
    return LevelManager.LevelType == LuaConst.LevelType.GoldHeroCooperate
end

function LevelManager.IsFourCountry()
    return LevelManager.LevelType == LuaConst.LevelType.SyncFourCountryChaos
end

function LevelManager.IsForbidPlayerInputLevel()
    return LevelManager.CurLevelFunc.isForbidPlayerInput
end

--是否是觉醒副本最终试炼（打玩家的关卡）
function LevelManager.IsHeroAwakePlayerLevel()
    return LevelManager.LevelType == LuaConst.LevelType.HeroAwakePlayer
end

function LevelManager.HasLoadedData()
    return persistPrivate.CurInfoData and LevelManager._levelLogicData.LogicLoadingStep == LuaConst.Enum_LoadingStep.None
end

--是否大型PVP关卡，做一些性能优化的特殊处理
function LevelManager.IsMassivePvPLevel()
    return LevelManager.LevelFeatureData and LevelManager.LevelFeatureData.PsLODSetting == 1001
end

--是否有后续关卡（有后续关卡的，当前关卡一般不结算，比如组队副本）
function LevelManager.HasNextLevel()
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.NextLevelID > 0
end

function LevelManager.GetNextLevelID()
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.NextLevelID or -1
end

function LevelManager.GetSwitchHeroCD()
    return private.switchHeroCd
end

function LevelManager.ShouldAddCanUseSkillToHeroWhenBorn()
    return LevelManager.CurLevelFunc:ShouldAddCanUseSkillToHeroWhenBorn()
end

function LevelManager.LevelTotalTime()
    return persistPrivate.CurInfoData and persistPrivate.CurInfoData.Timer
end

function LevelManager.HandleServerAction(entity, command)
    if LevelManager.IsSyncLevel() then
        return LevelManager.CurLevelFunc:HandleServerAction(entity, command)
    else
        logging.error(LTAG.ERROR, "HYW : 目前只有同步关卡才能执行服务器插帧！  如果单机玩法也需要，请联系战斗程序！")
    end
end

-- Entity:initialized() 之后
function LevelManager.OnEntityBorn(entity)
    LevelManager.CurLevelFunc:OnEntityBorn(entity)
end

function LevelManager.OnSwitchHero(fromEntity,toEntity)
    LevelManager.CurLevelFunc:OnSwitchHero(fromEntity,toEntity)
    LevelItemManager.Global:ResetComboNumber()
end

function LevelManager.AfterSwitchHero(fromEntity, toEntity, dontBackground)
    LevelManager.CurLevelFunc:AfterSwitchHero(fromEntity, toEntity, dontBackground)
end

function LevelManager:OnFightModeChanged(entity,fightMode)
    LevelManager.CurLevelFunc:OnFightModeChanged(entity,fightMode)
end

function LevelManager.OnOffLine(playerID)
    LevelManager.CurLevelFunc:OnOffLine(playerID)
end

function LevelManager.OnReconnect(playerID)
    LevelManager.CurLevelFunc:OnReconnect(playerID)
end

function LevelManager.OnPlayerFirstOnline(playerID)
    LevelManager.CurLevelFunc:OnPlayerFirstOnline(playerID)
end

function LevelManager.CountBornPoint()
    LevelManager.bornPointCount = LevelItemManager.GetItemCountByType(LuaConst.LevelItemType.BornPoint)
end

--设置 是需要校验的非同步关卡
function LevelManager.SetNeedCheckNotSyncLevel(value)
    private.needCheckNotSyncLevel = value
end
--是需要校验的非同步关卡
function LevelManager.IsNeedCheckNotSyncLevel()
    return private.needCheckNotSyncLevel or LevelManager.LevelType == LuaConst.LevelType.BossChallenge 
            or LevelManager.LevelType == LuaConst.LevelType.SubjectMonthBossChallenge -- boss挑战由于要回放，故一定要确保一致性的 。
end
function LevelManager.IsServerNeedCheckNotSyncLevel()
    return private.needCheckNotSyncLevel
end

--设置 是进入观战模式
function LevelManager.SetIsInLevelWatchBattle(value)
    private.IsInLevelWatchBattle = value
end
--是观战中
function LevelManager.IsInLevelWatchBattle()
    return private.IsInLevelWatchBattle
end

--设置 是进入回放模式
function LevelManager.SetIsReplayBattle(value)
    persistPrivate.IsReplayBattle = value
end
--是回放中
function LevelManager.IsReplayBattle()
    return persistPrivate.IsReplayBattle
end

--是回放中，切换关卡记录，用于埋点统计
function LevelManager.IsReplayRecordInSwitchLevel()
    return private.IsReplayRecordInSwitchLevel
end

function LevelManager.RecordFrameCmd(frame, moveType, dirX, dirZ, skillIndex, specCmd, useJoyStick, skillJoystickPosX, skillJoystickPosZ)
    local index = #persistPrivate.recordFrameCmdArray
    persistPrivate.recordFrameCmdArray[index + 1] = frame
    persistPrivate.recordFrameCmdArray[index + 2] = moveType
    persistPrivate.recordFrameCmdArray[index + 3] = dirX
    persistPrivate.recordFrameCmdArray[index + 4] = dirZ
    persistPrivate.recordFrameCmdArray[index + 5] = skillIndex
    persistPrivate.recordFrameCmdArray[index + 6] = specCmd
    persistPrivate.recordFrameCmdArray[index + 7] = useJoyStick
    persistPrivate.recordFrameCmdArray[index + 8] = skillJoystickPosX
    persistPrivate.recordFrameCmdArray[index + 9] = skillJoystickPosZ
end

function LevelManager.GetRecordFrameCmds()
    local str = Infrast.EncodeToBytes(persistPrivate.recordFrameCmdArray)
    return str
end

--需要统计帧和帧内命令的关卡(需要服务器支持且结算协议处也要加代码)
function LevelManager.NeedStatisticFrameCmdLevel()
    local levelType = LevelManager.LevelType
    return levelType == LuaConst.LevelType.SyncGuildWarMapLeft          --军团战左战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapMiddle        --军团战中战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapRight         --军团战右战场
            or levelType == LuaConst.LevelType.SyncGuildWarMapResources     --军团战资源战场
            or levelType == LuaConst.LevelType.FightThroneFirstFloor
            or levelType == LuaConst.LevelType.FightThroneSecondFloor
            or levelType == LuaConst.LevelType.FightThroneThirdFloor
end

function LevelManager.CurLevelCanSwitchHeroByCmd(fromEntity, index)
    return LevelManager.CurLevelFunc:CurLevelCanSwitchHeroByCmd(fromEntity, index)
end

--是否是单人高级藏宝洞（最后会从水、土、木三种箱子里选一个的那种挖宝副本）
function LevelManager.IsAdvancedDigNormal()
    return LevelManager.LevelType == LuaConst.LevelType.AdvancedDigNormal or  LevelManager.LevelType == LuaConst.LevelType.DigNormal
end
return LevelManager