RoApp/Assets/Lua/Logic/ClimbingTower/ClimbingTowerDataMgr.lua

local ClimbingTowerDataMgr = class("ClimbingTowerDataMgr",require("DataBase"))
local ClimbingTowerLevelData = require("ClimbingTower/ClimbingTowerLevelData")
local ClimbingTowerRankData = require("ClimbingTower/ClimbingTowerRankData")

function ClimbingTowerDataMgr:ctor()
    self.curChallengeLevel = 1          --当前需要挑战的关卡
    self.lastPassedTime = 0
    self.levels = nil
    self.ranks = nil
    self.rankPlayerIds = nil
    self.showLevels = nil
    self.selfRank = 10000
    self.requested = false
    self.curMaxFightingTime = 0
    self.curEnterBattleTime = 0
    self.battleEndCondList = nil
    self.bInited = false
    self.towerMode = 0 -- 0 原来的模式   1 无尽模式
    self.wjLevel = 1
    self.wjBossInfo = nil
    self.wjRewordCfg = nil
end

function ClimbingTowerDataMgr:Clear()
    self.bInited = false
    self.requested = false
    self.levels = nil
    self.ranks = nil
    self.rankPlayerIds = nil
    self.showLevels = nil
    self.battleEndCondList = nil

    self.changeTowerState = nil
end

function ClimbingTowerDataMgr:RegisterNetEvents()
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_INFO_ACK,self.OnClimbingTowerInfoAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_FRIEND_PASS_TOWER_INFO_ACK,self.OnTowerFriendPassTowerInfoAck,self)
   -- ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_TOWER_LEVEL_MIN_FIGHT_POWER_NTF,self.OnTowerLevelMinFightPowerNtf,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_BEGIN_ACK,self.OnClimbingTowerBeginAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_END_ACK,self.OnClimbingTowerEndAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_RANK_ACK,self.OnClimbingTowerRankAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_DAY_REWARD_ACK,self.OnClimbingTowerDayRewardAck,self)
   
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_WJ_BEGIN_ACK,self.OnWjBeginAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_WJ_END_ACK,self.OnWjEndAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_WJ_RANK_ACK,self.OnWjRankAck,self)
    ManagerContainer.NetManager:NetRegister(ProtoMsgId.SC_CLIMBING_TOWER_WJ_BOSS_NTF,self.OnWjBossNtf,self)


    ManagerContainer.LuaEventMgr:RegisterEvent(UIEventNames.EID_SC_GET_OTHER_PLAYER_BRIEF_INFO_ACK,self,self.OnGetRankBriefInfoAck)
end

function ClimbingTowerDataMgr:UnRegisterNetEvents()
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_INFO_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_FRIEND_PASS_TOWER_INFO_ACK)
    --ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_TOWER_LEVEL_MIN_FIGHT_POWER_NTF)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_BEGIN_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_END_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_RANK_ACK)
    
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_WJ_BEGIN_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_WJ_END_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_WJ_RANK_ACK)
    ManagerContainer.NetManager:UnRegisterPbIdCallback(ProtoMsgId.SC_CLIMBING_TOWER_WJ_BOSS_NTF)

    ManagerContainer.LuaEventMgr:UnregisterEvent(UIEventNames.EID_SC_GET_OTHER_PLAYER_BRIEF_INFO_ACK,self,self.OnGetRankBriefInfoAck);
end

function ClimbingTowerDataMgr:InitData()
    if self.bInited then
        return
    end

    self.levels = {}
    local cfgList = ManagerContainer.CfgMgr:GetClimbingTowerCfg()
    if cfgList ~= nil then
        for i = 1, #cfgList do
            self.levels[#self.levels+1] = ClimbingTowerLevelData:new(cfgList[i])
        end
    end
    self:SortLevelList()
    self.bInited = true
end

function ClimbingTowerDataMgr:SetShowLevels()
    self.showLevels = {}

    local maxLevel = self.curChallengeLevel + 4
    if maxLevel > #self.levels then
        maxLevel = #self.levels
    end

    for i = 1, maxLevel do
        local level = self:FindLevelData(i)
        level:SetPassed(level.levelId<self.curChallengeLevel)
        self.showLevels[#self.showLevels+1] = level
    end
end

function ClimbingTowerDataMgr:GetShowLevels()
    return self.showLevels
end

function ClimbingTowerDataMgr:SortLevelList()
    if self.levels == nil or #self.levels < 2 then
        return
    end

    table.sort(
        self.levels,
        function(a, b)
            return a.levelId > b.levelId
        end
    )
end

function ClimbingTowerDataMgr:ChangeData()

    ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_REFRESH_CLIMBINGTOWER_DATA);
end

function ClimbingTowerDataMgr:GetLevels()
    return self.levels
end

function ClimbingTowerDataMgr:FindLevelData(levelId)
    if self.levels == nil then
        return nil
    end

    for i = 1,#self.levels do
        local level = self.levels[i]
        if level.levelId == levelId then
            return level
        end
    end

    return nil
end

--function ClimbingTowerDataMgr:FindLevelIsPassed(LevelId)
function ClimbingTowerDataMgr:FindLevelIsPassed()
    --local lvData = self:FindLevelData(levelId)
    --if(lvData) then
        --return lvData.hasPassed
       
    --end
    --return false
    --LogError("================ curChallengeLevel =  "..self.curChallengeLevel.."   ========================")
    return self.curChallengeLevel >= self:GetTopTowerUnlockLv()  --true --
end

function ClimbingTowerDataMgr:FindRankerData(uid)
    if self.ranks == nil then
        return nil
    end

    for i=1, #self.ranks do
        if self.ranks[i].playerId == uid then
            return self.ranks[i]
        end 
    end

    return nil
end

function ClimbingTowerDataMgr:GetCurChallengeLevel()
    return self.curChallengeLevel
end

function ClimbingTowerDataMgr:GetRankList()
    return self.ranks
end

function ClimbingTowerDataMgr:GetCurrentLevelInfo()
    return self:FindLevelData(self.curChallengeLevel) 
end

function ClimbingTowerDataMgr:SendClimbingTowerInfoReq(changeTower)
    if self.requested then
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_CHANGE_TOWER_SHOW_REFRESH, changeTower)
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_REFRESH_CLIMBINGTOWER_DATA)
        return
    end
    self.changeTowerState = changeTower
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_INFO_REQ, {})
end

function ClimbingTowerDataMgr:InitClimbingTowerInfo(data)
    self.curChallengeLevel = data.now_tower_level + 1
    self.lastPassedTime = data.now_tower_time
    self.dayRewardTime = data.tower_level_day_reward_time
end

function ClimbingTowerDataMgr:OnClimbingTowerDayRewardAck(data)
    if data.error == 0 then
        self.dayRewardTime = data.next_day_reward_time
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.REFRESH_CLIMBINGTOWER_DAYREWARD,data.reward_list)
    end
end
function ClimbingTowerDataMgr:GetDayRewardTime()
    return self.dayRewardTime and (type(self.dayRewardTime) == "number" and self.dayRewardTime or #self.dayRewardTime) or 0
end

function ClimbingTowerDataMgr:OnClimbingTowerDayRewardREQ()
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_DAY_REWARD_REQ)
end

function ClimbingTowerDataMgr:OnClimbingTowerInfoAck(data)
    self:InitData()
    self.curChallengeLevel = data.now_tower_level + 1
    self.lastPassedTime = data.pass_time
    if data.infos ~= nil then
        for i = 1, #data.infos do
            local  friendTowerInfo = data.infos[i]
            local levelInfo = self:FindLevelData(friendTowerInfo.tower_level)
            if levelInfo ~= nil then
                levelInfo:SetFriendData(friendTowerInfo.infos)
            end
        end
    end
    self:SetShowLevels()
    ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_CHANGE_TOWER_SHOW_REFRESH, self.changeTowerState)
    ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_REFRESH_CLIMBINGTOWER_DATA)
    self.requested = true
end

function ClimbingTowerDataMgr:SendFriendPassTowerInfoReq(beginIdx,endIdx)
    -- LogError("SendFriendPassTowerInfoReq:" .. beginIdx .. "---" .. endIdx) 
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_FRIEND_PASS_TOWER_INFO_REQ, {begin_index=beginIdx,end_index=endIdx})
end

function ClimbingTowerDataMgr:OnTowerFriendPassTowerInfoAck(data)
    -- LogError("OnTowerFriendPassTowerInfoAck:" .. Inspect(data))
    if data.infos ~= nil then
        local levelIds = {}
        for i = 1, #data.infos do
            local  friendTowerInfo = data.infos[i]
            local levelInfo = self:FindLevelData(friendTowerInfo.tower_level)
            if levelInfo ~= nil then
                levelInfo:SetFriendData(friendTowerInfo.infos)
                levelIds[#levelIds+1] = friendTowerInfo.tower_level
            end
        end

        if #levelIds > 0 then
            ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_Refresh_ClimbingTower_FriendInfo,levelIds)
        end
    end
end

function ClimbingTowerDataMgr:OnTowerLevelMinFightPowerNtf(data)
    -- LogError("OnTowerLevelMinFightPowerNtf:" .. Inspect(data))
    if data.min_tower_info ~= nil then
        for i=1, #data.min_tower_info do
            local info = data.min_tower_info[i]
            local levelInfo = self:FindLevelData(info.tower_level)
            if levelInfo ~= nil then
                levelInfo:SetLowestPlayerInfo(info.brief,info.fight_power,info.record_time,info.battle_time)
            end
        end
    end
end

function ClimbingTowerDataMgr:SendClimbingTowerBeginReq(towerLevel)
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_BEGIN_REQ, {tower_level = towerLevel})
end

function ClimbingTowerDataMgr:OnClimbingTowerBeginAck(data)
    -- LogError("OnClimbingTowerBeginAck:" .. Inspect(data))
    if data.error == 0 then
       self:EnterBattle(data.tower_level,data.factor_list)
    end
end

function ClimbingTowerDataMgr:SendClimbingTowerEndReq(loadingTime,towerLevel,timeStamp)
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_END_REQ, {loading_time = loadingTime, tower_level = towerLevel,record_time_stamp = timeStamp})
end

function ClimbingTowerDataMgr:OnClimbingTowerEndAck(data)
    -- LogError("OnClimbingTowerEndAck:" .. Inspect(data))
    if data.error == 0 then
        local levelInfo = self:GetCurrentLevelInfo()
        if data.reward_list ~= nil then
            local rewards = {}
            for i = 1, #data.reward_list do
                local itemData = data.reward_list[i];
                rewards[#rewards+1] = {itemData.key, itemData.value,0}
            end

            if data.ex_reward_list  ~= nil then
                for i =1, #data.ex_reward_list do
                    local itemData = data.ex_reward_list[i];
                    rewards[#rewards+1] = {itemData.key, itemData.value,1}
                end
            end

            ManagerContainer.LuaUIMgr:Open(Enum.UIPageName.UIClimbingTowerBattleWin,{Enum.UIPageName.UIClimbingTower,rewards})
        else
            ManagerContainer.LuaUIMgr:Open(Enum.UIPageName.UIClimbingTowerBattleWin,{Enum.UIPageName.UIClimbingTower,nil})
        end

        self.curChallengeLevel = data.tower_level + 1
        if data.pass_time ~= nil then
            self.lastPassedTime = data.pass_time
        end

        if data.pass_info ~= nil then
            local levelInfo = self:FindLevelData(data.pass_info.tower_level)
            if levelInfo ~= nil then
                levelInfo:SetFriendData(data.pass_info.infos)
            end
        end
        self:SetShowLevels()
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_REFRESH_CLIMBINGTOWER_DATA)

        ManagerContainer.DataMgr.RankActivitiesMgr:QueryCurRankActivityData(Enum.RankActivitiesType.ClimbingTower)
    else
        ManagerContainer.LuaUIMgr:Open(Enum.UIPageName.UIClimbingTowerBattleFailed,Enum.UIPageName.UIClimbingTower)
    end
end

function ClimbingTowerDataMgr:SendClimbingTowerRankReq()
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_RANK_REQ, {})
end

function ClimbingTowerDataMgr:OnClimbingTowerRankAck(data)
    -- LogError("OnClimbingTowerRankAck:" .. Inspect(data))
    if data.error == 0 then
        self.ranks = {}
        self.rankPlayerIds = {}
        for i = 1, #data.rank_list do
            local player = ClimbingTowerRankData:new(data.rank_list[i].key,data.rank_list[i].value)
            self.ranks[#self.ranks+1] = player
            self.rankPlayerIds[#self.rankPlayerIds+1] = data.rank_list[i].key
        end
        self.selfRank = data.self_rank

        local uid_list = self:GetRankUidList(10)
        self:ReqTowerRankBriefData(uid_list)
    else
        self.ranks = nil
    end
    ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_Refresh_ClimbingTower_RankData)
end

function ClimbingTowerDataMgr:ReqTowerRankBriefData(uids)
    if uids == nil or #uids == 0 then
        return
    end

    -- LogError("ClimbingTowerDataMgr : " .. Inspect(uids))
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_GET_OTHER_PLAYER_BRIEF_INFO_REQ, {type=Enum.FriendTogglePageType.ClimbingTower, player_list=uids})
end

function ClimbingTowerDataMgr:OnGetRankBriefInfoAck(data)
    -- LogError("OnGetRankBriefInfoAck:" .. Inspect(data))
    if data.type == Enum.FriendTogglePageType.ClimbingTower then
        if data.brief_info ~= nil then
            for i = 1,#data.brief_info do
                local info = data.brief_info[i]
                local ranker = self:FindRankerData(info.uid)
                if ranker ~= nil then
                    ranker:SetRankData(info)
                end
                self:RemoveTempRankerId(info.uid)
            end
        end
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_Refresh_ClimbingTower_RankDetailData)
    end
end

function ClimbingTowerDataMgr:RemoveTempRankerId(uid)
    if self.rankPlayerIds == nil then
        return
    end

    for i = 1, #self.rankPlayerIds do
        if self.rankPlayerIds[i] == uid then
            table.remove(self.rankPlayerIds,i)
            return
        end
    end
end

function ClimbingTowerDataMgr:GetRankUidList(cnt)
    local uids = {}
    if self.rankPlayerIds ~= nil then
        if cnt > #self.rankPlayerIds then
            cnt = #self.rankPlayerIds
        end
        for i = 1, cnt do
            uids[#uids+1] = self.rankPlayerIds[i]
        end
    end
    return uids
end

function ClimbingTowerDataMgr:InitEndBattleCondition()
    if self.battleEndCondList ~= nil then
        return
    end

    self.battleEndCondList = System.Array.CreateInstance(Enum.TypeInfo.BattleEndCondition, 2)
    self.battleEndCondList[0] = BattleEndCondition.New(Constants.EndBattle_By_UndeadCount,Constants.ResultType_Normal)
    self.battleEndCondList[1] = BattleEndCondition.New(Constants.EndBattle_By_BattleTime,Constants.ResultType_Normal)
end

function ClimbingTowerDataMgr:EnterBattle(towerLevel,factorList)
    local levelInfo = self:FindLevelData(towerLevel)
    if levelInfo ~= nil then
        local teams = ManagerContainer.DataMgr.UserData:GetTeamData(true);
        if teams ~= nil then 
            ManagerContainer.LuaGameMgr:SetTeamData(teams,{false})
        end   
        ManagerContainer.LuaGameMgr:RefreshTeamData()
        self.curMaxFightingTime = levelInfo.maxFightingTime
        local curOurActors = {}
        local curEnemyActors = {}
        local teams = ManagerContainer.DataMgr.UserData:GetTeamData(true)
        if teams ~= nil then 
            --会有技能 没有即使更新 此处同步属性 
            ManagerContainer.LuaGameMgr:SetTeamData(teams,{true})
            --打印
            for i = 1, #teams do                
                Log("ClimbingTowerDataMgr EnterBattle RoleID = "..tostring(teams[i].uid))
                Log("Pet Id"..tostring(petId))
                local Skills = teams[i].skills
                for i = 1, #Skills do
                    local skillId = Skills[i].skillId
                    local petId = Skills[i].petId
                    Log("Role Skill"..tostring(skillId))                    
                end
            end
        end   
        local ourActors = System.Array.CreateInstance(Enum.TypeInfo.ActorData, #teams)
        for i = 1 , #teams do
            local actor = ManagerContainer.LuaActorDataMgr:GetActorsById(teams[i].uid,teams[i].id)
            --增加对应压制mark
            ManagerContainer.DataMgr.UserData:SetActorPveMark(teams[i].uid,actor)
            ourActors[i-1] = actor
            curOurActors[#curOurActors+1] = actor
        end

        local enemyActors = System.Array.CreateInstance(Enum.TypeInfo.ActorData, #levelInfo.npcs)
        for i = 1, #levelInfo.npcs do
            local npcInfo = levelInfo.npcs[i]
			local actor = ManagerContainer.LuaActorDataMgr:CreateNpc(10000+i,npcInfo.npcId,npcInfo.npcPos,npcInfo.npcLevel)
            if actor ~= nil then
                actor.IsBoss = npcInfo.isBoss
                enemyActors[i-1] = actor
                curEnemyActors[#curEnemyActors+1] = actor
			end
        end

        local battleFactors = System.Array.CreateInstance(Enum.TypeInfo.ValType, #factorList)
        for i = 1, #factorList do
            local factor = ValType.New(factorList[i].key,factorList[i].value)
            battleFactors[i-1] = factor
        end
        
        self.curEnterBattleTime = Time.realtimeSinceStartup

        self.isPlayRecord = false
        self:InitEndBattleCondition()
        ManagerContainer.LuaGameMgr:EnterClimbingTowerBattle(levelInfo.sceneName,levelInfo.bgmName,levelInfo.maxFightingTime,ourActors,enemyActors,self.battleEndCondList,nil,battleFactors)
    end
end

function ClimbingTowerDataMgr:ReplayBattle(towerLevel,battleRecordStr,replayername)
    local levelInfo = self:FindLevelData(towerLevel)
    if levelInfo == nil then
        return
    end   
    self.isPlayRecord = true
    self.recordLevelId = towerLevel
    ManagerContainer.LuaGameMgr:EnterClimbingTowerBattle(levelInfo.sceneName,levelInfo.bgmName,levelInfo.maxFightingTime,nil,nil,nil,battleRecordStr,nil,replayername)
end

function ClimbingTowerDataMgr:IsPlayRecord()
    return self.isPlayRecord,self.recordLevelId
end


function ClimbingTowerDataMgr:GetCurrentMaxFightingTime()
    return self.curMaxFightingTime
end

function ClimbingTowerDataMgr:BattleEnd(battleTime,isPlayRecord,timeStamp)
    if self.isPlayRecord then
        ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.EID_SHUT_TIMEBATTLE,Enum.UIPageName.UIClimbingTower)
        return
    end
    if self:GetTowerMode() == 2  then
        LogError("無盡模式！！")
        --self.wjLevel = self.wjLevel + 1
        --ManagerContainer.LuaUIMgr:Open(Enum.UIPageName.UIClimbingTowerBattleWin,{Enum.UIPageName.UIClimbingTower,nil})
        self:SendWjEndReq(battleTime,self.wjLevel,timeStamp)
        return
    end
    self:SendClimbingTowerEndReq(battleTime,self.curChallengeLevel,timeStamp)
end

function ClimbingTowerDataMgr:EnterBattle_WJ(towerLevel, factorList)
    local scenceName = "scene_climbingtower"
    local bgmName = "bgm_08"
    local wjinfo = self:GetCurWJTowerInfo()
    local NpcList = wjinfo.npcList
    local maxFight = 120

    --local levelInfo = self:FindLevelData(towerLevel)

    local teams = ManagerContainer.DataMgr.UserData:GetTeamData(true);
    if teams ~= nil then
        ManagerContainer.LuaGameMgr:SetTeamData(teams, {false})
    end
    ManagerContainer.LuaGameMgr:RefreshTeamData()
    self.curMaxFightingTime = maxFight
    local curOurActors = {}
    local curEnemyActors = {}
    local teams = ManagerContainer.DataMgr.UserData:GetTeamData(true)
    if teams ~= nil then
        -- 会有技能 没有即使更新 此处同步属性 
        ManagerContainer.LuaGameMgr:SetTeamData(teams, {true})
        -- 打印
        for i = 1, #teams do
            Log("ClimbingTowerDataMgr EnterBattle RoleID = " .. tostring(teams[i].uid))
            Log("Pet Id" .. tostring(petId))
            local Skills = teams[i].skills
            for i = 1, #Skills do
                local skillId = Skills[i].skillId
                local petId = Skills[i].petId
                Log("Role Skill" .. tostring(skillId))
            end
        end
    end
    local ourActors = System.Array.CreateInstance(Enum.TypeInfo.ActorData, #teams)
    for i = 1, #teams do
        local actor = ManagerContainer.LuaActorDataMgr:GetActorsById(teams[i].uid, teams[i].id)
        -- 增加对应压制mark
        ManagerContainer.DataMgr.UserData:SetActorPveMark(teams[i].uid, actor)
        ourActors[i - 1] = actor
        curOurActors[#curOurActors + 1] = actor
    end
    local cfg = self:GetWjRewordCfgByLv(self.wjLevel)
    local buffValue = self:GetWjBossbuffValueByCfg(cfg)

    local enemyActors = System.Array.CreateInstance(Enum.TypeInfo.ActorData, #NpcList)
    for i = 1, #NpcList do
        local npcInfo = NpcList[i]
        local actor = ManagerContainer.LuaActorDataMgr:CreateNpc(10000 + i, npcInfo.npcId, npcInfo.npcPos,
            npcInfo.npcLevel)
        if actor ~= nil then
            actor.IsBoss = npcInfo.isBoss
            if buffValue > 0 then
                ManagerContainer.LuaBattleMgr:AddBuffToActor_New(actor,true,self:CreateBossBuffcfg(buffValue))
            end
            enemyActors[i - 1] = actor
            curEnemyActors[#curEnemyActors + 1] = actor
        end
    end

    local battleFactors = System.Array.CreateInstance(Enum.TypeInfo.ValType, #factorList)
    for i = 1, #factorList do
        local factor = ValType.New(factorList[i].key, factorList[i].value)
        battleFactors[i - 1] = factor
    end

    self.curEnterBattleTime = Time.realtimeSinceStartup

    self.isPlayRecord = false
    self:InitEndBattleCondition()
    ManagerContainer.LuaGameMgr:EnterClimbingTowerBattle(scenceName, bgmName, maxFight, ourActors, enemyActors,
        self.battleEndCondList, nil, battleFactors)

end

function ClimbingTowerDataMgr:CreateBossBuffcfg(value)
    return {buffEffect = {{6,value}}}        
end

function ClimbingTowerDataMgr:CreateNpcList(npclist, lv)
    local ClimbingTowerNpcData = require("ClimbingTower/ClimbingTowerNpcData")
    local npcs = {}
    for i = 1, #npclist, 1 do
        npcs[#npcs + 1] = ClimbingTowerNpcData:new(npclist[i], lv)
    end
    return npcs
end


function ClimbingTowerDataMgr:GetTowerMode()
    if self.towerMode  == nil then
        self.towerMode = 0
    end
    return self.towerMode 
end

function ClimbingTowerDataMgr:SetTowerMode(mode)
    self.towerMode = mode
end


function  ClimbingTowerDataMgr:GetCurWJTowerInfo()
    local info = {}
    local npclv = math.floor(self.wjLevel*6.7 + 0.5)
    info.npcList = self:CreateNpcList({{70001, 1}, {70006, 4}, {70001, 3}, {70001, 2}}, npclv)
    info.lv = self.wjLevel
    return info
end

function ClimbingTowerDataMgr:GetTopTowerUnlockLv()
    return 1001
end
function ClimbingTowerDataMgr:GetWjTowerUnlockLv()
    return 1001
end
function ClimbingTowerDataMgr:GetWjIsUnlock()
    return true
end

function ClimbingTowerDataMgr:GetModelockInfo(mode)
    local lockInfo ={isunlock = true, unlockLv = 0} 

    if mode == 1 then
        lockInfo.isunlock = self:FindLevelIsPassed()
        lockInfo.unlockLv = self:GetTopTowerUnlockLv()
    elseif mode == 2 then
        lockInfo.isunlock  = self:GetWjIsUnlock()
        lockInfo.unlockLv = self:GetWjTowerUnlockLv()
    end
    return lockInfo
end

function ClimbingTowerDataMgr:GetCurWjLevel()
    return self.wjLevel
end

function ClimbingTowerDataMgr:SetCurWjLevel(lv)
    self.wjLevel = lv
end

function ClimbingTowerDataMgr:GetWjRewordCfgByLv(lv)
    local cfgmgr = ManagerContainer.CfgMgr
    local cfg = nil
    if self.wjRewordCfg and cfgmgr:LevelISWjRewordCfg(self.wjRewordCfg,lv) then
        cfg = self.wjRewordCfg
    else
        cfg = cfgmgr:GetWjRewordByLv(lv)        
    end

    return cfg
end

function ClimbingTowerDataMgr:GetWjRewordByLv(lv)
    local cfg = self:GetWjRewordCfgByLv(lv)
   
    local maxLv = cfg.levels[1][2]
    local minLv = cfg.levels[1][1]
    -- {cfgId = reward[1], num = reward[2]}
    local reword = {}
    for _, v in pairs(cfg.reward) do
        local item = {cfgId = v[1], num = v[2]}
    
        reword[item.cfgId] = item
    end

    for _, v in pairs(cfg.levelReward) do
        local item = {cfgId = v[1], num = v[2]}
        local num = (lv - minLv) * item.num
        if reword[item.cfgId] == nil then
            item.num = num
            reword[item.cfgId] = item
        else
            local  temp =  reword[item.cfgId]
            temp.num = temp.num + num      
        end
    end
    local ret = {}
    for _, v in pairs(reword) do
        table.insert(ret,v)
    end
    return ret
end
function ClimbingTowerDataMgr:GetCurWjReword()
    return self:GetWjRewordByLv(self.wjLevel)
end
function ClimbingTowerDataMgr:GetCurSpecialReword(isShow)
    local cfg = self:GetWjRewordCfgByLv(self.wjLevel)
    if isShow then
        return ManagerContainer.CfgMgr:GetReward(cfg.specialReward)
    end
    return cfg.specialReward
end

function ClimbingTowerDataMgr:GetWjBossbuffValueByCfg(cfg)
    local minLv = cfg.levels[1][1]
    local num = cfg.basicDF
    num = num + cfg.incrementalDf * (self.wjLevel - minLv)
    return num
end

-- =================================无尽协议===================================

function ClimbingTowerDataMgr:SendWjBeginReq()
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_WJ_BEGIN_REQ, {tower_level=self.wjLevel})
end
function ClimbingTowerDataMgr:OnWjBeginAck(data)
    LogError("OnWjBeginAck ----- " ..Inspect(data))
    self:EnterBattle_WJ(data.tower_level,{})
end


function ClimbingTowerDataMgr:SendWjEndReq(loadingTime,towerLevel,timeStamp)
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_WJ_END_REQ, {loading_time = loadingTime, tower_level = towerLevel,record_time_stamp = timeStamp})
end
function ClimbingTowerDataMgr:OnWjEndAck(data)
    LogError("OnWjEndAck ----- " ..Inspect(data))
    ManagerContainer.LuaUIMgr:Open(Enum.UIPageName.UIClimbingTowerBattleWin,{Enum.UIPageName.UIClimbingTower,nil})
end

function ClimbingTowerDataMgr:SendWjRankReq()
    ManagerContainer.NetManager:SendMessage(ProtoMsgId.CS_CLIMBING_TOWER_WJ_RANK_REQ, {})
end
function ClimbingTowerDataMgr:OnWjRankAck(data)
    LogError("OnWjRankAck ----- " ..Inspect(data))
end

function ClimbingTowerDataMgr:OnWjBossNtf(data)
    LogError("OnWjBossNtf ----- " ..Inspect(data))
    self.wjBossInfo = {}
    self.wjLevel = data.wj_level
   for i = 1, 4, 1 do
        local boss = {data["boss"..i] ,i}
        table.insert(self.wjBossInfo,boss)
   end
end
-- =================================无尽协议===================================

function ClimbingTowerDataMgr:GetCurWjLevel()
    return self.wjLevel
end

function ClimbingTowerDataMgr:GetCurBattleBuffInfo()
    if self.wjBattleBuffInfo == nil then
        self.wjBattleBuffInfo = 
        {
            buff1 = 0,
            buff2 = 1,
            buff3 = 0,
        }
    end

    return self.wjBattleBuffInfo
end

function ClimbingTowerDataMgr:SetCurBattleBuffInfo(type,lv)
    self.wjBattleBuffInfo['buff'..type] = lv
    self:RefBattleInfo()
    ManagerContainer.LuaEventMgr:Dispatch(UIEventNames.WJ_ON_BATTLE_CHANGE);
end

function ClimbingTowerDataMgr:RefBattleInfo()
    --self.AllBattleInfos = nil
    local cfgs = ManagerContainer.CfgMgr:GetWjBattleBuffCfg()
    local buffinfo = self:GetCurBattleBuffInfo()
    local allInfo = {value = 0,infos ={}}
    local value = 0
    for i = 1, 3, 1 do
        local tempInfo = {}
        local cfg = cfgs[i]
        tempInfo.curLv = buffinfo["buff" .. i]
        tempInfo.id = i
        tempInfo.lvEffect = cfg.BuffEffect[1][2]
        tempInfo.curEffect = tempInfo.lvEffect * tempInfo.curLv
        tempInfo.max = cfg.Max
        tempInfo.cost = cfg.Cost[tempInfo.curLv + 1]
        allInfo.infos[i] = tempInfo
        if tempInfo.curLv > 0 then            
            value = value + tempInfo.curEffect
        end
    end
    allInfo.value = value
   LogError(Inspect(allInfo))
    self.AllBattleInfos = allInfo
end


function ClimbingTowerDataMgr:GetCurAllBattleBuffInfo()
    if self.AllBattleInfos == nil then
       self:RefBattleInfo()
    end
    return self.AllBattleInfos
end
return ClimbingTowerDataMgr