local XGoldenMinerBaseObj = require("XEntity/XGoldenMiner/Object/XGoldenMinerBaseObj")
local XGoldenMinerBoom = require("XEntity/XGoldenMiner/Object/XGoldenMinerBoom")
local XGoldenMinerMouse = require("XEntity/XGoldenMiner/Object/XGoldenMinerMouse")
local XGoldenMinerRedEnvelope = require("XEntity/XGoldenMiner/Object/XGoldenMinerRedEnvelope")
local XGoldenMinerItemChangeInfo = require("XEntity/XGoldenMiner/Settle/XGoldenMinerItemChangeInfo")
local XGoldenMinerSettlementInfo = require("XEntity/XGoldenMiner/Settle/XGoldenMinerSettlementInfo")
local XUiItemPanel = require("XUi/XUiGoldenMiner/Panel/XUiItemPanel")
local XUiBuffPanel = require("XUi/XUiGoldenMiner/Panel/XUiBuffPanel")

--绳子状态
local RopeState = {
    Rock = 1, --常态摇摆
    Stretch = 2, --拉伸
    Shorten = 3, --回收
    Stop = 4,   --停止动作
}

--矿工状态
local HumenState = {
    Idle = 1, --常态
    MoveLeft = 2, --向左移动中
    MoveRight = 3, --向右移动中
}

--玩法倒计时颜色
local TxtTimeColor = {
    [true] = CS.UnityEngine.Color.white, 
    [false] = CS.UnityEngine.Color.red
}


local MILLISECOND = 1000    --毫秒
local TimeOffect = 0.99     --秒，补足倒计时为0时舍弃的0.9几秒
local PERCENT = XGoldenMinerConfigs.Percent         --倍率
local ROLE_MOVE_RANGE_PERCENT = XGoldenMinerConfigs.GetRoleMoveRangePercent()   --角色移动范围百分比
local GAME_NEAR_END_TIME = XGoldenMinerConfigs.GetGameNearEndTime() --临近结束的时间（单位：秒）
local GAME_STOP_COUNTDOWN = XGoldenMinerConfigs.GetGameStopCountdown()  --暂停倒计时（单位：秒）
local SHORTEN_SPEED_PARAMETER = XGoldenMinerConfigs.GetShortenSpeedParameter()
local SHORTEN_MIN_SPEED = XGoldenMinerConfigs.GetShortenMinSpeed()
local ROLE_GRAP_SUCCESS_TIME = XGoldenMinerConfigs.GetRoleGrapSuccessTime() --抓到物品切换回默认表情的时间（毫秒）
local USE_ITEM_SPEED = XGoldenMinerConfigs.GetUseItemSpeed()    --使用道具到抓取物的速度
local USE_BOOM_EFFECT = XGoldenMinerConfigs.GetUseBoomEffect()  --使用炸弹特效
local FINAL_SHIP_MAX_COUNT = XGoldenMinerConfigs.GetFinalShipMaxCount() --显示完全体的飞船需要升满的升级项

local CSUnityEngineTime = CS.UnityEngine.Time
local CSXResourceManagerLoad = CS.XResourceManager.Load
local CSUiButtonStateNormal = CS.UiButtonState.Normal
local CSUiButtonStateSelect = CS.UiButtonState.Select
local MathFloor = math.floor
local MathCeil = math.ceil
local MahtAbs = math.abs
local TableInsert = table.insert
-- 返回百分比倍率值(已计算底数100)
local GetPercentRate = function(percent)
    return XTool.IsNumberValid(percent) and 1 + percent or 1
end

--黄金矿工玩法界面
local XUiGoldenMinerBattle = XLuaUiManager.Register(XLuaUi, "UiGoldenMinerBattle")

function XUiGoldenMinerBattle:OnAwake()
    self:InitObj()

    self.CurFaceId = nil    --当前使用的表情Id
    self.SettlementInfo = XGoldenMinerSettlementInfo.New()
    self.DataDb = XDataCenter.GoldenMinerManager.GetGoldenMinerDataDb()
    self.HumenPosY = self.Humen.transform.localPosition.y   --矿工Y轴位置
    self.RopeRockDir = Vector3.back --绳子摇摆的方向
    self.PreFaceUrlPath = nil   --上一个表情的路径
    self.CurNearEndTime = 0 --当前临近结束时间
    self.IsCloseBattle = false  --游戏结束等后端传来数据再关闭界面
    self.IsFinishSuccess = true    --通关请求服务器是否返回成功
    self:SetIsPlayRopeOpenAnima(true)

    self:SetNotActiveBoomTimes(0)
    self:SetCurShortenSpeed(0)  --抓到东西时回收的速度
    self.ResourcePool = {}
    self.EffectPool = {}
    self.CurTriggerObjDic = {}	--钩子抓到的对象字典
    self.CurTriggerObjSettleList = {} --钩子抓到并结算成得分的对象列表
    self.CurTriggerObjSettleScoreDir = {} --结算的抓取物类型得分

    self.ItemContinueTimers = {}    --持续性道具计时器
    self.ItemContinueParams = {}    --持续性道具参数字典

    self:RegisterButtonEvent()
    self.ItemPanel = XUiItemPanel.New(self.PanelSkillParent, handler(self, self.UseItem))
    self.BuffPanel = XUiBuffPanel.New(self.PanelBuffParent, self)

    self:HideCurScoreChange()
end

function XUiGoldenMinerBattle:OnStart()
    local dataDb = self.DataDb
    local characterId = XDataCenter.GoldenMinerManager.GetUseCharacterId()
    self.CurStageId, self.CurStageIndex = dataDb:GetCurStageId()
    self.MapId = dataDb:GetStageMapId(self.CurStageId)
    self.LastTime = XGoldenMinerConfigs.GetMapTime(self.MapId) + TimeOffect
    self.BeforeScore = dataDb:GetStageScores()
    self.CurMapScore = self.BeforeScore --在当前地图中的得分
    self.SettlementItems = dataDb:GetItemColumns()
    self.DefaultFaceImgPath = XGoldenMinerConfigs.GetCharacterDefaultFace(characterId)  --角色默认表情资源路径
    self.IsPlayNearEndAnima = true  --是否播放临近结束时的动画
    self.PassTime = 0  --游戏已进行时间，用于处理延迟生成的抓取物
    self.MoveCount = 0  --玩家移动次数

    --飞碟特效首次打开界面隐藏，等倒计时结束后再显示
    self:SetHumenEffectActive(false)
    --背景的Canvas层级大于0会挡住特效，强制设为0
    if self.FullScreenBackground then
        self.FullScreenBackground.sortingOrder = 0
    end

    --目标得分
    self.TargetScoreData = dataDb:GetCurStageTargetScore()
    self.TargetScore.text = XUiHelper.GetText("GoldenMinerPlayTargetScore", self.TargetScoreData)

    self.TxtNumber.text = XUiHelper.GetText("GoldenMinerCurStage", self.CurStageIndex)

    --设置发射钩爪按钮音效的音量为原大小
    self.BtnChange.transform:GetComponent("XUguiPlaySound").VolumePercent = 100

    -- en1.32提前搬迁国服黄金矿工活动PC按键
    self.PcBtnShoot = self.BtnChange.gameObject:GetComponent(typeof(CS.XUiPc.XUiPcCustomKey))
    if self.PcBtnShoot then
        self.PcBtnShoot:SetKey(CS.XOperationType.ActivityGame, XEnumConstEn.GOLDEN_MINER.GAME_PC_KEY.Shoot)
    end
end

function XUiGoldenMinerBattle:OnEnable()
    XUiGoldenMinerBattle.Super.OnEnable(self)
    XEventManager.AddEventListener(XEventId.EVENT_APPLICATION_PAUSE, self.ApplicationPause, self)
    CS.XInputManager.SetCurOperationType(CS.XOperationType.ActivityGame)
    self:Init()
    -- 注册A/D按下事件
    self.EvtMngIdIndex = CS.XCommonGenericEventManager.RegisterLuaEvent(XEventId.EVENT_ALTER_LEFT_STICK_EVENT, function(evtId, arg)
        if self:GetCurState() ~= RopeState.Rock then
            return
        end
        local vector3 = arg.Vector
        if vector3.x < 0 then
            self.HumenCurState = HumenState.MoveLeft
        elseif vector3.x > 0 then
            self.HumenCurState = HumenState.MoveRight
        else
            self.HumenCurState = HumenState.Idle
        end
    end)
    XEventManager.AddEventListener(XEventId.EVENT_ACTIVITY_GAME_ESC, self.OnBtnStopClick, self)
end

function XUiGoldenMinerBattle:Init()
    --等异形屏适配宽度后再计算
    XScheduleManager.ScheduleOnce(function()
        if XTool.UObjIsNil(self.GameObject) then
            return
        end

        local areaPanel = XUiHelper.TryGetComponent(self.Ui.Transform, "SafeAreaContentPane")
        self.RectSize = areaPanel:GetComponent("RectTransform").rect.size
        self.RoleMoveRange = self.RectSize.x * ROLE_MOVE_RANGE_PERCENT

        self:InitTipAnimArgs()
        self:UpdateCurScore()
        self:InitMap(self.MapId)
        self:SetHumenCurState(HumenState.Idle)
        self:SetTxtTime(self.LastTime)
        self:InitEdgeTriggerEnter()
        self:InitTimes()
        self:SetRoleDefaultFace()
        self:InitHumenAppearance()

        self.ItemPanel:UpdateItemColumns()
        self:UpdateBuff()
        self:InitRope()
        self:SetCurState(RopeState.Rock)
        self:StartGameStopCountdown()
    end, 10)
end

function XUiGoldenMinerBattle:OnDisable()
    XUiGoldenMinerBattle.Super.OnDisable(self)
    XEventManager.RemoveEventListener(XEventId.EVENT_APPLICATION_PAUSE, self.ApplicationPause, self)
    XEventManager.RemoveEventListener(XEventId.EVENT_ACTIVITY_GAME_ESC, self.OnBtnStopClick, self)
    CS.XInputManager.SetCurOperationType(CS.XInputManager.BeforeOperationType)
    self:StopTimer()
    self:StopGameStopCountdown()
    self:StopCurScoreChangeAnima()
    -- 注销A/D按下事件
    CS.XCommonGenericEventManager.RemoveLuaEvent(XEventId.EVENT_ALTER_LEFT_STICK_EVENT, self.EvtMngIdIndex)
end

function XUiGoldenMinerBattle:OnDestroy()
    for _, resource in pairs(self.ResourcePool) do
        resource:Release()
    end
    if not XTool.UObjIsNil(self.GoInputHandler) then
        self.GoInputHandler:RemoveAllListeners()
    end
    self.GoInputHandler = nil
    self:StopRopeSoundPlay()
end

function XUiGoldenMinerBattle:InitObj()
    self.FullScreenBackground = XUiHelper.TryGetComponent(self.Transform, "FullScreenBackground", "Canvas")
end

--初始化飞船外观
function XUiGoldenMinerBattle:InitHumenAppearance()
    local humenImageObj = XUiHelper.TryGetComponent(self.Humen.transform, "Humen", "RawImage")
    if not humenImageObj then
        return
    end

    local dataDb = self.DataDb
    local upgradeList = dataDb:GetAllUpgradeStrengthenList()
    local totalNum = 0
    local shipKey = XGoldenMinerConfigs.ShipAppearanceKey.DefaultShip

    --设置飞船外观
    for _, strengthenDb in ipairs(upgradeList) do
        if not string.IsNilOrEmpty(strengthenDb:GetLvMaxShipKey()) and strengthenDb:IsMaxLv() then
            totalNum = totalNum + 1
            shipKey = strengthenDb:GetLvMaxShipKey()
        end
    end
    if totalNum >= FINAL_SHIP_MAX_COUNT then
        shipKey = XGoldenMinerConfigs.ShipAppearanceKey.FinalShip
    end
    humenImageObj:SetRawImage(XGoldenMinerConfigs.GetShipImagePath(shipKey))

    --设置飞船大小
    local shipSizeWidth, shipSizeHeight
    if shipKey == XGoldenMinerConfigs.ShipAppearanceKey.MaxSpeedShip then
        shipSizeWidth, shipSizeHeight = XGoldenMinerConfigs.GetShipSize(XGoldenMinerConfigs.ShipAppearanceSizeKey.MaxSpeedShipSize)
    elseif shipKey == XGoldenMinerConfigs.ShipAppearanceKey.MaxClampShip then
        shipSizeWidth, shipSizeHeight = XGoldenMinerConfigs.GetShipSize(XGoldenMinerConfigs.ShipAppearanceSizeKey.MaxClampShipSize)
    elseif shipKey == XGoldenMinerConfigs.ShipAppearanceKey.FinalShip then
        shipSizeWidth, shipSizeHeight = XGoldenMinerConfigs.GetShipSize(XGoldenMinerConfigs.ShipAppearanceSizeKey.FinalShipSize)
    else
        shipSizeWidth, shipSizeHeight = XGoldenMinerConfigs.GetShipSize(XGoldenMinerConfigs.ShipAppearanceSizeKey.DefaultShipSize)
    end
    humenImageObj.transform:GetComponent("RectTransform").rect.size = Vector2(shipSizeWidth, shipSizeHeight)
end

--初始化当前使用类型的钩爪
function XUiGoldenMinerBattle:InitRope()
    local falculaType = self:GetFalculaType()
    self.NormalRope.gameObject:SetActiveEx(falculaType == XGoldenMinerConfigs.FalculaType.Normal)
    self.MagneticRope.gameObject:SetActiveEx(falculaType == XGoldenMinerConfigs.FalculaType.Magnetic)
    self.BigRope.gameObject:SetActiveEx(falculaType == XGoldenMinerConfigs.FalculaType.Big)

    self.Rope = (falculaType == XGoldenMinerConfigs.FalculaType.Magnetic and self.MagneticRope) or
        (falculaType == XGoldenMinerConfigs.FalculaType.Big and self.BigRope) or
        self.NormalRope
    --普通和电磁钩爪的触发器
    self.RopeCordCollider = (falculaType == XGoldenMinerConfigs.FalculaType.Magnetic and self.MagneticRopeCordCollider) or self.NormalCordCollider
    --绳子Trans
    self.RopeTrans = self.Rope.transform
    self.RopeRectTrans = self.Rope.gameObject:GetComponent("RectTransform")
    --绳子最短长度
    self.RopeMinLength = self.RopeRectTrans.sizeDelta.y
    --绳子最长长度
    self.RopeMaxLength = math.ceil(math.sqrt(self.RectSize.x ^ 2 + self.RectSize.y ^ 2))
    --钩爪
    local ropeCord = XUiHelper.TryGetComponent(self.RopeTrans, "RopeCord")
    self.RopeCordTrans = ropeCord.transform
    self.RopeCordOriginPosY = self.RopeCordTrans.localPosition.y
    --左钩子
    local ropeCordLeft = XUiHelper.TryGetComponent(self.RopeTrans, "RopeCordLeft")
    self.RopeCordLeftTrans = ropeCordLeft and ropeCordLeft.transform
    self.RopeCordLeftOriginPosY = self.RopeCordLeftTrans and self.RopeCordLeftTrans.localPosition.y
    --右钩子
    local ropeCordRight = XUiHelper.TryGetComponent(self.RopeTrans, "RopeCordRight")
    self.RopeCordRightTrans = ropeCordRight and ropeCordRight.transform
    self.RopeCordRightOriginPosY = self.RopeCordRightTrans and self.RopeCordRightTrans.localPosition.y
    --电磁类型的钩子
    local ropeCordMagnetic = XUiHelper.TryGetComponent(self.RopeTrans, "RopeCordMagnetic")
    self.RopeCordMagneticTrans = ropeCordMagnetic and ropeCordMagnetic.transform
    self.RopeCordMagneticOriginPosY = self.RopeCordMagneticTrans and self.RopeCordMagneticTrans.localPosition.y
    --钩环
    local shackle = XUiHelper.TryGetComponent(self.RopeTrans, "Shackle")
    self.ShackleTrans = shackle and shackle.transform
    self.ShackleOriginPosY = self.ShackleTrans and self.ShackleTrans.localPosition.y
    --抓取到的对象的父节点
    self.TriggerObjs = XUiHelper.TryGetComponent(self.RopeCordTrans, "TriggerObjs")

    self:InitAim()
    self:SetRopeLength(self.RopeMinLength)
end

--初始化瞄准线
function XUiGoldenMinerBattle:InitAim()
    self.Aim = XUiHelper.TryGetComponent(self.RopeCordTrans, "Aim")
    local length = math.ceil(math.sqrt(self.RectSize.x ^ 2 + self.RectSize.y ^ 2))
    local sizeDelta = self.Aim.gameObject:GetComponent("RectTransform").sizeDelta
    self.Aim.gameObject:GetComponent("RectTransform").sizeDelta = Vector2(sizeDelta.x, length)
end

function XUiGoldenMinerBattle:InitTimes()
    self:SetAutoCloseInfo(XDataCenter.GoldenMinerManager.GetActivityEndTime(), function(isClose)
        if isClose then
            XDataCenter.GoldenMinerManager.HandleActivityEndTime()
            return
        end
    end, nil, 0)
end

--初始化地图边界触发器
function XUiGoldenMinerBattle:InitEdgeTriggerEnter()
    self.EdgeLeft:AddTriggerEnter2DCallback(function(collider) self:OnEdgeTriggerEnter(collider) end)
    self.EdgeRight:AddTriggerEnter2DCallback(function(collider) self:OnEdgeTriggerEnter(collider) end)
    self.EdgeTop:AddTriggerEnter2DCallback(function(collider) self:OnEdgeTriggerEnter(collider) end)
    self.EdgeBottom:AddTriggerEnter2DCallback(function(collider) self:OnEdgeTriggerEnter(collider) end)

    local rectSizeX, rectSizeY = self.RectSize.x, self.RectSize.y
    self.EdgeLeftBox.size = Vector2(self.EdgeLeftBox.size.x, rectSizeY)
    self.EdgeRightBox.size = Vector2(self.EdgeRightBox.size.x, rectSizeY)
    self.EdgeTopBox.size = Vector2(rectSizeX, self.EdgeTopBox.size.y)
    self.EdgeBottomBox.size = Vector2(rectSizeX, self.EdgeBottomBox.size.y)
end

--初始化地图中的抓取物
function XUiGoldenMinerBattle:InitMap(mapId)
    self.MouseObjList = {}
    self.BoomObjList = {}
    self.MoveObjList = {}
    self.NormalObjList = {}
    self.BornDelayObjList = {}
    self.DestroyObjList = {}
    local stoneIdList = XGoldenMinerConfigs.GetMapStoneId(mapId)
    local grapObj
    local triggerCb = handler(self, self.TrigerCallback)
    local resourceManagerLoadFunc = handler(self, self.ResourceManagerLoad)

    for i, stoneId in ipairs(stoneIdList) do
        local resource = self:ResourceManagerLoad(XGoldenMinerConfigs.GetStonePrefab(stoneId))
        local obj = XUiHelper.Instantiate(resource.Asset)
        local stoneType = XGoldenMinerConfigs.GetStoneType(stoneId)
        if stoneType == XGoldenMinerConfigs.StoneType.Boom then
            grapObj = XGoldenMinerBoom.New(obj, stoneId, i, triggerCb, resourceManagerLoadFunc)
            grapObj:InitTriggerBoomFunc(handler(self, self.TriggerBoom))
            TableInsert(self.BoomObjList, grapObj)
        elseif stoneType == XGoldenMinerConfigs.StoneType.Mouse then
            grapObj = XGoldenMinerMouse.New(obj, stoneId, i, triggerCb, resourceManagerLoadFunc)
            TableInsert(self.MouseObjList, grapObj)
        elseif stoneType == XGoldenMinerConfigs.StoneType.RedEnvelope then
            grapObj = XGoldenMinerRedEnvelope.New(obj, stoneId, i, triggerCb, resourceManagerLoadFunc)
            TableInsert(self.NormalObjList, grapObj)
        else
            grapObj = XGoldenMinerBaseObj.New(obj, stoneId, i, triggerCb, resourceManagerLoadFunc)
            if XTool.IsNumberValid(XGoldenMinerConfigs.GetStoneMoveType(stoneId)) then
                TableInsert(self.MoveObjList, grapObj)
            else
                TableInsert(self.NormalObjList, grapObj)
            end
        end

        obj.transform:SetParent(self.PanelStone, false)
        grapObj:Init(self.MapId, self.RectSize, self.PanelStone)
        grapObj:InitMoveArgs()

        if XTool.IsNumberValid(grapObj:GetStoneBornDelay()) then
            grapObj:SetDisable(true)
            TableInsert(self.BornDelayObjList, grapObj)
        end
        if XTool.IsNumberValid(grapObj:GetStoneDestroyTime()) then
            TableInsert(self.DestroyObjList, grapObj)
        end
    end
end

-----------------使用道具 begin--------------------
function XUiGoldenMinerBattle:UseItem(itemGrid)
    local itemColumn = itemGrid:GetItemColumn()
    local itemGridIndex = itemColumn:GetGridIndex()
    if not XDataCenter.GoldenMinerManager.IsUseItem(itemGridIndex) then
        return
    end

    local itemId = itemColumn:GetItemId()
    local buffId = XGoldenMinerConfigs.GetItemBuffId(itemId)
    local buffType = XGoldenMinerConfigs.GetBuffType(buffId)
    local params = XGoldenMinerConfigs.GetBuffParams(buffId)
    
    if buffType == XGoldenMinerConfigs.BuffType.GoldenMinerBoom then
        --绳子回收且有抓取物时，使用炸弹消灭抓取物
        if self:GetCurState() ~= RopeState.Shorten or XTool.IsTableEmpty(self.CurTriggerObjDic) then
            return
        end
        self:UseBoom()
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerStoneChangeGold then
        --正在拉回的物品变为同样重量的金块
        if self:GetCurState() ~= RopeState.Shorten or XTool.IsTableEmpty(self.CurTriggerObjDic) then
            return
        end
        for k, goldenMinerObject in pairs(self.CurTriggerObjDic) do
            goldenMinerObject:ChangeToGold()
        end
        self:SetRoleFaceByGroup(XGoldenMinerConfigs.FaceGroup.RoleUseStoneChangeGold, self:GetCurTriggerObjTotalScore())
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerMouseStop then
        --所有的鼬鼠停止移动一段时间
        for _, mouseObj in ipairs(self.MouseObjList) do
            mouseObj:StopMoveTime(tonumber(params[1]))
        end
        --鼬鼠恢复移动的时间
        self.MouseRecoverMoveTime = self.LastTime - tonumber(params[1])
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerNotActiveBoom then
        --不激活炸弹箱
        local curNotActiveBoomTimes = self:GetNotActiveBoomTimes()
        self:SetNotActiveBoomTimes(curNotActiveBoomTimes + tonumber(params[1]))
        self:SetIsActiveBoom(false)
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseNotActiveBoom)
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed then
        --拉回速度变为N倍
        if self:GetCurState() == RopeState.Shorten then
            self:StartItemTimer(XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed, params[2], params)
        end
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseShortenSpeed)
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerWeightFloat then
        self:StartItemTimer(XGoldenMinerConfigs.BuffType.GoldenMinerWeightFloat, params[3], params)
        self:LoadFullEffect(XGoldenMinerConfigs.GetWeightFloatEffect(), self.EffectFull)
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseWeightFloat)
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerItemStopTime then
        local charBuffType = XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime
        local time = tonumber(params[1])
        -- 角色技能时停使用时停道具时叠加时停时长
        if not XTool.IsTableEmpty(self.UseItemExBuffIdList) and self.UseItemExBuffIdList[charBuffType] then
            time = time + self.UseItemExBuffIdList[charBuffType][1]
        end
        self:SetTimeStop(time)
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseTimeStop)
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerUseItemAddTime then
        self:AddLastTime(params[1])
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseAddTime)
    elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerTypeBoom then
        self:UseTypeBoom(params[1])
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseTypeBoom)
    else
        return
    end

    self:OnUseItemExBuff(buffType)
    self:PlayUseItemSound(itemId)
    itemGrid:SetRImgIconActive(false)
    self:UpdateItemChangeInfo(itemGridIndex, XGoldenMinerConfigs.ItemChangeType.OnUse)
    self.DataDb:UseItem(itemGridIndex)
end

--播放使用道具音效
function XUiGoldenMinerBattle:PlayUseItemSound(itemId)
    local soundId = XGoldenMinerConfigs.GetItemUseSoundId(itemId)
    if not XTool.IsNumberValid(soundId) then
        return
    end

    XSoundManager.PlaySoundByType(soundId, XSoundManager.SoundType.Sound)
end

--使用炸弹
function XUiGoldenMinerBattle:UseBoom()
    self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseBoom)

    local triggerObjsPos = self.PanelPlay.transform:InverseTransformPoint(self.TriggerObjs.transform.position)
    self:LoadEffect(USE_BOOM_EFFECT, self.PanelPlay, triggerObjsPos)

    local score = self:GetCurTriggerObjTotalScore()
    local boomAfterScore = XGoldenMinerConfigs.GetFaceScore(XGoldenMinerConfigs.FaceId.RoleUseBoomAfter)
    self:SetRoleFace(score >= boomAfterScore and XGoldenMinerConfigs.FaceId.RoleUseBoomAfter or XGoldenMinerConfigs.FaceId.RoleUseBoom)

    self:RemoveCurTriggerObjDic(true)
end

--使用物品类型炸弹
function XUiGoldenMinerBattle:UseTypeBoom(type)
    self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseBoom)
    local isDestoryAll = not XTool.IsNumberValid(type)

    for _, obj in pairs(self.MouseObjList) do
        if (obj:GetType() == type or isDestoryAll) and obj:GetIsEnable() then
            obj:SelfDestroy(true)
        end
    end

    for _, obj in pairs(self.BoomObjList) do
        if (obj:GetType() == type or isDestoryAll) and obj:GetIsEnable() then
            obj:SelfDestroy(true)
        end
    end

    for _, obj in pairs(self.MoveObjList) do
        if (obj:GetType() == type or isDestoryAll) and obj:GetIsEnable() then
            obj:SelfDestroy(true)
        end
    end

    for _, obj in pairs(self.NormalObjList) do
        if (obj:GetType() == type or isDestoryAll) and obj:GetIsEnable() then
            obj:SelfDestroy(true)
        end
    end
end

function XUiGoldenMinerBattle:UpdateItemChangeInfo(itemGridIndex, status)
    local itemChangeInfo = XGoldenMinerItemChangeInfo.New()
    local itemDb = self.DataDb:GetItemColumnByIndex(itemGridIndex)
    itemChangeInfo:UpdateData({
        ItemId = itemDb:GetClientItemId(),
        Status = status,
        GridIndex = itemGridIndex
    })
    self.SettlementInfo:InsertSettlementItem(itemChangeInfo)
end

-- 使用道具时额外效果
function XUiGoldenMinerBattle:OnUseItemExBuff(itemBuffType)
    if XTool.IsTableEmpty(self.UseItemExBuffIdList) then
        return
    end
    for buffType, params in pairs(self.UseItemExBuffIdList) do
        -- 角色技能时停使用时停道具时不触发技能时停效果
        if buffType == XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime and 
            itemBuffType ~= XGoldenMinerConfigs.BuffType.GoldenMinerItemStopTime then
            self:SetTimeStop(tonumber(params[1]))
        end
    end
end

-- 启动持续性道具计时器
function XUiGoldenMinerBattle:StartItemTimer(itemType, time, params)
    self:StopItemTimer(itemType)
    self.ItemContinueTimers[itemType] = time
    self.ItemContinueParams[itemType] = params
end

-- 更新持续性道具计时
function XUiGoldenMinerBattle:UpdateItemTimer(deltaTime)
    if not self:IsTimeKeepOn() then
        return
    end
    for type, _ in pairs(self.ItemContinueTimers) do
        if not self:CheckInItemTimer(type) then
            self:StopItemTimer(type)
        else
            self.ItemContinueTimers[type] = self.ItemContinueTimers[type] - deltaTime
        end
    end
end

-- 关闭持续性道具计时器
function XUiGoldenMinerBattle:StopItemTimer(itemType)
    self.ItemContinueTimers[itemType] = nil
    self.ItemContinueParams[itemType] = nil
    if itemType == XGoldenMinerConfigs.BuffType.GoldenMinerWeightFloat then
        -- 关闭特效
        self:LoadFullEffect(XGoldenMinerConfigs.GetWeightFloatEffect(), self.EffectFull, false)
    end
end

-- 判断某持续性道具是否正在计时
function XUiGoldenMinerBattle:CheckInItemTimer(itemType)
    return self.ItemContinueTimers[itemType] ~= nil and self.ItemContinueTimers[itemType] > 0
end

-- 持续性道具改变钩爪回收速度
function XUiGoldenMinerBattle:TimeItemToChangeShortenSpeed()
    if not self:CheckInItemTimer(XGoldenMinerConfigs.BuffType.GoldenMinerWeightFloat) and
        not self:CheckInItemTimer(XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed) then
        return self.CurShortenSpeed
    end
    local baseSpeed = self.ShortenSpeed or 0

    -- 通过影响抓取物重量改变回收速度
    local totalWeight = 0
    local weightFloatParams = self.ItemContinueParams[XGoldenMinerConfigs.BuffType.GoldenMinerWeightFloat]
    local weightFloatObjType = not XTool.IsTableEmpty(weightFloatParams) and weightFloatParams[1] or nil
    local weightFloatPercent = not XTool.IsTableEmpty(weightFloatParams) and weightFloatParams[2] or nil
    local isAllType = weightFloatObjType ~= nil and weightFloatObjType == 0
    for _, obj in pairs(self.CurTriggerObjDic) do
        if isAllType or obj:GetType() == weightFloatObjType then
            totalWeight = totalWeight + MathFloor(obj:GetWeight() * GetPercentRate(weightFloatPercent / PERCENT))
        else
            totalWeight = totalWeight + obj:GetWeight()
        end
    end

    local denominator = totalWeight + SHORTEN_SPEED_PARAMETER
    denominator = XTool.IsNumberValid(denominator) and denominator or 1

    -- 通过直接影响速度改变回收速度
    local shortenSpeedParams = self.ItemContinueParams[XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed]
    local shortenSpeedPercent = not XTool.IsTableEmpty(shortenSpeedParams) and GetPercentRate(tonumber(shortenSpeedParams[1]) / PERCENT) or 1
    baseSpeed = baseSpeed * shortenSpeedPercent * (1 - (totalWeight / denominator))
    return math.max(SHORTEN_MIN_SPEED, baseSpeed)
end
-----------------使用道具 end--------------------

function XUiGoldenMinerBattle:StartTimer()
    self:StopTimer()
    self.Timer = XScheduleManager.ScheduleForeverEx(handler(self, self.Update), 0)
    self:CheckRopeSoundPlay()
end

function XUiGoldenMinerBattle:StopTimer()
    if self.Timer then
        XScheduleManager.UnSchedule(self.Timer)
        self.Timer = nil
    end
    self:StopRopeSoundPlay()
end

function XUiGoldenMinerBattle:RegisterButtonEvent()
    self:RegisterClickEvent(self.BtnStop, self.OnBtnStopClick)
    self:RegisterClickEvent(self.BtnChange, self.OnBtnChangeClick)
    self.GoInputHandler:AddPointerDownListener(function(eventData) self:OnPointerDown(eventData) end)
    self.GoInputHandler:AddPointerUpListener(function(eventData) self:OnPointerUp(eventData) end)
end

--抛出绳子
function XUiGoldenMinerBattle:OnBtnChangeClick()
    if self:GetCurState() ~= RopeState.Rock then
        return
    end

    self:OnPointerUp()
    self:SetCurState(RopeState.Stretch)
    self.SettlementInfo:AddLaunchingClawCount()
    XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetStretchSound(), XSoundManager.SoundType.Sound)
end

---------------暂停相关 begin--------------------
function XUiGoldenMinerBattle:OnBtnStopClick()
    self.BtnStop:SetButtonState(CSUiButtonStateSelect)
    self:StopTimer()
    local title = XUiHelper.GetText("GoldenMinerStopTipsTitle")
    local closeCallback = function()
        self.BtnStop:SetButtonState(CSUiButtonStateNormal)
        self:StartGameStopCountdown()
    end
    local sureCallback = handler(self, self.QuickDialog)
    local extraData = {
        sureText = XUiHelper.GetText("GoldenMinerStopTipsCloseText"),
        closeText = XUiHelper.GetText("GoldenMinerStopTipsSureText")
    }
    XLuaUiManager.Open("UiGoldenMinerDialog", title, "", closeCallback, sureCallback, extraData)
end

--二次确认退出弹窗
function XUiGoldenMinerBattle:QuickDialog()
    local title = XUiHelper.GetText("GoldenMinerQuickTipsTitle")
    local desc = XUiHelper.GetText("GoldenMinerQuickTipsDesc")
    local closeCallback = handler(self, self.OnBtnStopClick)
    local sureCallback = function()
        self:UpdateSettlementInfo()
        XDataCenter.GoldenMinerManager.RequestGoldenMinerExitGame(self.CurStageId, function()
            XLuaUiManager.PopThenOpen("UiGoldenMinerMain")
        end, self.SettlementInfo, self.CurMapScore, self.BeforeScore)
    end
    XLuaUiManager.Open("UiGoldenMinerDialog", title, desc, closeCallback, sureCallback)
end

--解除暂停倒计时
function XUiGoldenMinerBattle:StartGameStopCountdown()
    self:StopGameStopCountdown()
    local time = GAME_STOP_COUNTDOWN
    self.GameStopTimer = XScheduleManager.ScheduleForeverEx(function()
        if time <= 0 then
            self.PanelGuide.gameObject:SetActiveEx(false)
            self:SetHumenEffectActive(true)
            self:StopGameStopCountdown()
            self:StartTimer()
            return
        end

        self.TxtCountdown.text = string.format("%02d", time)
        self.PanelGuide.gameObject:SetActiveEx(true)
        time = time - 1
    end, XScheduleManager.SECOND)
end

function XUiGoldenMinerBattle:StopGameStopCountdown()
    if self.GameStopTimer then
        XScheduleManager.UnSchedule(self.GameStopTimer)
        self.GameStopTimer = nil
    end
end

--程序暂停
function XUiGoldenMinerBattle:ApplicationPause(isPause)
    if isPause then
        self:OnBtnStopClick()
    end
end
---------------暂停相关 end--------------------

local _IsNearEnd
local _IsPlayTimeEnable
function XUiGoldenMinerBattle:SetTxtTime(time)
    if not XTool.IsNumberValid(self.CurNearEndTime) then
        self.CurNearEndTime = time - 1
    end

    _IsPlayTimeEnable = time - self.CurNearEndTime < 0
    _IsNearEnd = time <= GAME_NEAR_END_TIME

    --临近结束时间后，每隔1秒播放一次动画
    if _IsNearEnd and _IsPlayTimeEnable then
        self.CurNearEndTime = time - 1
        self:PlayAnimation("TimeEnable")
    end

    self.TxtTime.text = XUiHelper.GetTime(time, XUiHelper.TimeFormatType.ESCAPE_REMAIN_TIME)
    self.TxtTime.color = TxtTimeColor[not _IsNearEnd]
end

--更新Buff
function XUiGoldenMinerBattle:UpdateBuff()
    self.BuffPanel:UpdateBuff()

    self:SetFalculaType(XGoldenMinerConfigs.FalculaType.Normal)
    self:SetStretchSpeed(XGoldenMinerConfigs.GetRopeStretchSpeed())     --绳子伸长基本速度
    self:SetShortenSpeed(XGoldenMinerConfigs.GetRopeShortenSpeed())     --绳子拉回基本速度
    self:SetHumenMoveSpeed(XGoldenMinerConfigs.GetHumenMoveSpeed())     --飞碟移动速度
    self:SetRopeRockSpeed(XGoldenMinerConfigs.GetRopeRockSpeed())       --绳子摇摆速度
    self.StoneUpScoreDic = {}       --抓取物获得的分数变为原本的X倍，默认为1
    self.UseItemExBuffIdList = {}   --使用道具时额外效果
    self.GetObjExBuffIdList = {}   --抓取物品时额外效果

    local ownBuffDic = XDataCenter.GoldenMinerManager.GetOwnBuffDic()
    local stoneScoreBuffs = ownBuffDic[XGoldenMinerConfigs.BuffType.GoldenMinerStoneScore]
    if not XTool.IsTableEmpty(stoneScoreBuffs) then
        for goldenMinerStoneType, params in pairs(stoneScoreBuffs) do
            self.StoneUpScoreDic[goldenMinerStoneType] = params[2] --各个不同类型的抓取物对应的倍率
        end
    end

    for buffType, params in pairs(ownBuffDic) do
        if buffType == XGoldenMinerConfigs.BuffType.GoldenMinerShortenSpeed then
            self:SetShortenSpeed(self.ShortenSpeed * GetPercentRate(params[1] / PERCENT))
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerNotActiveBoom then
            local curNotActiveBoomTimes = self:GetNotActiveBoomTimes()
            self:SetNotActiveBoomTimes(curNotActiveBoomTimes + params[1])
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerHumanSpeed then
            self:SetHumenMoveSpeed(self.HumenMoveSpeed * GetPercentRate(params[1] / PERCENT))
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerStretchSpeed then
            self:SetStretchSpeed(self.StretchSpeed * GetPercentRate(params[1] / PERCENT))
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerCordMode then
            self:SetFalculaType(params[1])
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerAim then
            self:SetIsShowAim(true)
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerInitAddTime then
            if not XTool.IsNumberValid(params[2]) or self.DataDb:GetFinishStageCount() <= params[2] then
                XScheduleManager.ScheduleOnce(function()
                    self:AddLastTime(params[1])
                end, GAME_STOP_COUNTDOWN * XScheduleManager.SECOND)
            end
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime then
            self.UseItemExBuffIdList[XGoldenMinerConfigs.BuffType.GoldenMinerUseItemStopTime] = params
        elseif buffType == XGoldenMinerConfigs.BuffType.GoldenMinerValueFloat then
            self.GetObjExBuffIdList[XGoldenMinerConfigs.BuffType.GoldenMinerValueFloat] = params
        end
    end
end


-- 时间相关
--==============================================================

-- 增加剩余时间
function XUiGoldenMinerBattle:AddLastTime(time)
    if not XTool.IsNumberValid(time) then
        return
    end
    if self.LastTime == nil then
        self.LastTime = 0
    end
    self.LastTime = self.LastTime + time
    self:SetTxtTime(self.LastTime)
    self:PlayAddTimeAnim(time)
end

-- 时间暂停
function XUiGoldenMinerBattle:SetTimeStop(time)
    local stopTime = time
    self:StopTimeStopTimer()
    self:TimeStop()
    self:LoadFullEffect(XGoldenMinerConfigs.GetStopTimeStartEffect(), self.EffectFull)
    self.TimeStopTimer = XScheduleManager.ScheduleForeverEx(function()
        stopTime = stopTime - (self.Timer and CSUnityEngineTime.deltaTime or 0)
        local isInGame = XTool.IsNumberValid(self.PanelStone.transform.childCount)
        if XTool.UObjIsNil(self.GameObject) then
            self:StopTimeStopTimer()
        end
        if not isInGame or stopTime <= 0 then
            self:StopTimeStopTimer()
            self.TimeStopTimer = nil
            self:TimeContinue()
        end
    end, 0)
end

function XUiGoldenMinerBattle:StopTimeStopTimer()
    if self.TimeStopTimer then
        self:LoadFullEffect(XGoldenMinerConfigs.GetStopTimeStopEffect(), self.EffectFull)
        XScheduleManager.UnSchedule(self.TimeStopTimer)
        self.TimeStopTimer = nil
    end
end

function XUiGoldenMinerBattle:TimeStop()
    self.IsTick = false
end

function XUiGoldenMinerBattle:TimeContinue()
    self.IsTick = true
end

function XUiGoldenMinerBattle:IsTimeKeepOn()
    if self.IsTick == nil then
        self.IsTick = true
    end
    return self.IsTick
end

--==============================================================


-- Update相关
--==============================================================

local _DeltaTime
local _CurState
function XUiGoldenMinerBattle:Update()
    _DeltaTime = self:GetDeltaTime()
    self:UpdateTime()
    if MathFloor(self.LastTime) <= 0 then
        self.LastTime = 0
        self:GameOver()
        return
    end

    self:UpdateItemTimer(_DeltaTime)
    self:UpdateShipState()
    self:UpdateShipMove()

    self:UpdateObjBorn()
    self:UpdateObjDestroy()
    self:UpdateObjMove()
end

function XUiGoldenMinerBattle:UpdateTime()
    if not self:IsTimeKeepOn() then
        return
    end
    self.LastTime = self.LastTime - _DeltaTime
    self.PassTime = self.PassTime + _DeltaTime
    if self.LastTime < 0 then
        self.LastTime = 0
    end
    self:SetTxtTime(self.LastTime)
end

-- 飞船抓取状态
function XUiGoldenMinerBattle:UpdateShipState()
    _CurState = self:GetCurState()
    if _CurState == RopeState.Rock then
        self:Rock()
        self:SetRoleDefaultFace()
        self:CheckGameOver()
    elseif _CurState == RopeState.Stretch then
        self:Stretch()
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleStretch)
    elseif _CurState == RopeState.Shorten then
        self:Shorten()
    end
end

-- 飞船移动
function XUiGoldenMinerBattle:UpdateShipMove()
    if self.HumenCurState == HumenState.MoveLeft then
        self:HumenMoveLeft()
    elseif self.HumenCurState == HumenState.MoveRight then
        self:HumenMoveRight()
    end
end

local _BornDelayObjList = {}
function XUiGoldenMinerBattle:UpdateObjBorn()
    if not self:IsTimeKeepOn() then
        return
    end
    if XTool.IsTableEmpty(self.BornDelayObjList) then
        return
    end
    _BornDelayObjList = {}
    for _, obj in ipairs(self.BornDelayObjList) do
        if self.PassTime >= obj:GetStoneBornDelay() then
            obj:SetDisable(false)
        else
            TableInsert(_BornDelayObjList, obj)
        end
    end
    self.BornDelayObjList = _BornDelayObjList
end


local _DestoryObjList = {}
function XUiGoldenMinerBattle:UpdateObjDestroy()
    if not self:IsTimeKeepOn() then
        return
    end
    if XTool.IsTableEmpty(self.DestroyObjList) then
        return
    end
    _DestoryObjList = {}
    for _, obj in ipairs(self.DestroyObjList) do
        if self.PassTime >= obj:GetStoneBornDelay() + obj:GetStoneDestroyTime() and not obj:GetIsCatch() then
            obj:SelfDestroy()
        else
            TableInsert(_DestoryObjList, obj)
        end
    end
    self.DestroyObjList = _DestoryObjList
end

-- 抓取物移动
function XUiGoldenMinerBattle:UpdateObjMove()
    if not self:IsTimeKeepOn() then
        return
    end
    for _, obj in ipairs(self.MouseObjList) do
        obj:Move(_DeltaTime)
    end
    for _, obj in ipairs(self.MoveObjList) do
        obj:Move(_DeltaTime)
    end
end

--==============================================================

-----------Buff相关 begin---------------
--设置回收绳子基本速度
function XUiGoldenMinerBattle:SetShortenSpeed(speed)
    self.ShortenSpeed = speed
end

--设置当前回收绳子的速度
function XUiGoldenMinerBattle:SetCurShortenSpeed(speed)
    self.CurShortenSpeed = speed
end

--更新当前正在回收绳子时的速度
function XUiGoldenMinerBattle:UpdateCurShortenSpeed(speed)
    local baseSpeed = speed or self.ShortenSpeed or 0
    local totalWeight = self:GetCurTriggerObjTotalWeight()
    local denominator = totalWeight + SHORTEN_SPEED_PARAMETER
    denominator = XTool.IsNumberValid(denominator) and denominator or 1
    baseSpeed = baseSpeed * (1 - (totalWeight / denominator))
    self:SetCurShortenSpeed(math.max(SHORTEN_MIN_SPEED, baseSpeed))
end

--设置绳子伸长速度
function XUiGoldenMinerBattle:SetStretchSpeed(speed)
    self.StretchSpeed = speed
end

--设置角色移动速度
function XUiGoldenMinerBattle:SetHumenMoveSpeed(speed)
    self.HumenMoveSpeed = speed
end

--设置绳子摇摆速度
function XUiGoldenMinerBattle:SetRopeRockSpeed(speed)
    self.RopeRockSpeed = speed
end

--设置钩爪类型
function XUiGoldenMinerBattle:SetFalculaType(type)
    self.FalculaType = type
end

--设置钩爪变大
function XUiGoldenMinerBattle:SetFalculaBigger(type)
    self.FalculaType = type
end

function XUiGoldenMinerBattle:GetFalculaType()
    return self.FalculaType
end

--是否显示瞄准线
function XUiGoldenMinerBattle:SetIsShowAim(isShow)
    self.IsShowAim = isShow
end

--获得抓取物分数上升倍率，默认1
function XUiGoldenMinerBattle:GetStoneUpScoreMultiple(goldenMinerStoneType)
    local multiple = self.StoneUpScoreDic[goldenMinerStoneType]
    return XTool.IsNumberValid(multiple) and GetPercentRate(multiple / PERCENT) or 1
end

--获得抓取物分数
function XUiGoldenMinerBattle:GetStoneScore(goldenMinerObject)
    local goldenMinerStoneType = goldenMinerObject:GetType()
    local score = 0

    --鼬鼠需要额外算上携带物的倍率
    if goldenMinerStoneType == XGoldenMinerConfigs.StoneType.Mouse then
        local carryStoneId = goldenMinerObject:GetCurCarryStoneId()
        if XTool.IsNumberValid(carryStoneId) then
            local stoneType = XGoldenMinerConfigs.GetStoneType(carryStoneId)
            -- 红包抓取物之后的抓取物类型都是效果型
            if stoneType <= XGoldenMinerConfigs.StoneType.RedEnvelope  then
                score = score + goldenMinerObject:GetCarryStoneScore() * self:GetStoneUpScoreMultiple(stoneType)
            end
        end
    elseif goldenMinerStoneType == XGoldenMinerConfigs.StoneType.AddTimeStone then
        return goldenMinerObject:GetScore()
    elseif goldenMinerStoneType == XGoldenMinerConfigs.StoneType.ItemStone then
        return score
    end

    score = score + goldenMinerObject:GetScore() * self:GetStoneUpScoreMultiple(goldenMinerStoneType)

    return score
end
-----------Buff相关 end-----------------

-----------角色状态 begin---------------
--按下屏幕，角色左右移动
local _Screen = CS.UnityEngine.Screen
function XUiGoldenMinerBattle:OnPointerDown(eventData)
    if self:GetCurState() ~= RopeState.Rock then
        return
    end

    local eventPosX = eventData.position.x
    if eventPosX < _Screen.width / 2 then
        --向左移动
        self:SetHumenCurState(HumenState.MoveLeft)
    else
        --向右移动
        self:SetHumenCurState(HumenState.MoveRight)
    end
    self.MoveCount = self.MoveCount + 1
end

function XUiGoldenMinerBattle:OnPointerUp()
    self:SetHumenCurState(HumenState.Idle)
end

function XUiGoldenMinerBattle:HumenMoveLeft()
    local changePosX = self.Humen.transform.localPosition.x - self:GetDeltaTime() * self.HumenMoveSpeed
    if not self:CheckHumenMove(changePosX) then
        return
    end
    self.Humen.transform.localPosition = Vector3(changePosX, self.HumenPosY, 0)
end

function XUiGoldenMinerBattle:HumenMoveRight()
    local changePosX = self.Humen.transform.localPosition.x + self:GetDeltaTime() * self.HumenMoveSpeed
    if not self:CheckHumenMove(changePosX) then
        return
    end
    self.Humen.transform.localPosition = Vector3(changePosX, self.HumenPosY, 0)
end

function XUiGoldenMinerBattle:SetHumenCurState(state)
    self.HumenCurState = state
end

local _HumenCurPosX
function XUiGoldenMinerBattle:CheckHumenMove(changePosX)
    _HumenCurPosX = self.Humen.transform.localPosition.x
    --锚点在中间
    if MahtAbs(changePosX * 2) >= self.RoleMoveRange then
        self:SetHumenCurState(HumenState.Idle)
        return false
    end
    return true
end
-----------角色状态 end---------------

-----------绳子状态 begin---------------
local _RopeLength
local _Scale
function XUiGoldenMinerBattle:Rock()
    if self.RopeTrans.localRotation.z <= -0.5 then
        self.RopeRockDir = Vector3.forward
    elseif self.RopeTrans.localRotation.z >= 0.5 then
        self.RopeRockDir = Vector3.back
    end
    self.RopeTrans:Rotate(self.RopeRockDir * self.RopeRockSpeed * self:GetDeltaTime())
end

function XUiGoldenMinerBattle:Stretch()
    _RopeLength = self.RopeLength + self:GetDeltaTime() * self.StretchSpeed
    self:SetRopeLength(_RopeLength)
    self:SetRopeCordPosY(self.RopeMinLength - self.RopeRectTrans.sizeDelta.y)
    if _RopeLength >= self.RopeMaxLength then
        self:SetCurState(RopeState.Shorten)
    end
end

function XUiGoldenMinerBattle:Shorten()
    if self.RopeLength <= self.RopeMinLength then
        self:SetRopeLength(self.RopeMinLength)
        self:SetRopeCordPosY(0)
        self:CheckRoleGrapSuccess()
        self:UpdateCurScore()
        self:SetCurState(RopeState.Rock)
        return
    end

    _RopeLength = self.RopeLength - self:GetDeltaTime() * self:TimeItemToChangeShortenSpeed()
    self:SetRopeLength(_RopeLength)
    self:SetRopeCordPosY(self.RopeMinLength - self.RopeRectTrans.sizeDelta.y)
end

--设置绳子高度
function XUiGoldenMinerBattle:SetRopeHeight(height)
    self.RopeRectTrans.sizeDelta = Vector2(self.RopeRectTrans.sizeDelta.x, height)
end

--设置绳子节点下的Y轴
--ropeLengthLerp：当前绳子长度和原始长度的差值
local _localPosition
function XUiGoldenMinerBattle:SetRopeCordPosY(ropeLengthLerp)
    if self.RopeCordLeftTrans then
        _localPosition = self.RopeCordLeftTrans.localPosition
        self.RopeCordLeftTrans.localPosition = Vector3(_localPosition.x, self.RopeCordLeftOriginPosY + ropeLengthLerp, _localPosition.z)
    end
    if self.RopeCordRightTrans then
        _localPosition = self.RopeCordRightTrans.localPosition
        self.RopeCordRightTrans.localPosition = Vector3(_localPosition.x, self.RopeCordRightOriginPosY + ropeLengthLerp, _localPosition.z)
    end
    if self.RopeCordMagneticTrans then
        _localPosition = self.RopeCordMagneticTrans.localPosition
        self.RopeCordMagneticTrans.localPosition = Vector3(_localPosition.x, self.RopeCordMagneticOriginPosY + ropeLengthLerp, _localPosition.z)
    end
    if self.ShackleTrans then
        _localPosition = self.ShackleTrans.localPosition
        self.ShackleTrans.localPosition = Vector3(_localPosition.x, self.ShackleOriginPosY + ropeLengthLerp, _localPosition.z)
    end
    _localPosition = self.RopeCordTrans.localPosition
    self.RopeCordTrans.localPosition = Vector3(_localPosition.x, self.RopeCordOriginPosY + ropeLengthLerp, _localPosition.z)
end

function XUiGoldenMinerBattle:SetRopeLength(length)
    self.RopeLength = length
    self:SetRopeHeight(length)
end

--设置当前绳子的状态
--boomObj：在地图中的炸弹对象
function XUiGoldenMinerBattle:SetCurState(state, boomObj)
    local falculaType = self:GetFalculaType()

    --电磁钩爪不播放夹子动画，直接回收
    if state == RopeState.Stop and falculaType == XGoldenMinerConfigs.FalculaType.Magnetic then
        state = RopeState.Shorten
        if boomObj then
            self:TriggerBoom(boomObj)
        end
    elseif state == RopeState.Stop and falculaType == XGoldenMinerConfigs.FalculaType.Big then
        if boomObj then
            self:TriggerBoom(boomObj)
        end
    end

    --播放和停止音效
    if state == RopeState.Stretch then
        XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetStretchSound(), XSoundManager.SoundType.Sound)
    else
        XSoundManager.Stop(XGoldenMinerConfigs.GetStretchSound())
    end
    if state == RopeState.Shorten then
        XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetShortenSound(), XSoundManager.SoundType.Sound)
    else
        XSoundManager.Stop(XGoldenMinerConfigs.GetShortenSound())
    end

    local isPlayRopeAnima = self.CurState ~= state
    self.CurState = state
    if isPlayRopeAnima then
        self:PlayRopeAnima(state, boomObj)
    end
    if state == RopeState.Stop then
        --普通钩爪停止移动播放动画时，关闭触发器检测
        if falculaType == XGoldenMinerConfigs.FalculaType.Normal then
            self:SetRopeCordColliderActive(false)
        end
        return
    end

    local notActiveBoomTimes = self:GetNotActiveBoomTimes()
    if state == RopeState.Shorten and notActiveBoomTimes > 0 then
        self:SetNotActiveBoomTimes(notActiveBoomTimes - 1)
    end

    self:SetIsActiveBoom(state == RopeState.Stretch and notActiveBoomTimes <= 0)

    self:UpdateCurShortenSpeed()
    self:SetAimActive(state == RopeState.Rock and self.IsShowAim)
    self:SetRopeCordColliderActive(state == RopeState.Stretch)

    if state == RopeState.Shorten then
        self:CheckRoleGrapingFace()
    end

    if state == RopeState.Rock then
        self:CheckGameOver()
    end
end

--播放夹子动画
function XUiGoldenMinerBattle:PlayRopeAnima(state, boomObj)
    --未抓到物品碰到边界回到摇摆状态时，不播放夹子打开的动画
    if state == RopeState.Stretch then
        self:SetIsPlayRopeOpenAnima(false)
    elseif state == RopeState.Rock and not self:GetIsPlayRopeOpenAnima() then
        self:SetIsPlayRopeOpenAnima(true)
        return
    end

    local animaName
    local falculaType = self:GetFalculaType()
    if falculaType == XGoldenMinerConfigs.FalculaType.Normal then
        animaName = (state == RopeState.Rock and "NormalRopeOpen") or (state == RopeState.Stop and "NormalRopeClose")
    elseif falculaType == XGoldenMinerConfigs.FalculaType.Big then
        animaName = (state == RopeState.Rock and "BigRopeOpen") or (state == RopeState.Stop and "BigRopeClose")
    end

    if state == RopeState.Stop then
        self:SetIsPlayRopeOpenAnima(true)
    end
    if animaName then
        self:PlayAnimation(animaName, function()
            if state == RopeState.Stop then
                if not boomObj then
                    self:SetObjToTriggerParent()
                else
                    self:TriggerBoom(boomObj)
                end
                self:SetCurState(RopeState.Shorten)
            end
        end)
    end
end

function XUiGoldenMinerBattle:SetIsPlayRopeOpenAnima(isPlay)
    self.IsPlayRopeAnima = isPlay
end

function XUiGoldenMinerBattle:GetIsPlayRopeOpenAnima()
    return self.IsPlayRopeAnima
end

function XUiGoldenMinerBattle:GetCurState()
    return self.CurState
end

--设置不激活炸药箱的次数
function XUiGoldenMinerBattle:SetNotActiveBoomTimes(times)
    self.NotActiveBoomTimes = times
end

function XUiGoldenMinerBattle:GetNotActiveBoomTimes()
    return self.NotActiveBoomTimes
end

function XUiGoldenMinerBattle:SetIsActiveBoom(isActive)
    for _, boomObj in ipairs(self.BoomObjList) do
        boomObj:SetGoInputHandlerActive(isActive)
    end
end

function XUiGoldenMinerBattle:SetAimActive(isActive)
    self.Aim.gameObject:SetActiveEx(isActive)
end
-----------绳子状态 end---------------

-----------钩子触发器相关 begin------------
function XUiGoldenMinerBattle:SetRopeCordColliderActive(isActive)
    if self:GetFalculaType() == XGoldenMinerConfigs.FalculaType.Big then
        self.BigRopeCordLeftCollider.enabled = isActive
        self.BigRopeCordRightCollider.enabled = isActive
        return
    end

    if XTool.UObjIsNil(self.RopeCordCollider) then
        XLog.Error("黄金矿工钩子上的触发器不存在")
        return
    end
    self.RopeCordCollider.enabled = isActive
end

function XUiGoldenMinerBattle:TrigerCallback(goldenMinerObject)
    local stoneType = goldenMinerObject:GetType()
    local falculaType = self:GetFalculaType()

    if stoneType ~= XGoldenMinerConfigs.StoneType.Boom then
        self.CurTriggerObjDic[goldenMinerObject:GetIndex()] = goldenMinerObject
    end

    if stoneType == XGoldenMinerConfigs.StoneType.Boom then
        self:SetCurState(RopeState.Stop, goldenMinerObject)
        return
    elseif falculaType == XGoldenMinerConfigs.FalculaType.Magnetic then
        goldenMinerObject:SetObjToTriggerParent(self.TriggerObjs)
        return
    end

    self:SetCurState(RopeState.Stop)
end

function XUiGoldenMinerBattle:OnEdgeTriggerEnter(collider)
    self:SetCurState(RopeState.Shorten)
end

function XUiGoldenMinerBattle:SetObjToTriggerParent()
    for _, v in pairs(self.CurTriggerObjDic) do
        v:SetObjToTriggerParent(self.TriggerObjs)
    end
end

--碰到炸弹
function XUiGoldenMinerBattle:TriggerBoom(boomObj)
    if (boomObj) and not XTool.UObjIsNil(boomObj.GameObject) then
        local effect = XGoldenMinerConfigs.GetStoneCatchEffect(boomObj:GetId())
        local boomObjPos = self.PanelPlay.transform:InverseTransformPoint(boomObj.Transform.position)
        self:LoadEffect(effect, self.PanelPlay, boomObjPos)
        boomObj:SetObjToTriggerParent()
    end
    self:RemoveCurTriggerObjDic()
    self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleGrapBoom)
end

-- 碰到加时道具
function XUiGoldenMinerBattle:TriggerAddTime(boomObj)
    
end
-----------钩子触发器相关 end--------------

-----------表情相关 begin------------
--检查表情，返回是否可切换表情
function XUiGoldenMinerBattle:CheckFace()
    if XTool.IsNumberValid(self.MouseRecoverMoveTime) and self.MouseRecoverMoveTime <= self.LastTime then
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleUseMouseStop)
        return false
    end
    self.MouseRecoverMoveTime = 0

    if XTool.IsNumberValid(self.RoleGrapSuccessTime) and self.RoleGrapSuccessTime <= self.LastTime then
        return false
    end
    self.RoleGrapSuccessTime = 0
    
    return true
end

--检查角色成功拉回表情
function XUiGoldenMinerBattle:CheckRoleGrapSuccess()
    for _, obj in pairs(self.CurTriggerObjDic) do
        if obj:GetType() == XGoldenMinerConfigs.StoneType.RedEnvelope then
            self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleGrapRedEnvelope)
        elseif obj:GetType() == XGoldenMinerConfigs.StoneType.AddTimeStone then
            self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleGrapAddTime)
        elseif obj:GetType() == XGoldenMinerConfigs.StoneType.ItemStone then
            self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleGrapTimeStop)
        else
            local score = self:GetCurTriggerObjTotalScore()
            self:SetRoleFaceByGroup(XGoldenMinerConfigs.FaceGroup.RoleGrapSuccess, score)
        end
    end

    self.RoleGrapSuccessTime = self.LastTime - ROLE_GRAP_SUCCESS_TIME / MILLISECOND
end

--检查角色拉回的表情
function XUiGoldenMinerBattle:CheckRoleGrapingFace()
    --没抓到任何东西
    if XTool.IsTableEmpty(self.CurTriggerObjDic) then
        self:SetRoleFace(XGoldenMinerConfigs.FaceId.RoleCantGrap)
        return
    end

    local weight = self:GetCurTriggerObjTotalWeight()
    self:SetRoleFaceByGroup(XGoldenMinerConfigs.FaceGroup.RoleGraping, weight)
end

--策划需求：不显示默认表情了
function XUiGoldenMinerBattle:SetRoleDefaultFace()
    if not self:CheckFace() then
        return
    end
    if self.PreFaceUrlPath == self.DefaultFaceImgPath then
        return
    end

    self:PlayAnimation("PanelEmoticonDisable")
    self.PreFaceUrlPath = self.DefaultFaceImgPath
end

function XUiGoldenMinerBattle:SetRoleFace(faceId)
    if self.CurFaceId == faceId then
        return
    end

    local img = XGoldenMinerConfigs.GetFaceImage(faceId)
    if self.PreFaceUrlPath == img then
        return
    end

    local isPlayDisable = self.DefaultFaceImgPath ~= self.PreFaceUrlPath

    self.PreFaceUrlPath = img
    if isPlayDisable then
        self:PlayAnimation("PanelEmoticonDisable", function()
            if not XTool.UObjIsNil(self.RImgHate) then
                self.RImgHate:SetRawImage(img)
            end
            self:PlayAnimation("PanelEmoticonEnable")
        end)
    else
        if not XTool.UObjIsNil(self.RImgHate) then
            self.RImgHate:SetRawImage(img)
        end
        self:PlayAnimation("PanelEmoticonEnable")
    end
    self.CurFaceId = faceId

    self:CheckFace()
end

function XUiGoldenMinerBattle:SetRoleFaceByGroup(groupId, value)
    local faceId = XGoldenMinerConfigs.GetFaceIdByGroup(groupId, value)
    self:SetRoleFace(faceId)
end
-----------表情相关 end--------------

--获得拉取中的物品总积分
function XUiGoldenMinerBattle:GetCurTriggerObjTotalScore()
    local score = 0
    for _, obj in pairs(self.CurTriggerObjDic) do
        score = score + self:GetStoneScore(obj)
    end
    return score
end

--获得拉取中的物品总重量
function XUiGoldenMinerBattle:GetCurTriggerObjTotalWeight()
    local weight = 0
    for _, obj in pairs(self.CurTriggerObjDic) do
        weight = weight + obj:GetWeight()
    end
    return weight
end

function XUiGoldenMinerBattle:UpdateCurScore()
    local score
    local addTime = 0
    local stopTime = 0
    for _, goldenMinerObject in pairs(self.CurTriggerObjDic) do
        if goldenMinerObject:GetType() == XGoldenMinerConfigs.StoneType.AddTimeStone then
            addTime = addTime + self:GetStoneScore(goldenMinerObject)
        elseif goldenMinerObject:GetType()  == XGoldenMinerConfigs.StoneType.ItemStone then
            stopTime = goldenMinerObject:GetScore()
        else
            score = self:OnGetObjScoreExBuff(self:GetStoneScore(goldenMinerObject))
            self:AddCurMapScore(score)
            self:CheckRedEnvelopeItem(goldenMinerObject)
            if goldenMinerObject:GetScore() ~= 0 then
                self:AddCurTriggerObjSettleScore(goldenMinerObject:GetType(), score)
                TableInsert(self.CurTriggerObjSettleList, goldenMinerObject)
            end
        end
        -- 携带式效果型抓取物处理
        if goldenMinerObject:GetType()  == XGoldenMinerConfigs.StoneType.Mouse then
            local carryStoneId = goldenMinerObject:GetCurCarryStoneId()
            if XTool.IsNumberValid(carryStoneId) then
                if XGoldenMinerConfigs.GetStoneType(carryStoneId) == XGoldenMinerConfigs.StoneType.AddTimeStone then
                    addTime = addTime + XGoldenMinerConfigs.GetStoneScore(carryStoneId)
                elseif XGoldenMinerConfigs.GetStoneType(carryStoneId)  == XGoldenMinerConfigs.StoneType.ItemStone then
                    stopTime = XGoldenMinerConfigs.GetStoneScore(carryStoneId)
                end
            end
        end
    end

    if XTool.IsNumberValid(stopTime) then
        self:SetTimeStop(stopTime)
    end
    if XTool.IsNumberValid(addTime) then
        self:AddLastTime(addTime)
    end
    self:RemoveCurTriggerObjDic()
    self:UpdateTextCurScore()
end

-- 处理计分时受百分比增幅的分数
function XUiGoldenMinerBattle:AddCurTriggerObjSettleScore(stoneType, score)
    if not XTool.IsNumberValid(self.CurTriggerObjSettleScoreDir[stoneType]) then
        self.CurTriggerObjSettleScoreDir[stoneType] = 0
    end
    self.CurTriggerObjSettleScoreDir[stoneType] = self.CurTriggerObjSettleScoreDir[stoneType] + MathFloor(score)
end

function XUiGoldenMinerBattle:UpdateTextCurScore()
    local score = self.CurMapScore
    if not self.OriginScore then
        self.OriginScore = score
        self.CurScore.text = XUiHelper.GetText("GoldenMinerPlayCurScore", self.CurMapScore)
    elseif self.OriginScore ~= score then
        self:PlayCurScoreChangeAnima(score - self.OriginScore, self.OriginScore)
        self.OriginScore = score
    end
end

-- 获得抓取物额外buff
function XUiGoldenMinerBattle:OnGetObjScoreExBuff(score)
    if XTool.IsTableEmpty(self.GetObjExBuffIdList) then
        return score
    end
    for buffType, params in pairs(self.GetObjExBuffIdList) do
        -- 抓取物浮动
        if buffType == XGoldenMinerConfigs.BuffType.GoldenMinerValueFloat then
            local percent = GetPercentRate(math.random(params[1], params[2]) / PERCENT)
            return MathCeil(score * percent)
        end
    end
    return score
end

--检查红包箱是否能获得道具
function XUiGoldenMinerBattle:CheckRedEnvelopeItem(goldenMinerObject)
    local dataDb = self.DataDb
    local itemColumnIndex = dataDb:GetEmptyItemIndex()
    if not goldenMinerObject.GetItemId or not itemColumnIndex then
        return
    end

    local itemId = goldenMinerObject:GetItemId()
    if not XTool.IsNumberValid(itemId) then
        return
    end

    dataDb:UpdateItemColumn(itemId, itemColumnIndex)
    self.ItemPanel:UpdateItemColumns()
    self:PlayGetItemAnim(itemId)
    self:UpdateItemChangeInfo(itemColumnIndex, XGoldenMinerConfigs.ItemChangeType.OnGet)
end

function XUiGoldenMinerBattle:AddCurMapScore(score)
    if XTool.IsNumberValid(score) then
        XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetAddScoreSound(), XSoundManager.SoundType.Sound)
    end
    self.CurMapScore = math.floor(self.CurMapScore + score)
end

function XUiGoldenMinerBattle:RemoveCurTriggerObjDic(isBoom)
    self:DestroyAllChildObj(isBoom)
    self:UpdateCurShortenSpeed()
end

function XUiGoldenMinerBattle:DestroyAllChildObj(isBoom)
    for _, v in pairs(self.CurTriggerObjDic) do
        v:DestroySelf(isBoom)
    end
    self.CurTriggerObjDic = {}
end

--没物品可以抓时直接游戏结束
function XUiGoldenMinerBattle:CheckGameOver()
    local transform = self.PanelStone.transform
    local childCount = transform.childCount
    -- 全部物体被抓
    if not XTool.IsNumberValid(childCount) then
        self:GameOver()
        return
    end
    -- 除了延迟生成的物体全部被抓
    local enabledCount = 0
    for i = 0, childCount-1, 1 do
        if transform:GetChild(i).gameObject.activeSelf then
            enabledCount = enabledCount + 1
        end
    end
    if not XTool.IsNumberValid(enabledCount) then
        self:GameOver()
    end
end

function XUiGoldenMinerBattle:GameOver()
    self:StopTimer()
    self:UpdateSettlementInfo(true)

    local curMapScore = self.CurMapScore
    local mapId = self.MapId
    local curStageId = self.CurStageId
    local lastTimeScore = self:GetLastTimeScore()
    self.IsWin = curMapScore + lastTimeScore >= self.TargetScoreData

    local closeCb = handler(self, self.CheckGameState)
    local isCloseFunc = handler(self, self.GetIsCloseBattle)
    local data = {
        CurStageId = curStageId,
        CurMapId = mapId,
        CurStageIndex = self.CurStageIndex,
        BeforeScore = self.BeforeScore,
        CurMapScore = curMapScore,
        GoldenMinerObjectList = self.CurTriggerObjSettleList,
        GoldenMinerObjectScoreDir = self.CurTriggerObjSettleScoreDir,
        TargetScore = self.TargetScoreData,
        LastTime = MathFloor(self.LastTime),
        LastTimeScore = lastTimeScore
    }
    XLuaUiManager.Open("UiGoldenMinerReport", data, closeCb, isCloseFunc)
    XDataCenter.GoldenMinerManager.RequestGoldenMinerFinishStage(curStageId, self.SettlementInfo, curMapScore + lastTimeScore, function(isFinishSuccess)
        self.IsCloseBattle = true
        self.IsFinishSuccess = isFinishSuccess
    end, self.IsWin)
end

-- 计算剩余时间分数
function XUiGoldenMinerBattle:GetLastTimeScore()
    local score = 0
    local countTime = MathCeil(self.LastTime)
    local scoreGroup = XGoldenMinerConfigs.GetScoreGroupIdList()
    for index, scoreId in ipairs(scoreGroup) do
        if countTime <= 0 then
            return score
        end
        local countMaxTime = XGoldenMinerConfigs.GetLastTimeMax(scoreId)
        local countPerPoint = XGoldenMinerConfigs.GetPerTimePoint(scoreId)
        if index <= 1 then
            if countTime > countMaxTime then
                score = score + countPerPoint * countMaxTime
            else
                score = score + countPerPoint * countTime
            end
            countTime = countTime - countMaxTime
        else
            local needCountTime = countMaxTime - XGoldenMinerConfigs.GetLastTimeMax(scoreGroup[index-1])
            if countTime > needCountTime then
                score = score + countPerPoint * needCountTime
            else
                score = score + countPerPoint * countTime
            end
            countTime = countTime - needCountTime
        end
    end
    return score
end

function XUiGoldenMinerBattle:GetIsCloseBattle()
    return self.IsCloseBattle
end

--刷新发给后端的关卡结算数据
function XUiGoldenMinerBattle:UpdateSettlementInfo(isTimeSettle)
    local mapId = self.MapId
    local mapTime = XGoldenMinerConfigs.GetMapTime(mapId)
    local addScore = self.CurMapScore - self.BeforeScore
    if isTimeSettle then
        addScore = addScore + self:GetLastTimeScore()
    end
    self.SettlementInfo:SetMoveCount(self.MoveCount)
    self.SettlementInfo:SetScores(addScore)
    self.SettlementInfo:SetCostTime(MathFloor(mapTime - self.LastTime))
    self.SettlementInfo:UpdateGrabDataInfos(self.CurTriggerObjSettleList)
end

function XUiGoldenMinerBattle:ResourceManagerLoad(path)
    local resource = self.ResourcePool[path]
    if resource then
        return resource
    end
    resource = CSXResourceManagerLoad(path)
    if resource == nil or not resource.Asset then
        XLog.Error(string.format("XUiGoldenMinerBattle:ResourceManagerLoad加载资源，路径：%s", path))
        return
    end

    self.ResourcePool[path] = resource
    return resource
end

--加载特效
function XUiGoldenMinerBattle:LoadEffect(path, parent, localPosition)
    if XTool.UObjIsNil(parent) then
        return
    end

    local model = self.EffectPool[path]
    if XTool.UObjIsNil(model) then
        local resource = self:ResourceManagerLoad(path)
        model = XUiHelper.Instantiate(resource.Asset, parent)
        self.EffectPool[path] = model
    end

    model.transform.localPosition = localPosition or Vector3.zero

    model.gameObject:SetActiveEx(false)
    model.gameObject:SetActiveEx(true)
    return model
end

--加载具有全屏要求的ui层级特效-parent需要具有XUiEffectLayer控件
function XUiGoldenMinerBattle:LoadFullEffect(path, parent, active)
    if XTool.UObjIsNil(parent) then
        return
    end
    parent.gameObject:SetActiveEx(false)
    if XTool.UObjIsNil(self.EffectPool[path]) then
        self.EffectPool[path] = XUiHelper.Instantiate(parent.gameObject, parent.transform.parent)
    end
    self.EffectPool[path].gameObject:SetActiveEx(false)
    if active == nil or active then
        self.EffectPool[path].gameObject:SetActiveEx(true)
        self.EffectPool[path].gameObject:LoadUiEffect(path)
    end
end

function XUiGoldenMinerBattle:CheckGameState()
    local nextStageId = self.DataDb:GetCurStageId()
    if (not self.IsWin or not nextStageId) or (not self.IsFinishSuccess and self.CurStageIndex == 1) then
        XLuaUiManager.PopThenOpen("UiGoldenMinerMain")
        return
    end
    XLuaUiManager.PopThenOpen("UiGoldenMinerShop")
end

function XUiGoldenMinerBattle:SetHumenEffectActive(isActive)
    if self.HumenEffect then
        self.HumenEffect.gameObject:SetActiveEx(isActive)
    end
end

function XUiGoldenMinerBattle:GetBoomObj(index)
    for _, boomObj in ipairs(self.BoomObjList) do
        if boomObj:GetIndex() == index then
            return boomObj
        end
    end
end

local _deltaTime
function XUiGoldenMinerBattle:GetDeltaTime()
    _deltaTime = CSUnityEngineTime.deltaTime
    --防止卡顿跳帧
    if _deltaTime > 0.05 then
        _deltaTime = 0.05
    end
    return _deltaTime
end

--检查绳子的音效播放
function XUiGoldenMinerBattle:CheckRopeSoundPlay()
    local curState = self:GetCurState()
    if curState == RopeState.Stretch then
        XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetStretchSound(), XSoundManager.SoundType.Sound)
    elseif curState == RopeState.Shorten then
        XSoundManager.PlaySoundByType(XGoldenMinerConfigs.GetShortenSound(), XSoundManager.SoundType.Sound)
    end
end

function XUiGoldenMinerBattle:StopRopeSoundPlay()
    XSoundManager.Stop(XGoldenMinerConfigs.GetShortenSound())
    XSoundManager.Stop(XGoldenMinerConfigs.GetStretchSound())
end

---------------抓取成功播放动画 begin----------------
function XUiGoldenMinerBattle:PlayCurScoreChangeAnima(changeScore, originScore)
    self:ShowCurScoreChange("+" .. changeScore)
    self:StopCurScoreChangeAnima()

    local scores = self.DataDb:GetStageScores()
    self.CurScoreChangeAnima = XUiHelper.Tween(1, function(f)
        self:ShowCurScoreChange("+" .. changeScore)
        self.CurScore.text = XUiHelper.GetText("GoldenMinerPlayCurScore", math.floor(originScore + changeScore * f))
    end, function()
        self.CurScore.text = XUiHelper.GetText("GoldenMinerPlayCurScore", self.CurMapScore)
    end)

    if self.PanelCurScoreChange then
        self.PanelCurScoreChange.gameObject:SetActiveEx(true)
        self:PlayAnimation("BubbleEnable")
    end
end

function XUiGoldenMinerBattle:StopCurScoreChangeAnima()
    if self.CurScoreChangeAnima then
        XScheduleManager.UnSchedule(self.CurScoreChangeAnima)
        self.CurScoreChangeAnima = nil
    end
end

function XUiGoldenMinerBattle:ShowCurScoreChange(score)
    if self.TxtCurScoreChange then
        self.TxtCurScoreChange.text = score
    end
end

function XUiGoldenMinerBattle:HideCurScoreChange()
    if self.PanelCurScoreChange then
        self.PanelCurScoreChange.gameObject:SetActiveEx(false)
    end
end
---------------抓取成功播放动画 end------------------

--提示动画相关
--==============================================================

function XUiGoldenMinerBattle:InitTipAnimArgs()
    self.AddTimeTipPosition = self.TxtAddTimeTip.transform.position
end

function XUiGoldenMinerBattle:PlayGetItemAnim(itemId)
    self.TxtAddItemTip.gameObject:SetActive(true)
    self.TxtAddItemTip.text = "+1"
    self.TxtAddItemTip.transform.position = self.Humen.transform.position
    self.RImgAddItemIcon:SetRawImage(XGoldenMinerConfigs.GetItemIcon(itemId))
    local endY = self.TxtAddItemTip.transform.localPosition.y + XGoldenMinerConfigs.GetTipAnimMoveLength()
    local time = XGoldenMinerConfigs.GetTipAnimTime() / XScheduleManager.SECOND
    self.TxtAddItemTip.transform:DOLocalMoveY(endY, time)
    XScheduleManager.ScheduleOnce(function()
        if XTool.UObjIsNil(self.GameObject) then
            return
        end
        self.TxtAddItemTip.gameObject:SetActive(false)
    end, XGoldenMinerConfigs.GetTipAnimTime())
end

function XUiGoldenMinerBattle:PlayAddTimeAnim(time)
    self.TxtAddTimeTip.transform.position = self.AddTimeTipPosition
    self.TxtAddTimeTip.gameObject:SetActive(true)
    self.TxtAddTimeTip.text = "+"..time
    local endY = self.TxtAddTimeTip.transform.localPosition.y + XGoldenMinerConfigs.GetTipAnimMoveLength()
    local time = XGoldenMinerConfigs.GetTipAnimTime() / XScheduleManager.SECOND
    self.TxtAddTimeTip.transform:DOLocalMoveY(endY, time)
    XScheduleManager.ScheduleOnce(function()
        if XTool.UObjIsNil(self.GameObject) then
            return
        end
        self.TxtAddTimeTip.gameObject:SetActive(false)
    end, XGoldenMinerConfigs.GetTipAnimTime())
end

--==============================================================