yzyCli/u3d/Lua/game/expDun/ExpHangupMainView.lua

-- <*
--     @Author:        Saber
--     @Description:   经验挂机 主界面
-- *>
ExpHangupMainView = ExpHangupMainView or BaseClass(BaseView)
local ExpHangupMainView = ExpHangupMainView
local ExpDunAnimConst = ExpDunAnimConst
local SetAnchoredPosition = SetAnchoredPosition
local TweenLite = TweenLite
local SetLocalScale = SetLocalScale
local cc = cc
local GlobalTimerQuest = GlobalTimerQuest
local math_random = math.random
local Status = Status
local GoodsModel = GoodsModel

function ExpHangupMainView:__init()
    self.base_file = "expDun"
    self.layout_file = "ExpHangupMainView"
    self.layer_name = "UI"
    self.destroy_imm = true
    self.use_background = true     --全屏界面默认使用这个参数,非全屏界面自行设置
    self.hide_maincancas = true
    self.append_to_ctl_queue = false
    -- self.blur_activity_bg = true
    self.use_show_anim = true
    self.use_hide_anim = true
    self:AddPreLoadList("expDun", {"ExpHangupMonModelItem"})
    self.model = ExpDunModel:getInstance()
    self.dun_model = BaseDungeonModel:getInstance()
    self.main_role = RoleManager.Instance.mainRoleInfo
    self.is_set_zdepth = true

    self.cur_page = 1 -- 当前选中的章节
    self.cur_page_index = 1 -- 当前选中的章节
    self.limit_page = 1 -- 限制查看的章节数
    self.total_pages = 0
    self.page_limit_lv = 0
    self.first_load_route = true
    self.route_item = {}
    self.expdun_route_update_func = nil
    -- 模型动画相关参数
    self.bg_roll_uvRect = self.model.main_bg_roll_uvRect
    self.bg_roll_back_uvRect = self.model.main_bg_roll_back_uvRect
    self.role_skill_list = nil -- 当前职业和性别使用的技能列表缓存
    self.last_anim_mon_id = nil
    -- 新    宝    岛
    self.anim_stage = 1 -- 当前动画阶段 1为移动阶段，2为战斗阶段，3为战斗结束后的奖励表现和等待阶段
    self.temp_stage_data = nil -- 临时动画数据资源，第一次打开界面获取，使用一次后删除
    self.role_ran_pos = ExpDunAnimConst.RoleRamPos
    self.mon_id_list = ExpDunAnimConst.AnimMonList
    self.role_pos_origin = Vector2(-270, 0) -- 玩家模型坐标原点
    self.mon_stage_data = {} -- 怪物阶段数据
    self.mon_model_list = nil
    self.has_play_effect_time = 0 -- 第几次播放终结动画
    self.last_slay_effect_time = Status.NowTime
    self.role_mod_pos_offset = nil -- 模型起点偏移
    self.launch_pos_offset = nil -- 发射坐标偏移
    self.clicked_enhance_btn = false
    self.load_callback = function () 
        self:LoadSuccess()
        self:AddEvent()
        -- lua_soundM:PlayBackgroundSound("dungeon4", LuaSoundManager.SOUND_TYPE.SCENE, true)
    end
    self.open_callback = function (  )
        self:UpdateView()
    end
    self.destroy_callback = function (  )
        self:DestroySuccess()
        -- --播放场景背景音乐
        -- local cur_scene = SceneManager:getInstance():GetSceneId()
        -- lua_soundM:PlayBackground(cur_scene)
    end
end

function ExpHangupMainView:Open(need_show_guide, need_show_offline_con)
    --self.data = data
    self.need_show_guide = need_show_guide
    self.need_show_offline_con = need_show_offline_con
    BaseView.Open(self)
end

function ExpHangupMainView:LoadSuccess()
    local nodes = {
        -- 动画相关
        -- 2020年6月24日新增 bullet_slay_con, 专门用来处理终结弹幕表现
        "anim_node",
        "anim_node/role_con:obj:raw",
        "anim_node/mon_con", "anim_node/hp_con", "anim_node/bullet_con", "anim_node/bullet_slay_con",   -- (三个大小完全一样的动画节点，用来区分层级)
        "anim_reward_con1", "anim_reward_con2", "anim_reward_con3", 
        -- 背景相关
        "anim_bg:raw", "close:obj", 
        "anim_node/bg_roll_mask:raw", 
        "anim_node/bg_roll_mask/bg_roll:raw", 
        "anim_node/bg_roll_mask/bg_roll_back:raw", 
        "help_btn:obj", 
        "route_bg:raw", 
        -- 其他
        "buy_btn:obj:imgex", -- 快速挂机购买界面按钮
        "buy_timer:tmp", -- 快速挂机冷却相关
        "reward_icon_btn:obj:img",  -- 放置挂机领取按钮
        "hang_receive_tip:obj", -- 放置挂机奖励领取提示
        "challenge_btn:obj:img", -- 打开副本主入口界面
        "challenge_btn/challenge_lb:tmp", 
        "sweep_btn:obj", -- 扫荡按钮
        "sweep_btn/sweep_lb:tmp", 
        "sweep_btn/sweep_btn_red:obj", 
        -- "ques_con:obj", 
        -- "dun_name:tmp", -- 当前副本名称
        "eff_val:tmp", -- 副本效率
        "reward_icon_lb:tmp", 
        -- 红点
        "challenge_btn/challenge_red:obj",  "buy_btn/buy_btn_red:obj","buy_btn/buy_btn_effect",  "reward_icon_btn/reward_icon_btn_red:obj", 
        -- 2021年3月11日 第六版改动新增 合并副本进度
        "enhance_btn:obj", 
        "rec_power_bg",
        "rec_power_bg/rec_power_icon:img", 
        "rec_power_bg/rec_power:tmp", 
        -- "route_scroll:scroll:cg", 
        -- "route_scroll/Viewport/route_con",  -- 路线容器
        "route_con:cg",  -- 路线容器
        "award_con:obj", 
        "arrow_left:obj", 
        "arrow_left/arrow_left_red:img", 
        "arrow_right:obj:img", 
        "arrow_right/arrow_right_red:img", 
        -- 2021年5月11日 第七版改动新增 波数排行
        "exp_wave_rank_btn:obj", 
        -- 2021年7月8日新增 追加章节查看限制
        "route_limit_bg:obj", 
        "route_limit_bg/route_limit_icon", 
        "route_limit_bg/route_limit_lb:tmp", 
        --buff相关
        "buffText:tmp:obj", "buffImg:obj", 
    }
    self:GetChildren(nodes)
    SetAnchoredPositionX(self.role_con, 9999) -- 加载模型前移出屏幕外
    local mask_x, mask_y = GetSizeDeltaXY(self.bg_roll_mask)
    SetSizeDelta(self.bg_roll_mask, mask_x * 0.99, mask_y * 0.99)
    for i = 1, 3 do
        self["award_item" .. i] = UIObjPool:getInstance():PopItem(UIObjPool.UIType.AwardItem, self["anim_reward_con" .. i])
        self["award_item" .. i]:SetAnchoredPosition(0, 0)
        self["award_item" .. i]:SetItemSize(59, 59)
        self["award_item" .. i]:SetVisible(false)
        self["award_item" .. i]:SetData(100007)
    end

    lua_resM:setOutsideRawImage(self, self.anim_bg_raw, GameResPath.GetViewBigBg("exp_anim_bg"))
    lua_resM:setOutsideRawImage(self, self.route_bg_raw, GameResPath.GetViewBigBg("exp_route_bg"))
    -- self.bg_roll_mask_raw.color = Color(1, 1, 1, 1 / 255)
    -- lua_resM:setOutsideRawImage(self, self.bg_roll_mask_raw, GameResPath.GetViewBigBg("expDun_anim_mask"))
    -- local function bg_roll_callback()
    --     self.bg_roll_raw.uvRect = self.bg_roll_uvRect
    -- end
    -- lua_resM:setOutsideRawImage(self, self.bg_roll_raw, GameResPath.GetViewBigBg("expDun_rollBg_1446_558"), false, bg_roll_callback)
    -- self.route_con_cg.alpha = 1
    self:AddToStageHandler()

    local buff_kind = OperateActivityModel.MaterialSubmitBuffKind.ADVENTURE_EXP_UP--触发加成后，玩家每分钟放置冒险经验收益提升100%（增对初始数值计算）
    local buff_cfg,buff_info = OperateActivityModel:getInstance():GetMaterialBuffInfoByKind(buff_kind)
    local buff_str = ""
    -- buff_info = {etime = TimeUtil:getServerTime(  )+300}
    -- buff_cfg = {data = 100}
    self.add_buff_exp_str = ""
    if buff_cfg and buff_info then
        local sec = buff_info.etime - TimeUtil:getServerTime(  )
        if sec > 0 then
            self.buffText_tmp.text = "放置倍速 生效期间生效期间提升效率<color=#2cf89a>"
            self.add_buff_exp_str = HtmlColorTxt("+"..buff_cfg.data.."%", ColorUtil.ORANGE_DARK)
            self.buffImg_obj:SetActive(true)
        else
            self.buffText_tmp.text = ""
            self.buffImg_obj:SetActive(false)
        end
    else
        self.buffText_tmp.text = ""
        self.buffImg_obj:SetActive(false)
    end


    if self.need_show_guide then --打开界面强制播放聚焦特效
        self:AddUIEffect("ui_jujiaodianji", self.challenge_btn, self.layer_name, nil, 1, true)  
    end
    if OperateActivityModel:getInstance().boss_drop_act then --打开界面强制播放聚焦特效
        self:AddUIEffect("ui_jujiaodianji", self.buy_btn_effect, self.layer_name, nil, 1, true)  
    end
end

function ExpHangupMainView:AddEvent()
    local function click_event(target, x, y)
        if target == self.close_obj then            
            self:Close()
        elseif target == self.sweep_btn_obj then -- 扫荡
            self.dun_model:Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61130)
        elseif target == self.challenge_btn_obj then -- 打开副本主入口界面
            -- self.model:Fire(ExpDunModel.OPEN_EXP_DUN_MAIN_VIEW, true)
            -- local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_EXP_DUNGEON,3)
            -- if helpVo then
            --     GlobalEventSystem:Fire(EventName.FINISH_CURRENT_HELP_STEP,helpVo)
            -- end           
            if self.expdun_can_enter_flag then 
                self.dun_model:Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61001, BaseDungeonModel.EXP_DUN_ID)              
            else
                Message.show("未达到挑战要求，请提升后再来吧~", "fault")
            end
            -- self.model:Fire(ExpDunModel.OPEN_EXP_HANGUP_MAIN_VIEW, false)
            -- self:Close()
        elseif target == self.reward_icon_btn_obj then -- 挂机奖励领取
            -- local condition = Config.Modulesub["610@16"].open_lv
            -- local lv = self.main_role.level
            -- if condition > lv then
            --     local str = string.format("%s级开放", condition)
            --     Message.show(str, "fault")
            -- else
            --     self.dun_model:Fire(BaseDungeonModel.REQUEST_CCMD_EVENT, 61050, 0, 0)
            -- end
            self.model:Fire(ExpDunModel.CHECK_OPEN_HANGUP_RECEIVE_VIEW)
        elseif target == self.help_btn_obj then -- 挂机玩法查询
            GlobalEventSystem:Fire(EventName.OPEN_INSTRUCTION_VIEW, "610@2")
        elseif target == self.buy_btn_obj then -- 快速挂机按钮
            OperateActivityModel:getInstance().boss_drop_act = false
            self:ClearUIEffect(self.buy_btn_effect)
            -- 2020年3月28日新增 快速挂机区分等级开放
            local condition = Config.Modulesub["610@15"].open_lv
            local lv = self.main_role.level
            if condition > lv then
                local str = string.format("%s级开放", condition)
                Message.show(str, "fault")
            else
                self.model:Fire(ExpDunModel.OPEN_QUICK_HANGUP_VIEW, true)
            end
        elseif target == self.arrow_right_obj then
            -- 追加限制，限制页码后不可以查看后续章节
            local target_page_index = self.limit_page < self.total_pages and self.limit_page or self.total_pages
            if self.cur_page_index + 1 <= target_page_index then
                self:ScrollToTargetPage(self.cur_page_index + 1)
            else
                Message.show("解锁当前章节后可浏览", "fault")
            end
        elseif target == self.arrow_left_obj then
            if self.cur_page_index - 1 > 0 then
                self:ScrollToTargetPage(self.cur_page_index - 1)
            end
        elseif target == self.enhance_btn_obj then -- 提升按钮，点击弹出引导
            if not self.clicked_enhance_btn then
                self.clicked_enhance_btn = true
                self:AddUIEffect("ui_jujiaodianji", self.challenge_btn, self.layer_name, nil, 1, true)    
            end
        elseif target == self.exp_wave_rank_btn_obj then -- 波数排行界面
            self.model:Fire(ExpDunModel.OPEN_WAVE_RANK_VIEW, true)
        elseif target == self.buffText_obj then -- buff相关
            local buff_kind = OperateActivityModel.MaterialSubmitBuffKind.ADVENTURE_EXP_UP   --伤害结算计算BUFF加成，对BOSS伤害提高10%，BOSS对人物伤害降低10%
            local buff_cfg,buff_info,dot = OperateActivityModel:getInstance():GetMaterialBuffInfoByKind(buff_kind)
            if buff_cfg and buff_info then
                local abs_pos = target.transform:TransformPoint(Vector3.zero)
                local sub_type = CustomActivityModel:getInstance():getActMinSubType(CustomActivityModel.CustomActBaseType.MATERIAL_SUBMIT)
                local act_list = CustomActivityModel:getInstance():getActList(CustomActivityModel.CustomActBaseType.MATERIAL_SUBMIT, sub_type)
                if act_list then
                    local buff_data = nil
                    for k,v in pairs(act_list.condition_list) do--[{role_lv,80},{sub,1},{cost,30},{group,5}]
                        if v[1] == "suit" then--全服进度套件ID
                            buff_data = OperateActivityModel:getInstance():GetMaterialSubmitServerCfg(tonumber(v[2]),dot)
                            break
                        end
                    end
                    if buff_data then
                        local data = {
                            sub_type = sub_type,
                            buff_data = buff_data,
                            pos_x = abs_pos.x,
                            pos_y = abs_pos.y,
                            is_outside = true,
                        }
                        OperateActivityModel:getInstance():Fire(OperateActivityModel.OPEN_MATERIAL_SUBMIT_BUFF_VIEW,data)
                    end
                end
            end
        end
    end
    AddClickEvent(self.close_obj, click_event, LuaSoundManager.SOUND_UI.NONE)
    AddClickEvent(self.sweep_btn_obj, click_event)
    AddClickEvent(self.challenge_btn_obj, click_event)
    AddClickEvent(self.reward_icon_btn_obj, click_event)
    AddClickEvent(self.help_btn_obj, click_event)
    AddClickEvent(self.buy_btn_obj, click_event)
    AddClickEvent(self.arrow_right_obj, click_event)
    AddClickEvent(self.arrow_left_obj, click_event)
    AddClickEvent(self.enhance_btn_obj, click_event)
    AddClickEvent(self.exp_wave_rank_btn_obj, click_event)
    AddClickEvent(self.buffText_obj, click_event)


    -- 经验副本奖励状态的上次领取时间更新
    local function update_expdun_reward_icon(red_type)
        self:UpdateHangupRewardIconStage()
    end
    self:BindEvent(self.model, ExpDunModel.UPDATE_HANGUP_RECEIVE_TIME, update_expdun_reward_icon)

    -- 更新扫荡或挑战按钮状态
    local function update_sweep_or_challenge_status(dun_type)
        if dun_type and dun_type == BaseDungeonModel.DUN_TYPE.EXP then
            self:UpdateSweepOrChallengeStatus()
        end
    end
    self:BindEvent(self.dun_model, BaseDungeonModel.UPDATE_DUN_BASE_INFO, update_sweep_or_challenge_status)

    local function update_expdun_offline_red(red_type)
        if not red_type or red_type == ExpDunModel.Red_Type.Offline then
            self:UpdateHangupRewardIconStage()
        end
    end
    self:BindEvent(self.model, ExpDunModel.UPDATE_EXP_RED_BY_REDTYPE, update_expdun_offline_red)

    -- 当挂机效率更新时刷新一次
    local function on_update_hangup_ratio()
        self:UpdateDunWaveData()
    end
    self:BindEvent(self.model, ExpDunModel.UPDATE_HANGUP_RATIO, on_update_hangup_ratio)

    -- 领取玩快速挂机后刷新
    local function refresh_quick_hangup_timer()
        self:UpdateQuickHangupTimer()
    end
    self:BindEvent(self.model, ExpDunModel.UPDATE_QUICKHANGUP_DATA, refresh_quick_hangup_timer)

    local function update_challenge_red(red_type)
        if not red_type or red_type == ExpDunModel.Red_Type.Milestone then
            self:UpdateEffRed()
        end
    end
    self:BindEvent(self.model, ExpDunModel.UPDATE_EXP_RED_BY_REDTYPE, update_challenge_red)
    self:BindEvent(self.model, ExpDunModel.UPDATE_MAINUI_EXP_TIP, update_challenge_red) -- 追加绑定这个，用于战斗力或者波次更新的时候

    local function onGuideTrigger()
        self:AddToStageHandler()
    end
    self:BindEvent(GlobalEventSystem, EventName.TRIGGER_GUIDE_TYPE, onGuideTrigger)

    local function updata_buff_state(id)
        if id == KfActivityModel.TabID.MaterialSubmit and self.is_loaded then
            self:UpdateQuickHangupTimer()
        end
    end
    self:BindEvent(KfActivityModel:getInstance(), KfActivityModel.ANS_UPDATE_VIEW, updata_buff_state)

    local function show_ms_reward(ms_data, pos, index)
        self:ShowMsReward(ms_data, pos, index)
    end
    self:BindEvent(self.model, ExpDunModel.SHOW_MS_REWARD, show_ms_reward) -- 追加绑定这个，用于战斗力或者波次更新的时候

    local function on_level_up()
        self:UpdateExpDunEnterLvAndPowerCondition()
        self:UpdateMilestoneItems()
    end
    self.on_level_up_id = self.main_role:Bind(EventName.CHANGE_LEVEL, on_level_up)

    local function on_role_power_change()
        local function on_timemgr_delay_func()
            self:UpdateExpDunEnterLvAndPowerCondition()
        end
        TimeManager.GetInstance():StartTime("ExpHangupMainView_UpdateExpDunEnterLvAndPowerCondition", 1, on_timemgr_delay_func)
    end
    self.on_role_power_change_id = self.main_role:BindOne("fighting", on_role_power_change)
end

function ExpHangupMainView:CancelHide()
    BaseView.CancelHide(self)
    if self.is_loaded then
        self:UpdateRoleModel()
    end
end

function ExpHangupMainView:UpdateView()
    self:UpdateDunWaveData()
    self:UpdateSweepOrChallengeStatus()
    self:UpdateExpDunEnterLvAndPowerCondition()
    self:UpdateHangupRewardIconStage()
    self:UpdateQuickHangupTimer()
    self:UpdateEffRed()
    self:UpdateMilestoneItems(true)
    -- 动画相关
    self:StartBgRollAnim() -- 背景滚动
    self:UpdateRoleModel() -- 玩家模型
    self:UpdateMonModel() -- 怪物模型
    self:CreateBulletItems() -- 子弹节点
    -- 后面要改为推算阶段(已改)
    self.anim_stage, self.temp_stage_data = self.model:GetRandomAnimStatusAndData()
    self:ViewAnimSwitcher()
end

-- 根据当前副本进度更新数据
function ExpHangupMainView:UpdateDunWaveData(  )
    -- 更新基本奖励
    self.cur_wave = self.model:GetCurrentWave()
    local route_data = self.model:GetWaveRouteData(self.cur_wave ~= 0 and self.cur_wave or 1)
    local chapter_data = self.model:GetExpChapterData(route_data.chapter)
    -- self.dun_name_tmp.text = string.format("当前关卡：%s第%s波", 
    --     Trim(Config.Expdunchapter[route_data.chapter].chapter_name), 
    --     (self.cur_wave ~= 0 and self.cur_wave or 1) - chapter_data.min_wave + 1)
    local ratio = self.model:GetExpHangUpRatio()
    local has_ratio_str = ratio == 10000 and "" or string.format("（%s）", (ratio / 100) .. "%")
    print("huangcong:ExpHangupMainView [start:399] :", has_ratio_str)
    self.eff_val_tmp.text = string.format("当前经验收益：<color=#fdffc2>%s/分%s</color>%s", 
        WordManager:ConvertNum(self.model:GetExpEfficiency(self.cur_wave, true)),
        has_ratio_str,self.add_buff_exp_str)
    
    -- 里程碑相关
    self.next_wave = self.cur_wave < TableSize(Config.Expdunwave) and self.cur_wave + 1 or self.cur_wave
    local next_wave_route = self.model:GetWaveRouteData(self.next_wave)
    -- 首次加载需要限定一次章节数和里程碑数
    self.cur_route = next_wave_route.id
    self.cur_ms_cfg = self.model:GetNextMainPointByWave(self.next_wave, false) -- 当前进度的下一个里程碑点
end

-- 检查当前是应该扫荡还是挑战副本
function ExpHangupMainView:UpdateSweepOrChallengeStatus(  )
    -- 先判断玩家是否处于红点等级限制的情况，是则需要实时计算扫荡状态，否则就拿红点缓存就行了
    local limit_red = self.model:GetExpDunLimitNewlyRed()
    local sweep_red = false
    if limit_red then
        local dun_data = self.dun_model:GetDunProtoInfo(BaseDungeonModel.DUN_TYPE.EXP)
        if dun_data and dun_data[1] then
            for k, v in pairs(dun_data[1].rec_data) do
                if v.key == 13 then
                    sweep_red = v.val == 0
                    break
                end
            end
        end
    else
        sweep_red = self.model:GetExpRedByRedType(ExpDunModel.Red_Type.Sweep)
    end

    self.challenge_btn_obj:SetActive(not sweep_red)
    self.sweep_btn_obj:SetActive(sweep_red)
    -- 红点直接在显示扫荡的时候显示
    self.sweep_btn_red_obj:SetActive(sweep_red)
end

-- 当前玩家等级或者战力发生变化时调用，刷新界面等级或战力引导，并判断是否可以挑战副本
function ExpHangupMainView:UpdateExpDunEnterLvAndPowerCondition(  )
    local power = self.main_role.fighting
    local level = self.main_role.level
    local wave_cfg = Config.Expdunwave[self.next_wave]
    local match_power = power >= wave_cfg.power_limit
    local match_level = level >= wave_cfg.lv_limit
    -- 等级不够时 显示等级不够的表现 其他情况显示为战力
    if match_level then
        self.rec_power_tmp.text = string.format("战力要求：  <color=%s>%s</color><color=#ffffff>/%s</color>",
            match_power and ColorUtil.GREEN_DARK or ColorUtil.RED_DARK, power, wave_cfg.power_limit)
    else
        self.rec_power_tmp.text = string.format("等级要求：  <color=%s>%s</color><color=#ffffff>/%s</color>",
            ColorUtil.RED_DARK, level, wave_cfg.lv_limit)
    end
    self.expdun_can_enter_flag = match_power and match_level
    lua_resM:setImageSprite(self, self.rec_power_icon_img, "expDun_asset", self.expdun_can_enter_flag and "exp_route_img11" or "exp_route_img6", true)
    SetAnchoredPositionX(self.rec_power_icon, self.expdun_can_enter_flag and 18 or 9.5)
    local total_len = 36 + self.rec_power_tmp.preferredWidth + 30
    SetSizeDeltaX(self.rec_power_bg, total_len)
    -- 设置按钮和文本灰化
    SetImageGray(self.challenge_btn_img, not self.expdun_can_enter_flag)
    SetTMPSharedMaterial(self.challenge_lb_tmp, self.expdun_can_enter_flag 
        and ShaderTools.TMPSharedMaterialType.FZZZOutlineDarkOrangeBtn 
        or ShaderTools.TMPSharedMaterialType.FZZZOutlineDarkGrayBtn)
end

-- 更新放置挂机奖励展示表现和红点
function ExpHangupMainView:UpdateHangupRewardIconStage(  )
    self:ClearExpDunRewardIconTimer()
    local condition = Config.Modulesub["610@16"].open_lv
    local lv = self.main_role.level
    if condition > lv then -- 未达到开放等级
        SetImageGray(self.reward_icon_btn_img, true)
        self.reward_icon_lb_tmp.text = string.format("%s级开放", condition)
        self.reward_icon_btn_red_obj:SetActive(false)
        self.hang_receive_tip_obj:SetActive(false)
    else
        SetImageGray(self.reward_icon_btn_img, false)
        -- 获取挂机时长配置
        local max_sec = self.model:GetHangupResourceLimitTime() * 3600
        -- 已累计挂机时间
        local contain_time
        -- local last_time = self.model:GetHangUpReceiveTime()
        local offline_red = self.model:GetExpRedByRedType(ExpDunModel.Red_Type.Offline)
        local function exp_dun_reward_icon_timer()
            contain_time = self.model:GetHangUpContainTimeData()
            -- 设置资源储存时间
            self.reward_icon_lb_tmp.text = string.format("累计 <color=#2cf86f>%s</color>", TimeUtil:timeConvert(contain_time > max_sec and max_sec or contain_time, "hh:mm:ss")) 
            if (contain_time >= 3600 or offline_red) and not self.reward_icon_btn_red_obj.activeSelf then -- 超过1小时或者有离线卡显示红点
                self.reward_icon_btn_red_obj:SetActive(true)
            elseif (contain_time < 3600 and not offline_red) and self.reward_icon_btn_red_obj.activeSelf then
                self.reward_icon_btn_red_obj:SetActive(false)
            end
            if contain_time >= 3600 and not self.hang_receive_tip_obj.activeSelf then -- 超过1小时显示奖励领取tips
                self.hang_receive_tip_obj:SetActive(true)
            elseif contain_time < 3600 and self.hang_receive_tip_obj.activeSelf then
                self.hang_receive_tip_obj:SetActive(false)
            end
        end
        self.exp_dun_reward_icon_timer_id = GlobalTimerQuest:AddPeriodQuest(exp_dun_reward_icon_timer, 1, -1)
        exp_dun_reward_icon_timer()
    end
end

function ExpHangupMainView:ClearExpDunRewardIconTimer(  )
    if self.exp_dun_reward_icon_timer_id then
        GlobalTimerQuest:CancelQuest(self.exp_dun_reward_icon_timer_id)
        self.exp_dun_reward_icon_timer_id = nil
    end
end

-- 更新快速挂机累计表现
function ExpHangupMainView:UpdateQuickHangupTimer(  )
    self:ClearQuickHangupTimer()
    local condition = Config.Modulesub["610@15"].open_lv
    local lv = self.main_role.level

    local have_time = 0
    local buff_kind = OperateActivityModel.MaterialSubmitBuffKind.ADVENTURE_EXP --是否存在活动加成buff 免费收取一次二倍
    local buff_cfg,buff_info = OperateActivityModel:getInstance():GetMaterialBuffInfoByKind(buff_kind)
    -- buff_cfg = {discount = 80,data = 1}
    -- buff_info = {etime = TimeUtil:getServerTime(  )+300,used = {{kdata = 1,vdata=0}}}
    if buff_cfg and buff_info then
        have_time = 1
        local sec = buff_info.etime - TimeUtil:getServerTime(  )
        if sec > 0 then
            self:ActBuffTimeLate(sec)
            for k,v in pairs(buff_info.used) do
                if v.kdata == 1 and v.vdata == 1 then--buff有一次免费二倍
                    have_time = 0
                    break
                end
            end
        end
    end
    if condition > lv then -- 未达到开放等级，默认0进度
        self.buy_btn_imgex.gray = true
        self.buy_timer_tmp.text = string.format("%s级开放", condition)
        self.buy_btn_red_obj:SetActive(false)
    else
        local last_time = self.model:GetQuickHangUpReceiveTime()
        local max_time, use_time = self.model:GetHangUpTimeCount()
        local left_time -- 距离下次刷新的时间
        if last_time ~= 0 and use_time < max_time then
            -- 加载当前等级的配置
            local hangup_exp_cfg = self.model:GetBuyExpBasicExpCfg()
            if not hangup_exp_cfg then
                self:ClearQuickHangupTimer()
                return
            end
            local end_time = last_time + hangup_exp_cfg.time -- 下次刷新的时间戳
            local function quick_hangup_timer()
                left_time = end_time - TimeUtil:getServerTime()
                if left_time < 0 or (have_time >= 1 and self.model:GetExpRedByRedType(ExpDunModel.Red_Type.QuickHangUp)) then
                    self.buy_btn_imgex.gray = false
                    self.buy_timer_tmp.text = ""
                    self.buy_btn_red_obj:SetActive(true)
                    self:ClearQuickHangupTimer()
                else
                    if not self.buy_btn_imgex.gray then
                        self.buy_btn_imgex.gray = true
                    end
                    if self.buy_btn_red_obj.activeSelf then
                        self.buy_btn_red_obj:SetActive(false)
                    end
                    self.buy_timer_tmp.text = string.format("冷却 <color=%s>%s</color>", ColorUtil.RED_DARK, TimeUtil:timeConvert2(left_time))
                end
            end
            self.quick_hangup_timer_id = GlobalTimerQuest:AddPeriodQuest(quick_hangup_timer, 0.5, -1)
            quick_hangup_timer()
        else
            self.buy_btn_imgex.gray = false
            self.buy_timer_tmp.text = ""
            self.buy_btn_red_obj:SetActive(false)
        end
    end
end

function ExpHangupMainView:ClearQuickHangupTimer(  )
    if self.quick_hangup_timer_id then
        GlobalTimerQuest:CancelQuest(self.quick_hangup_timer_id)
        self.quick_hangup_timer_id = nil
    end
end

function ExpHangupMainView:ShowMsReward(ms_data, pos, index)
    if not ms_data or not ms_data.reward then return end
    if self.temp_ms_data and self.temp_ms_data.wave == ms_data.wave then
        self.award_con_obj:SetActive(false)
        self.temp_ms_data = nil
        return 
    end
    self.temp_ms_data = ms_data
    -- 加载里程碑奖励
    self.ms_reward_creator = self.ms_reward_creator or self:AddUIComponent(UI.ItemListCreator)
    local info = {
        data_list = self.temp_ms_data.reward, 
        item_con = self.award_con, 
        scroll_view = self.award_con,
        obj_pool_type = UIObjPool.UIType.AwardItem,
        item_width = 62,
        start_x = 6,
        start_y = 35,
        space_x = 8,
        create_frequency = 0.01,
        alignment = UnityEngine.TextAnchor.UpperCenter,
        on_update_item = function(item, i, v)
            local type_Id, lock = GoodsModel:getInstance():GetMappingTypeId(v[1], v[2])
            item:SetData(type_Id, v[3], nil, nil, lock)
            item:SetItemSize(62, 62)
        end,
    }
    self.ms_reward_creator:UpdateItems(info)
    local total_len = 70 * #self.temp_ms_data.reward + 25
    SetSizeDeltaX(self.award_con, total_len < 230 and 230 or total_len)
    self.award_con_obj:SetActive(true)
    -- local cur_scroll_pos_x = self.route_scroll.anchoredPosition.x
    local cur_node_pos_x = self.route_con.anchoredPosition.x
    local pos_x = pos.x + cur_node_pos_x + self.award_con.sizeDelta.x * 0.25 + 10
    local pos_y = index % 2 == 1 and -141.5 or -81.5
    SetAnchoredPosition(self.award_con, pos_x, pos_y)
end

-- 2021年3月11日新增
-- 整合副本进度相关表现
-- 加载路线节点 delay_show:界面的表现太多了，这个字段用来控制在打开界面的时候延迟加载
function ExpHangupMainView:UpdateMilestoneItems(delay_show)
    -- local data = self.model:GetExpRouteData()
    local data = self.model:GetMainRouteData()
    local data_num = #data
    local role_lv = self.main_role.level
    self.total_pages = math.ceil(data_num / 4) -- 这边的数据是将5个波次合并成1条数据，实际上将会是20波一页
    self.route_item_creator = self.route_item_creator or self:AddUIComponent(UI.ItemListCreator)
    -- 计算当前的目标波数所在的页码，并计算出能查看的页码上限
    self.limit_page = self.total_pages + 1
    local checked_cur_page = false
    local checked_limit_page = false
    local temp_route_data, temp_chapter_data
    local page_min_wave, page_max_wave
    for k = 1, self.total_pages do
        local temp_index = k * 4 > data_num and data_num or k * 4
        page_max_wave = data[temp_index].ms_data.wave
        if self.next_wave <= page_max_wave and not checked_cur_page then
            self.cur_page = k
            checked_cur_page = true
            -- break
        end
        if not checked_limit_page then
            local temp_min_page = k * 4 - 3
            page_min_wave = data[temp_min_page].ms_data.wave
            temp_route_data = self.model:GetWaveRouteData(page_min_wave)
            temp_chapter_data = Config.Expdunchapter[temp_route_data.chapter]
            if temp_chapter_data and temp_chapter_data.min_lv > role_lv then
                self.limit_page = k
                self.page_limit_lv = temp_chapter_data.min_lv
                checked_limit_page = true
            else
                -- 如果不是未解锁的章节，则需要再次置空
                page_min_wave = nil
            end
        end
    end
    -- 更新当前等级的限制文本内容
    self:UpdateRouteLimitLb()
    self.expdun_route_update_func = function(cur_page)
        local data_index_min = (cur_page - 1) * 4 + 1
        local data_index_max = cur_page * 4
        data_index_max = data_index_max > data_num and data_num or data_index_max
        local item_index = 0 -- 一次最多加载4个节点，这边用来做索引
        for i = data_index_min, data_index_max do 
            item_index = item_index + 1
            self.route_item[item_index] = self.route_item[item_index] or ExpDunRouteItem.New(self.route_con)
            self.route_item[item_index]:SetData(data[i], self.cur_wave, i, page_min_wave)
            self.route_item[item_index]:SetAnchoredPosition((item_index - 1) * 251, 0)
            self.route_item[item_index]:SetVisible(true)
        end
        -- 隐藏多余的节点
        for i = item_index + 1, 4 do
            if self.route_item[i] then
                self.route_item[i]:SetVisible(false)
            end
        end
    end
    -- local info = {
    --     data_list = data, 
    --     item_con = self.route_con, 
    --     scroll_view = self.route_scroll,
    --     item_class = ExpDunRouteItem,
    --     item_width = 246,
    --     start_x = 5,
    --     -- space_x = 5,
    --     create_frequency = 0.01,
    --     reuse_item_num = 7,
    --     alignment = UnityEngine.TextAnchor.UpperLeft,
    --     on_update_item = function(item, i, v)
    --         item:SetData(v, self.cur_wave, i, page_min_wave)
    --     end,
    --     final_callback = function()
    --         self.route_scroll_scroll.horizontal = false
    --         -- SetSizeDeltaX(self.route_con, self.route_con.sizeDelta.x + 20, self.route_con.sizeDelta.y)
    --         self:ScrollToTargetPage()
    --     end,
    -- }
    if delay_show then
        local function delay_method(  )
            self.expdun_route_update_func(self.cur_page_index)
            self:ScrollToTargetPage()
            -- self.route_item_creator:UpdateItems(info)
        end
        if not self.route_item_creator_delayId then
            self.route_item_creator_delayId = setTimeout(delay_method, 0.1)
        end
    else
        self.expdun_route_update_func(self.cur_page_index)
        self:ScrollToTargetPage()
        -- self.route_item_creator:UpdateItems(info)
    end
end
function ExpHangupMainView:ScrollToTargetPage(page)
    if self.is_in_action then return end
    page = page or (self.cur_page > self.limit_page and self.limit_page or self.cur_page) -- 初始加载不可以超过限制页数
    if not (self.cur_page_index == page) or self.first_load_route then -- 页码不同才需要坐动画
        -- local x_offset = (self.cur_page_index - page) * 984
        self.is_in_action = true
        if self.route_cg_alpha_id then
            TweenLite.Stop(self.route_cg_alpha_id)
            self.route_cg_alpha_id = nil
        end
        self.route_con_cg.alpha = 0
        -- local action_con = cc.SweepAction.New(0.1, self.route_con, "right", x_offset, true, true)
        local action_con = cc.CallFunc.New(function ()
            self.is_in_action = false
            self.route_cg_alpha_id = TweenLite.to(self, self.route_con_cg, TweenLite.UiAnimationType.ALPHA_ALL, 1, 0.2)
        end)
        -- 添加动画
        cc.ActionManager:getInstance():addAction(action_con, self.route_con)
        self.first_load_route = false
    end
    self.cur_page_index = page
    -- 刷新节点
    if self.expdun_route_update_func then
        self.expdun_route_update_func(self.cur_page_index)
    end
    self.arrow_right_obj:SetActive(self.cur_page_index < self.total_pages)
    self.arrow_left_obj:SetActive(self.cur_page_index > 1)
    -- 如果处于限制页码时，右侧箭头需要灰化
    local show_right_arrow_gray = self.limit_page <= self.total_pages and self.cur_page_index == self.limit_page
    SetImageGray(self.arrow_right_img, show_right_arrow_gray)
    self.route_limit_bg_obj:SetActive(show_right_arrow_gray)

    self:UpdateArrowRed()
end

function ExpHangupMainView:UpdateRouteLimitLb(  )
    self.route_limit_lb_tmp.text = string.format("解锁等级：<color=%s>%s</color>/%s", ColorUtil.RED_DARK, 
        self.main_role.level, self.page_limit_lv)
end

function ExpHangupMainView:UpdateArrowRed(  )
    if self.cur_page_index > 1 then -- 更新左侧按钮红点
        local bool = false
        for i = 1, self.cur_page_index - 1 do
            bool = bool or self.model:GetMainRouteMilestoneRedByPages(i)
        end
        self.arrow_left_red_img.enabled = bool
    end
    if self.cur_page_index < self.total_pages then -- 更新右侧按钮红点
        local bool = false
        for i = self.cur_page_index + 1, self.total_pages do
            bool = bool or self.model:GetMainRouteMilestoneRedByPages(i)
        end
        self.arrow_right_red_img.enabled = bool
    end
end

-- 动画相关 -- 
-- 动画相关 -- 
-- 动画相关 -- 
-- 主界面动画总控制
function ExpHangupMainView:ViewAnimSwitcher(  )
    local now_time = Status.NowTime
    local function anim_mgr_func()
        if self.anim_stage == 1 then -- 飞行阶段
            -- 创建怪物数据
            self:UpdateMonStageData()
            -- 阶段倒计时
            local function stage1_timer()
                local stage_time = Status.NowTime - now_time
                if stage_time >= ExpDunAnimConst.Stage1_Time * 0.8 then -- 飞行时间过后切换到2阶段
                    self:ClearAnimMgrFuncId()
                    self.anim_stage = 2
                    self:ViewAnimSwitcher()
                end
            end
            self:ClearAnimMgrFuncId()
            self.anim_mgr_func_id = GlobalTimerQuest:AddPeriodQuest(stage1_timer, 0.05, -1)
        elseif self.anim_stage == 2 then -- 发射弹幕阶段
            self.has_play_effect_time = 0
            self:StartShootBullet()
            self:UpdateMonStageData()
            self.temp_stage_data = nil
        elseif self.anim_stage == 3 then -- 留时间播放奖励表现
            local function stage1_timer()
                self:ClearAnimMgrFuncId()
                self.anim_stage = 1
                self:ViewAnimSwitcher()
            end
            self:UpdateMonStageData()
            self:ClearAnimMgrFuncId()
            self.anim_mgr_func_id = GlobalTimerQuest:AddPeriodQuest(stage1_timer, ExpDunAnimConst.Run_Stage_Time, -1)
        end
    end
    anim_mgr_func()
end
function ExpHangupMainView:ClearAnimMgrFuncId(  )
    if self.anim_mgr_func_id then
        GlobalTimerQuest:CancelQuest(self.anim_mgr_func_id)
        self.anim_mgr_func_id = nil
    end
end
-- 加载主角模型
function ExpHangupMainView:UpdateRoleModel(  )
    -- 加载章节载具
    local chapter = self.model:GetExpDunWaveChapter(self.model:GetCurrentWave())
    local chapter_cfg = Config.Expdunchapter[chapter]
    local extra_offset = ExpDunAnimConst.ExtraOffset[chapter_cfg.res_id]
    self.role_mod_pos_offset = extra_offset and extra_offset.model_pos or Vector2(0, 0)
    self.launch_pos_offset = extra_offset and extra_offset.launch_pos or Vector2(0, 0)
    -- 加载模型
    local res_data = {
        layer_name = "UI",
        type = SceneBaseType.Include_Horse,
        father_node = self,
        transform = self.role_con,
        fashion_type = FuncOpenModel.TypeId.Clothes, 
        size = Vector2(1200*1.067, 720*1.067),
        raycast_size = Vector2(200, 277),
        action_name_list = {"run"},
        light_id = self.main_role.light_id,
        talisman_id = GetTalismanClotheId(self.main_role),
        -- scale = 0.43,
        -- position = Vector3(0,213,-100),
        -- ui_model_type = UIModelCommon.ModelType.RT,
        scale = 1, 
        can_rotate = false, 
        rotate = 180, 
        position = Vector3(55, -10, -500),
        show_shadow = false, 
        free_param = chapter_cfg.res_id,
        callBack = function()
            -- 加载完移回来
            SetAnchoredPositionX(self.role_con, -270)
            -- 首次加载不需要动画，直接定在某个点
            self:StartRoleModelAutoAnim(true)
        end,
    }
    FuncOpenModel:getInstance():SetModelRes(res_data)
    -- 重新加载背景图
    local function bg_roll_callback()
        self.bg_roll_raw.uvRect = self.bg_roll_uvRect
    end
    lua_resM:setOutsideRawImage(self, self.bg_roll_raw, GameResPath.GetViewBigBg("exp_anim_bg" .. chapter_cfg.bg_id), false, bg_roll_callback)
    -- 加载背景图远景图
    local function bg_roll_back_callback()
        self.bg_roll_back_raw.uvRect = self.bg_roll_back_uvRect
    end
    lua_resM:setOutsideRawImage(self, self.bg_roll_back_raw, GameResPath.GetViewBigBg("exp_anim_bg_back_" .. chapter_cfg.bg_id), false, bg_roll_back_callback)
end

-- 开始主角模型漂移动画
function ExpHangupMainView:StartRoleModelAutoAnim(no_anim)
    if not self.role_ram_pos_index then
        self.role_ram_pos_index = math_random(1, #self.role_ran_pos)
    else
        local new_pos = self.role_ram_pos_index
        -- 保证获取一个跟上个坐标不相等的位移点
        while(new_pos == self.role_ram_pos_index) do
            new_pos = math_random(1, #self.role_ran_pos)
        end
        self.role_ram_pos_index = new_pos
    end
    local pos_cfg = self.role_ran_pos[self.role_ram_pos_index]
    local auto_pos = Vector3(self.role_pos_origin.x + pos_cfg.pos.x + self.role_mod_pos_offset.x, self.role_pos_origin.y + pos_cfg.pos.y + self.role_mod_pos_offset.y, 0)
    local amin_scale = Vector3(pos_cfg.scale, pos_cfg.scale, pos_cfg.scale)
    local call_back = function()
        self:StartRoleModelAutoAnim(false)
    end
    self:ClearRoleModelAutoAnimId()
    self.role_model_move_anim_id = TweenLite.to(self, self.role_con, TweenLite.UiAnimationType.POS, auto_pos, pos_cfg.anim_time, call_back)
    self.role_model_scale_anim_id = TweenLite.to(self, self.role_con, TweenLite.UiAnimationType.SCALE, amin_scale, pos_cfg.anim_time)
end
function ExpHangupMainView:ClearRoleModelAutoAnimId(  )
    if self.role_model_move_anim_id then
        TweenLite.Stop(self.role_model_move_anim_id)
        self.role_model_move_anim_id = nil
    end
    if self.role_model_scale_anim_id then
        TweenLite.Stop(self.role_model_scale_anim_id)
        self.role_model_scale_anim_id = nil
    end
end

function ExpHangupMainView:UpdateMonModel()
    -- 播放怪物死亡后的奖励动画
    local function reward_anim_callback(index)
        local mon_item_pos = self.mon_model_list[index]:GetAnchoredPosition()
        SetAnchoredPosition(self["anim_reward_con"..index], mon_item_pos.x - 29.5 + 1, mon_item_pos.y + 93 + 59)
        self["award_item" .. index]:SetVisible(true)
        local function anim_end_fun()
            if self["award_item" .. index] then
                self["award_item" .. index]:SetVisible(false)
                self:OnRewardAnimEndShake() -- 收入宝箱之后播放宝箱动画
            end
        end
        self:ClearRewardAnim(index)
        self["reward_anim_id" .. index] = TweenLite.to(self, self["anim_reward_con"..index], 
            TweenLite.UiAnimationType.ANCHORED_POS, self.reward_icon_btn.anchoredPosition, 1, 
            anim_end_fun, TweenFunc.EASE_IN_QUINT)
    end

    if self.mon_model_list == nil then
        self.mon_model_list = {}
        for i = 1, 3 do 
            self.mon_model_list[i] = ExpHangupMonModelItem.New(self.mon_con, nil, self.layer_name)
            self.mon_model_list[i]:SetRewardAnimCallback(i, reward_anim_callback)
            self.mon_model_list[i]:SetHpParentNode(self.hp_con)
        end
    end
    self:StartMonModelIndexFunc()
end
-- 收入宝箱之后播放宝箱动画
function ExpHangupMainView:OnRewardAnimEndShake(  )
    -- 先清除动画
    cc.ActionManager:getInstance():removeAllActionsFromTarget(self.reward_icon_btn)
    SetLocalScale(self.reward_icon_btn, 1, 1, 1)
    local anim_scale = 1 * 0.9
    local action1 = cc.ScaleTo.New( 0.1, anim_scale, anim_scale, anim_scale)
    local action2 = cc.ScaleTo.New( 0.1, 1, 1, 1)
    local action8 = cc.Sequence.New(action1, action2)--顺序
    cc.ActionManager:getInstance():addAction(action8, self.reward_icon_btn)
end
function ExpHangupMainView:ClearRewardAnim(index)
    if self["reward_anim_id" .. index] then
        TweenLite.Stop(self["reward_anim_id" .. index])
        self["reward_anim_id" .. index] = nil
    end
end
function ExpHangupMainView:StartMonModelIndexFunc(  )
    self:ClearMonModelIndexFunc()
    self.mon_index_1 = self.mon_model_list[1].transform:GetSiblingIndex()
    self.mon_index_2 = self.mon_model_list[2].transform:GetSiblingIndex()
    self.mon_index_3 = self.mon_model_list[3].transform:GetSiblingIndex()
    local temp_tb = {}
    local function mon_model_index_func()
        for k, v in ipairs(self.mon_model_list) do
            temp_tb[k] = temp_tb[k] or {}
            temp_tb[k].index = k - 1
            temp_tb[k].scale = v:GetMonConScale()
        end
        local sort_func = function ( a, b )
            return a.scale < b.scale
        end
        table.sort(temp_tb, sort_func)
        if self.mon_index_1 ~= temp_tb[1].index
            or self.mon_index_2 ~= temp_tb[2].index
            or self.mon_index_3 ~= temp_tb[3].index then -- 缩放顺序发生变动
            self.mon_model_list[1].transform:SetSiblingIndex(temp_tb[1].index)
            self.mon_index_1 = temp_tb[1].index
            self.mon_model_list[2].transform:SetSiblingIndex(temp_tb[2].index)
            self.mon_index_2 = temp_tb[2].index
            self.mon_model_list[3].transform:SetSiblingIndex(temp_tb[3].index)
            self.mon_index_3 = temp_tb[3].index
        end
    end
    self.mon_model_index_func_id = GlobalTimerQuest:AddPeriodQuest(mon_model_index_func, 0.1, -1)
end
function ExpHangupMainView:ClearMonModelIndexFunc(  )
    if self.mon_model_index_func_id then
        GlobalTimerQuest:CancelQuest(self.mon_model_index_func_id)
        self.mon_model_index_func_id = nil
    end
end
-- 更新阶段怪物数据
function ExpHangupMainView:UpdateMonStageData(  )
    local chapter = self.model:GetExpDunWaveChapter(self.model:GetCurrentWave())
    local chapter_cfg = Config.Expdunchapter[chapter]
    local mon_id = chapter_cfg and chapter_cfg.mon_id
    -- -- 生成一个随机boss
    -- local mon_id = self.anim_stage ~= 1 and self.last_anim_mon_id or self.mon_id_list[math_random(1, #self.mon_id_list)]
    for k, v in ipairs(self.mon_model_list) do
        if self.anim_stage == 1 or not self.mon_stage_data[k] then -- 初次创建或者1阶段时需要重新刷新
            self.mon_stage_data[k] = {
                pos = Vector2((k % 2) * -70, -80 + (k-1) * 80 - 20),
                mod_pos = Vector2((k % 2 == 0) and 130 or 250, math_random(-50, 50)),
            }
        end
        if self.anim_stage == 2 and self.temp_stage_data then
            self.mon_stage_data[k] = self.mon_stage_data[k] or {}
            self.mon_stage_data[k].cur_hp = self.temp_stage_data.hp_data[k]
        end
        v:SetData(self.anim_stage, mon_id, self.mon_stage_data[k])
    end
end

-- 创建一定量的子弹节点
function ExpHangupMainView:CreateBulletItems(  )
    if not self.bullet_list then
        self.bullet_list = {}
        for i = 1, ExpDunAnimConst.BulletNum do
            self.bullet_list[i] = ExpHangupBulletItem.New(self.bullet_con, nil, self.layer_name, 1)
        end
    end

    if not self.bullet_slay_list then
        self.bullet_slay_list = {}
        for i = 1, ExpDunAnimConst.BulletNumSlay do
            self.bullet_slay_list[i] = ExpHangupBulletItem.New(self.bullet_slay_con, nil, self.layer_name, 2)
        end
    end
end

-- 使用已创建的子弹特效节点做到击中怪物的效果
function ExpHangupMainView:StartShootBullet(  )
    local bullet_time = ExpDunAnimConst.BulletTime -- 子弹动画时间
    local atk_duration = ExpDunAnimConst.Role_Attack_Duration -- 攻击间隔
    -- 动画开始的时间
    local start_anim_time = Status.NowTime - (self.temp_stage_data and self.temp_stage_data.status_pass_time or 0) 
    -- 上次发射时间
    local last_launch_time = Status.NowTime - bullet_time 
    local slay_wait_time = ExpDunAnimConst.SlayBulletEffectWaitTime
    local slay_anim_time = ExpDunAnimConst.SlayBulletEffectAnimTime
    local bullet_data = {}
    local function auto_shoot_func()
        local pass_time = Status.NowTime - last_launch_time
        local anim_total_time = Status.NowTime - start_anim_time -- 动画经过了的时间
        if pass_time >= atk_duration then
            -- 选出一个不在动画状态中的子弹
            local item
            for k, v in ipairs(self.bullet_list) do
                if not v:GetIsAnimating() then
                    item = v
                    break
                end
            end
            -- 随机出一个没死的怪物
            local un_dead_list = {}
            for k, v in ipairs(self.mon_model_list) do
                if not v:GetIsDead() then
                    un_dead_list[#un_dead_list+1] = v
                end
            end
            if #un_dead_list == 0 then -- 怪物死完，播放第三阶段
                self:ClearAnimMgrFuncId()
                self.anim_stage = 3
                self:ViewAnimSwitcher()
                -- self:PlayShootingSound(false)
            else
                if item then
                    local function hit_callback()
                        for k, target in ipairs(un_dead_list) do
                            if target then
                                if not target:GetIsDead() then
                                    target:UpdateGetHit(math_random(2, 5))
                                end
                            end
                        end
                    end
                    -- 控制终结动画
                    if anim_total_time >= slay_wait_time and Status.NowTime - self.last_slay_effect_time > slay_anim_time then
                        self.last_slay_effect_time = Status.NowTime
                        self:StartSlayBulletEffect()
                    end
                    bullet_data = {
                        start_pos = self.role_con.anchoredPosition + Vector2(self.launch_pos_offset.x, self.launch_pos_offset.y),
                        anim_time = bullet_time,
                        callback = hit_callback,
                        is_normal_bullet = true,
                    }
                    item:SetData(bullet_data)
                    last_launch_time = Status.NowTime
                    -- self:PlayShootingSound(true)
                end
            end
        end
    end
    self:ClearAnimMgrFuncId()
    self.anim_mgr_func_id = GlobalTimerQuest:AddPeriodQuest(auto_shoot_func, 0.03, -1)
end

-- 子弹音效
function ExpHangupMainView:PlayShootingSound( is_play )
    do return end
    if is_play then
        if not self.shooting_sound_id then
            self.shooting_sound_id = lua_soundM:PlayEffect(self, "shooting", true, LuaSoundManager.SOUND_TYPE.UI)
        end
    else
        if self.shooting_sound_id then
            lua_soundM:StopEffect(self, LuaSoundManager.SOUND_TYPE.UI, self.shooting_sound_id)
            self.shooting_sound_id = nil
        end
    end
end

-- 开始终结子弹表现
function ExpHangupMainView:StartSlayBulletEffect(  )
    local bullet_data = {}
    local anim_time = ExpDunAnimConst.SlayBulletEffectAnimTime
    self.has_play_effect_time = self.has_play_effect_time + 1
    for k, v in pairs(self.bullet_slay_list) do
        bullet_data = {
            start_pos = self.role_con.anchoredPosition + Vector2(self.launch_pos_offset.x, self.launch_pos_offset.y),
            anim_time = anim_time,
            show_effect_type = self.has_play_effect_time,
            is_normal_bullet = false,
        }
        v:SetData(bullet_data)
    end
    -- 延时销毁所有怪物
    local function delay_slay_all_mon()
        for k, v in ipairs(self.mon_model_list) do
            if not v:GetIsDead() then
                v:UpdateGetHit(ExpDunAnimConst.SlayBulletEffectDmg)
            end
        end
    end
    self:ClearDelaySlayAllMonId()
    self.delay_slay_all_mon_id = GlobalTimerQuest:AddDelayQuest(delay_slay_all_mon, ExpDunAnimConst.SlayBulletEffectDmgWaitTime)
end

function ExpHangupMainView:ClearDelaySlayAllMonId(  )
    if self.delay_slay_all_mon_id then
        GlobalTimerQuest:CancelQuest(self.delay_slay_all_mon_id)
        self.delay_slay_all_mon_id = nil
    end
end

-- 开始背景滚动
function ExpHangupMainView:StartBgRollAnim(  )
    local last_time = Status.NowTime
    local speed = ExpDunAnimConst.BgSpeed
    local function bg_roll_anim()
        local pass_time = Status.NowTime - last_time
        local move_x = pass_time * speed * (self.anim_stage ~= 1 and ExpDunAnimConst.CombatBgSpeed or 1)
        self.bg_roll_uvRect.x = self.bg_roll_uvRect.x + move_x
        self.bg_roll_raw.uvRect = self.bg_roll_uvRect
        self.bg_roll_back_uvRect.x = self.bg_roll_back_uvRect.x + move_x * 0.2
        self.bg_roll_back_raw.uvRect = self.bg_roll_back_uvRect
        last_time = Status.NowTime
    end
    self:ClearBgRollAnimId()
    self.bg_roll_anim_id = GlobalTimerQuest:AddPeriodQuest(bg_roll_anim, 0.02, -1)
end
function ExpHangupMainView:ClearBgRollAnimId(  )
    if self.bg_roll_anim_id then
        GlobalTimerQuest:CancelQuest(self.bg_roll_anim_id)
        self.bg_roll_anim_id = nil
    end
end

function ExpHangupMainView:UpdateEffRed(  )
    self.challenge_red_obj:SetActive(self.model:GetNextWaveFitPowerRed() and self.model:GetNextWaveFitLevel())
end

function ExpHangupMainView:DestroySuccess(  )
    -- self:PlayShootingSound(false)
    self:ClearExpDunRewardIconTimer()
    self:ClearQuickHangupTimer()
    for k,v in pairs(self.route_item) do
        v:DeleteMe()
        v = nil
    end
    self.route_item = {}
    if self.route_item_creator_delayId then
        GlobalTimerQuest:CancelQuest(self.route_item_creator_delayId)
        self.route_item_creator_delayId = nil
    end
    if self.route_cg_alpha_id then
        TweenLite.Stop(self.route_cg_alpha_id)
        self.route_cg_alpha_id = nil
    end
    self:ClearUIEffect(self.challenge_btn)
    OperateActivityModel:getInstance().boss_drop_act = false
    self:ClearUIEffect(self.buy_btn_effect)
    self:ClearAnimMgrFuncId()
    self:ClearMonModelIndexFunc()
    self:ClearDelaySlayAllMonId()
    self:ClearRewardAnim(1)
    self:ClearRewardAnim(2)
    self:ClearRewardAnim(3)
    if self.mon_model_list then
        for k, v in pairs(self.mon_model_list) do
            v:DeleteMe()
            v = nil
        end
        self.mon_model_list = nil
    end
    if self.bullet_list then
        for k, v in pairs(self.bullet_list) do
            v:DeleteMe()
            v = nil
        end
        self.bullet_list = nil
    end
    if self.bullet_slay_list then
        for k, v in pairs(self.bullet_slay_list) do
            v:DeleteMe()
            v = nil
        end
        self.bullet_slay_list = nil
    end
    for i = 1, 3 do
        if self["award_item" .. i] then
            UIObjPool:getInstance():PushItem(UIObjPool.UIType.AwardItem, self["award_item" .. i])
            self["award_item" .. i] = nil
        end
    end

    if self.act_buff_timer_id then
        GlobalTimerQuest:CancelQuest(self.act_buff_timer_id)
        self.act_buff_timer_id = nil
    end

    if self.on_level_up_id then
        self.main_role:UnBind(self.on_level_up_id)
        self.on_level_up_id = nil
    end

    if self.on_role_power_change_id then
        self.main_role:UnBind(self.on_role_power_change_id)
        self.on_role_power_change_id = nil
    end

    self:ClearRoleModelAutoAnimId()
    self:ClearBgRollAnimId()
    cc.ActionManager:getInstance():removeAllActionsFromTarget(self.reward_icon_btn)
    cc.ActionManager:getInstance():removeAllActionsFromTarget(self.route_con)
    -- 缓存背景的uv偏移
    self.model.main_bg_roll_uvRect = self.bg_roll_uvRect
    self.model.main_bg_roll_back_uvRect = self.bg_roll_back_uvRect
end

function ExpHangupMainView:AddToStageHandler()
    local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_EXP_DUNGEON,3)
    if not helpVo then return end
    local help_type = helpVo.help_type
    local step = helpVo.step
    local button = false 
    if (help_type == HelpType.TYPE_EXP_DUNGEON) and step == 3 then        
        button = self.challenge_btn_obj
    end
    if button then
        local function call_back()
        end
        GlobalEventSystem:Fire(EventName.OPEN_GUIDE_PROMPT_VIEW, button.transform, self.transform, call_back, helpVo, self.layout_file)
    end  
end

function ExpHangupMainView:Close()
    local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_EXP_DUNGEON,3)
    if helpVo then
        if helpVo.step == 3 then
            GlobalEventSystem:Fire(EventName.CLOSE_GUIDE_PROMPT_VIEW)
        end        
    end    
    BaseView.Close(self)
end

--活动BUFF时间倒计时
function ExpHangupMainView:ActBuffTimeLate( sec )
    if self.is_loaded then
        if self.act_sec == sec then
            return
        else
            self.act_sec = sec
        end
        if self.act_buff_timer_id then
            GlobalTimerQuest:CancelQuest(self.act_buff_timer_id)
            self.act_buff_timer_id = nil
        end
        local sec = sec or 0
        if sec > 0 then 
            local function onTimer()
                sec = sec - 1
                if sec > 0 then
                    
                else
                    if self.act_buff_timer_id then
                        GlobalTimerQuest:CancelQuest(self.act_buff_timer_id)
                        self.act_buff_timer_id = nil
                    end
                    self:UpdateQuickHangupTimer()
                end
            end
            if not self.act_buff_timer_id then
                self.act_buff_timer_id = GlobalTimerQuest:AddPeriodQuest(onTimer, 1, -1)
            end
            onTimer()
        else
            self:UpdateQuickHangupTimer()
        end
    end
end