local BattleScheduler = require "app/module/battle/helper/battle_scheduler"
local BattlePassive = require "app/module/battle/helper/battle_passive"
local BattlePool = require "app/module/battle/helper/battle_pool"
local BattleHelper = require "app/module/battle/helper/battle_helper"
local BattleBuffEntity = require "app/userdata/battle/skill/battle_buff_entity"
local BattleTeam = require "app/module/battle/team/battle_team"
local BATTLE_BOARD_SKILL_HANDLE = require "app/module/battle/skill/battle_board_skill_handle"
local BATTLE_ROGUE_SKILL_HANDLE = require "app/module/battle/skill/battle_rogue_skill_handle"
local BATTLE_GRID_EFFECT_HANDLE = require "app/module/battle/skill/battle_grid_effect_handle"
local BATTLE_INSTRUCTIONS_HELPER = require "app/module/battle/helper/battle_instructions_helper"
local BattleBoardTouchHelper = require "app/module/battle/helper/battle_board_touch_helper"
local BattleBuffHandle = require "app/module/battle/helper/battle_buff_handle"
local BATTLE_SNAPSHOT_HELPER = require "app/module/battle/helper/battle_snapshot_helper"
local BOARD_HELER = require "app/module/battle/helper/board_helper"
local BattleFormula = require "app/module/battle/helper/battle_formula"
local BattleBaseController = class("BattleBaseController")
local BattleConst = GConst.BattleConst
local BUFF_NAME_TO_ATTR = BattleConst.BUFF_NAME_TO_ATTR
local GRID_BREAK_CONDITION = BattleConst.GRID_BREAK_CONDITION
local SIDE_ATK = BattleConst.SIDE_ATK
local SIDE_DEF = BattleConst.SIDE_DEF

function BattleBaseController:getPosInfo(posId)
    return ModuleManager.BattleManager:getPosInfo(posId, self:getRowCount())
end

function BattleBaseController:getRowCount()
    return self.battleData:getRowCount()
end

function BattleBaseController:getSkillEntityBySkillId(skillId)
    return self.battleData:getSkillEntityBySkillId(skillId, self.curActionSide)
end

function BattleBaseController:getSkillEntityByElement(elementType)
    return self.battleData:getSkillEntityByElement(elementType, self.curActionSide)
end

function BattleBaseController:isUnlockedSkillElementType(elementType)
    return self.battleData:isUnlockedSkillElementType(elementType, self.curActionSide)
end

function BattleBaseController:getSkillCount(skillId)
    return self.battleData:getSkillCount(skillId, self.curActionSide)
end

function BattleBaseController:getSkillPool()
    return self.battleData:getSkillPool(self.curActionSide)
end

function BattleBaseController:getSkillEntities(side)
    side = side or self.curActionSide
    return self.battleData:getSkillEntities(side)
end

function BattleBaseController:addSkillEnergy(elementMap, side)
    side = side or self.curActionSide
    self.battleData:addSkillEnergy(elementMap, side)
end

-- *************各个子模块的战斗需要重写的方法 START*************
function BattleBaseController:getBoardConfig()
    return {}
end

function BattleBaseController:getChapterConfig()
    return {}
end

function BattleBaseController:getChapterId()
    return 0
end

function BattleBaseController:getBuffs()
    return {}
end

function BattleBaseController:getBattleUIPath()
	return "app/ui/battle/battle_ui"
end

---- 障碍格子图片
function BattleBaseController:getBlockIcon()
    local chapterInfo = self:getChapterConfig()[self.chapterId]
    if not chapterInfo then
        return "battle_hinder_4"
    end
    return chapterInfo.block_icon
end

function BattleBaseController:getChessBoardBgName()
    local chapterInfo = self:getChapterConfig()[self.chapterId]
    if not chapterInfo then
        return "chessboard_1"
    end
    return chapterInfo.chess_board
end

function BattleBaseController:getScene()
    local chapterInfo = self:getChapterConfig()[self.chapterId]
    if not chapterInfo then
        return "bg_1"
    end
    return chapterInfo.scene
end

function BattleBaseController:refreshWave()
    if not self.battleUI then
        return
    end
    self.battleUI:refreshWave(self:getWaveIndex())
end

-- 战斗结束
function BattleBaseController:controllBattleEnd()
end

-- 不同模块的战斗需要初始化的东西
function BattleBaseController:initOther()
end

-- 怪物攻击力加成
function BattleBaseController:getMonsterAtkAddition()
	return 0
end

-- 怪物血量加成
function BattleBaseController:getMonsterHpAddition()
	return 0
end

-- 怪物攻击力固定
function BattleBaseController:getMonsterAtkFixed()
	return 0
end

-- 怪物血量固定
function BattleBaseController:getMonsterHpFixed()
	return 0
end

-- 需要额外加载的资源
function BattleBaseController:loadOtherRes(callback)
	return callback()
end

function BattleBaseController:tick(dt)
end

-- 一共有多少波
function BattleBaseController:getMaxWave()
    local config = self:getChapterConfig()[self.chapterId]
    if not config or not config.monster then
        return 0
    end
    return #config.monster
end

function BattleBaseController:getMinEliminationCount()
    if not self.minEliminationCount then
        self.minEliminationCount = GFunc.getConstIntValue("element_combo")
    end
    return self.minEliminationCount
end

function BattleBaseController:getNextMonsterId(waveIndex)
    waveIndex = waveIndex or self:getWaveIndex() + 1
    local config = self:getChapterConfig()[self.chapterId]
    local monsterId = config.monster[waveIndex]
    return monsterId
end

function BattleBaseController:showBossEnterAni(bornTime, bossName, monsterComp, callback)
    self.battleUI:showBossEnterAni(bornTime, bossName, monsterComp, callback)
end

function BattleBaseController:generateNextMonster()
    local monsterId = self:getNextMonsterId()
    if monsterId == nil then
        return self:enterNextWave()
    end
    local isBoss = self.defTeam:getIsBoss()
    local unitEntity = self.battleData:addMonster(monsterId, true, self)
    local modelId = unitEntity:getModelId()
    BattleHelper:loadBattleHeroModel(modelId, self.battleUI:getBattleNode(), function(spineObject)
        self.defTeam:removeAllUnits()
        local monsterComp = spineObject:addLuaComponent(GConst.BattleConst.TYPEOF_LUA_COMP.BATTLE_MONSTER_COMPONENT)
        monsterComp:initWithEntity(modelId, unitEntity, self)
        self.defTeam:addUnit(monsterComp, true)
        self:handleBuffs(GConst.BattleConst.SIDE_DEF)
        self.battleUI:refreshDefHp(unitEntity:getHp(), unitEntity:getHpPercent())
        local bornTime = monsterComp:getAnimationDuration(GConst.BattleConst.SPINE_ANIMATION_NAME.BORN)
        if isBoss then -- 如果是boss就跑过去
            local count = 0
            local function onFinish()
                count = count + 1
                if count == 2 then
                    self.atkTeam:stopRunAction()
                    self:onRoundEnd(true)
                end
            end
            self.atkTeam:playRunAction()
            self.atkTeam:recoverHpOnWaveOver(onFinish)

            isBoss = self.defTeam:getIsBoss()
            if isBoss then
                local monsterInfo = ConfigManager:getConfig("monster")[monsterId]
                self:showBossEnterAni(bornTime, ModuleManager.HeroManager:getMonsterName(monsterInfo.monster_base), monsterComp, function()
                    monsterComp:playEnterBattlefield(true, onFinish)
                end)
            else
                monsterComp:playEnterBattlefield(true, onFinish)
            end
        else
            local count = 0
            local function onFinish()
                count = count + 1
                if count == 2 then
                    self:onRoundEnd(true)
                end
            end
            self.atkTeam:recoverHpOnWaveOver(onFinish)

            isBoss = self.defTeam:getIsBoss()
            if isBoss then
                local monsterInfo = ConfigManager:getConfig("monster")[monsterId]
                self:showBossEnterAni(bornTime, ModuleManager.HeroManager:getMonsterName(monsterInfo.monster_base), monsterComp, function()
                    monsterComp:playEnterBattlefield(false, onFinish)
                end)
            else
                monsterComp:playEnterBattlefield(false, onFinish)
            end
        end
    end)
end

function BattleBaseController:findNextDefUnit()
    self:generateNextMonster()
end

function BattleBaseController:onDefDead(callback)
    self.defTeam:getMainUnit():playDead(function()
        local monsterId = self.defTeam:getMainUnit().unitEntity:getDeathSummon()
        if monsterId > 0 then
            self:generateMonsterById(monsterId, function()
                self.curWaveMonsterDead = false
                if callback then
                    callback()
                end
                self:handleBuffs(BattleConst.SIDE_DEF)
            end)
        else
            if callback then
                callback()
            end
        end
    end)
end

function BattleBaseController:onLinkChange()
    self.battleUI:hideAllSfxLine()
    self.linkChangeNeedFalsePosMap = table.clearOrCreate(self.linkChangeNeedFalsePosMap)
    for posId, entity in pairs(self.battleData:getGridEnties()) do
        if entity:getCell() then
            self.linkChangeNeedFalsePosMap[posId] = entity:getCell()
        end
    end

    local sequence = self.battleData:getGridSequence()
    local mainElementType
    local dmgSkillId
    for index, info in ipairs(sequence) do
        local entity = self.battleData:getGridEntity(info.posId)
        if not mainElementType or not dmgSkillId then
            local skillId = entity:getSkillId()
            if not skillId and not mainElementType then
                mainElementType = entity:getElementType()
            end
            if skillId and not dmgSkillId then
                dmgSkillId = skillId
            end
            if mainElementType and dmgSkillId then
                break
            end
        end
    end

    local count = #sequence

    for index, info in ipairs(sequence) do
        local entity = self.battleData:getGridEntity(info.posId)
        if entity:getCell() then
            entity:getCell():showHighLight(true, mainElementType, self.battleUI)
        end
        if self.linkChangeNeedFalsePosMap[info.posId] then
            self.linkChangeNeedFalsePosMap[info.posId] = nil
        end
        if index < count then
            local nextPosId = sequence[index + 1].posId
            self.battleUI:getSfxLine(index, function(obj)
                local curPos = self:getPosInfo(info.posId)
                local nextPos = self:getPosInfo(nextPosId)
                local pos, z = ModuleManager.BattleManager:getPosCenterAndDir(curPos, nextPos)
                obj:setLocalScale(25, 25, 25)
                obj:setLocalPosition(pos.x, pos.y, 0)
                obj:setEulerAngles(0, 0, z)
            end)
        end
        if index == count then
            if entity:getCell() then
                entity:getCell():showAni()
            end
        end
    end

    for posId, cell in pairs(self.linkChangeNeedFalsePosMap) do
        cell:showHighLight(false)
    end

    self.teampSkillBreakEnergyMap = table.clearOrCreate(self.teampSkillBreakEnergyMap)
    for posId, info in pairs(self.battleData:getSkillInfluenceGrids()) do
        local entity = self.battleData:getGridEntity(posId)
        if info.direction ~= BattleConst.BOARD_RANGE_TYPE.RANDOM then
            if entity:getCell() then
                entity:getCell():showCircle(true)
                if dmgSkillId then
                    local skillEntity = self.battleData:getSkillEntityBySkillId(dmgSkillId)
                    local multiple = skillEntity and skillEntity:getSkillBreakEnergyMultiple() or 1
                    if multiple > 1 then
                        entity:getCell():setCountStr(skillEntity:getSkillBreakEnergyMultipleStr())
                        local elementType = entity:getElementType()
                        if entity:canLink() and elementType and elementType > 0 then
                            self.teampSkillBreakEnergyMap[elementType] = (self.teampSkillBreakEnergyMap[elementType] or 0) + (multiple - 1)
                        end
                    end
                end
            end
        end
    end

    local dmgElementTypeMap
    if not self:getCurActionUnitComp():getActiveSkillLimit() then
        local aniSequence, influenceElementType, lineCount, elementTypeMap, linkElementType, effectGridMap, randomPosList = self:calculateCurElimination(true)
        dmgElementTypeMap = elementTypeMap
        if randomPosList then
            for _, posId in ipairs(randomPosList) do
                local gridEntity = self.battleData:getGridEntity(posId)
                if gridEntity and gridEntity:canLink() then
                    local elementType = gridEntity:getElementType()
                    if elementTypeMap[elementType] and elementTypeMap[elementType] > 0 then
                        elementTypeMap[elementType] = elementTypeMap[elementType] - 1
                    end
                end
            end
        end
        for elementType, count in pairs(elementTypeMap) do
            self.teampSkillBreakEnergyMap[elementType] = (self.teampSkillBreakEnergyMap[elementType] or 0) + count
        end
        self.battleUI:refreshSkill(elementTypeMap, count > 0, self.curActionSide)
    end

    if mainElementType then
        self:getSideTeam(self.curActionSide):changeMainUnit(mainElementType)
    end

    local elementTypeCount = 0
    if dmgElementTypeMap then
        for element, count in pairs(dmgElementTypeMap) do
            elementTypeCount = elementTypeCount + count
        end
    end
    local dmg = self:calExpectedInjury(mainElementType, elementTypeCount, dmgSkillId)
    local defMainUnitcomp = self:getCurOtherActionUnitComp()
    if defMainUnitcomp then
        local hp = defMainUnitcomp.unitEntity:getHp()
        local hpPercent = (hp - dmg) / defMainUnitcomp.unitEntity:getMaxHp()
        if self.curActionSide == SIDE_ATK then
            self.battleUI:setDefHp(hp, hpPercent)
        else
            self.battleUI:setAtkHp(hp, hpPercent)
        end
    end
end

function BattleBaseController:getInitBoard()
    if not self.boradList then
        self.boradList = {}
        self.fixedRandomGrid = {}
        self.mysteryBoxIndexMap = {}

        local config = self:getChapterConfig()[self.chapterId]
        local boardCfg = self:getBoardConfig()
        for _, boardId in ipairs(config.board) do
            local cfg = boardCfg[boardId]
            if cfg then
                table.insert(self.boradList, {board = GFunc.getTable(cfg.board), mysteryBoard = GFunc.getTable(cfg.mystery_box_board), gridEdge = GFunc.getTable(cfg.grid_edge)})
                table.insert(self.fixedRandomGrid, GFunc.getTable(cfg.control_element))
            end
        end
    end

    return self.boradList, self.fixedRandomGrid, self.mysteryBoxIndexMap
end

function BattleBaseController:getNotInvolvedSkills()
    if not self.notInvolvedSkills then
        self.notInvolvedSkills = {}
        local config = self:getChapterConfig()[self.chapterId]
        if config.not_involved_skill then
            for _, skillId in ipairs(config.not_involved_skill) do
                self.notInvolvedSkills[skillId] = true
            end
        end
    end

    return self.notInvolvedSkills
end

function BattleBaseController:getFixedRogueSkill()
    if not self.fixedRogueSkill then
        self.fixedRogueSkill = {}
    end

    return self.fixedRogueSkill
end

function BattleBaseController:getSealElementType()
    if not self.sealElementType then
        self.sealElementType = {}
        local config = self:getChapterConfig()[self.chapterId]
        if config.seal_element then
            for _, elementType in ipairs(config.seal_element) do
                self.sealElementType[elementType] = true
            end
        end
    end

    return self.sealElementType
end

function BattleBaseController:getAtkMinRow()
    return 0
end

-- *************各个子模块的战斗需要重写的方法 end*************

function BattleBaseController:handleBuffs(side)
    for _, buffInfo in ipairs(self:getBuffs()) do
        local buffEntity = buffInfo.buffEntity
        local buffTargetSide = buffEntity:getTargetSide()
        local target
        if buffTargetSide == BattleConst.SIDE_DEF then
            target = self.defTeam:getMainUnit()
        elseif buffTargetSide == BattleConst.SIDE_ATK then
            target = self.atkTeam:getMainUnit()
        elseif buffTargetSide == BattleConst.SIDE_ATK_ALL then
            if not side or side == buffTargetSide then
                for matchtype, comp in pairs(self.atkTeam:getUnitComp()) do
                    local buffEntity = BattleBuffEntity:create()
                    buffEntity:init(buffInfo.effect, comp.unitEntity)
                    buffEntity:setTargetSide(buffTargetSide)
                    comp:takeEffect(buffEntity, comp)
                end
            end
        else
            local matchType = BattleConst.SIDE_OBJ_TO_MATCH_TYPE[buffTargetSide]
            if matchType then
                target = self.atkTeam:getUnitComp()[matchType]
            end
        end

        if target then
            if side then
                if buffTargetSide == side then
                    buffEntity:setOwner(target)
                    target:takeEffect(buffEntity, target)
                end
            else
                buffEntity:setOwner(target)
                target:takeEffect(buffEntity, target)
            end
        end
    end
end

function BattleBaseController:ctor()
    self.battleData = DataManager.BattleData
end

function BattleBaseController:init(params, snapshot)
    params = params or {}
    self.snapshot = snapshot
    self.params = params
    self.battleType = params.battleType or GConst.BattleConst.BATTLE_TYPE.STAGE
    self.waveDurationTime = 0
    self.totalDurationTime = 0
    self.eliminateCount = 0
    self.eliminateTotalCount = 0
    self.maxLinkCount = 0
    self.realTime = 0
    self.taskProgress = {}
    self.waveRoundCount = {}
    self.lastRoundBreakedGridType = {}
    self.waitingFillCount = 0
    self.needWaitingBoardOver = nil
    self.curWaveMonsterDead = false
    self.totalBreakedGridType = {}
    self.totalEliminateCountMap = {}

    self.curActionSide = SIDE_ATK
    self:resetSideActionCount()
    self.chapterId = self:getChapterId()
    self.waveIndex = 0
    self.maxWaveIndex = self:getMaxWave()
    self.victory = false
    self.roundStep = BattleConst.BATTLE_ROUND_STEP.WAIT_BEGIN
    self.effectTexts = {}
    self.instructions = {}
    self.gotMysteryBoxIndexs = {}
    self.showMysteryBoxIndexs = {}
    self.delayEffectTextList = {}
	self.delayEffectTextCount = 0
    self.time = 0
    self.battleData:setTimeScaleBase(nil) -- 还原
    if snapshot then -- 处理战斗快照
        self:dealSnapshotBattleBaseInfo(snapshot)
        self.battleData:init(params, snapshot.battledataShopInfo)
    else
        self.battleData:init(params)
    end
    BattleScheduler:init()
    BattlePool:init()
    BattleHelper:init()
    BattlePassive:init()
    self:setTimeScale(self.battleData:getTimeScale())
    self:bindData()
    self:initBattleTeam()
    self:initOther()
    self:prepareFight()
end

function BattleBaseController:dealSnapshotBattleExtraInfo(snapshot)
    BATTLE_SNAPSHOT_HELPER:dealSnapshotBattleExtraInfo(self, snapshot)
end

function BattleBaseController:dealSnapshotBattleBaseInfo(snapInfo)
    BATTLE_SNAPSHOT_HELPER:dealSnapshotBattleBaseInfo(self, snapInfo)
end

function BattleBaseController:snapshotBattleInfo()
    BATTLE_SNAPSHOT_HELPER:snapshotBattleInfo(self)
end

function BattleBaseController:bindData()
    self.battleData:bind("timeSpeed", ModuleManager.BattleManager, function()
		self:setTimeScale( self.battleData:getTimeScale())
	end, false)
end

function BattleBaseController:unBindAll()
    self.battleData:unBind("timeSpeed", ModuleManager.BattleManager)
end

function BattleBaseController:initBattleTeam()
    self.atkTeam = BattleTeam:create()
    self.atkTeam:init(BattleConst.SIDE_ATK, self)
    self.defTeam = BattleTeam:create()
    self.defTeam:init(BattleConst.SIDE_DEF, self)
end

function BattleBaseController:resetSideActionCount()
    if not self.sideActionCount then
        self.sideActionCount = {
            [SIDE_ATK] = 1,
            [SIDE_DEF] = 1,
        }
    else
        self.sideActionCount[SIDE_ATK] = 1
        self.sideActionCount[SIDE_DEF] = 1
    end
end

function BattleBaseController:resduceSideActionCount(side)
    if not self.sideActionCount or not self.sideActionCount[side] then
        return false
    end
    if self.sideActionCount[side] > 0 then
        self.sideActionCount[side] = self.sideActionCount[side] - 1
        return true
    else
        return false
    end
end

function BattleBaseController:getSideActionCount(side)
    if not self.sideActionCount or not self.sideActionCount[side] then
        return 0
    end
    return self.sideActionCount[side]
end

function BattleBaseController:getControllerParams()
    return self.params
end

function BattleBaseController:setCurActionSide(side)
    self.curActionSide = side or SIDE_ATK
end

function BattleBaseController:setIsPauseHpProgress(value)
    self.battleUI:setIsPauseHpProgress(value)
end

function BattleBaseController:getIsPvpBattle()
    return BattleConst.IS_PVP_BATTLE[self.battleType] == true
end

function BattleBaseController:moveBattlefield(time)
    self.battleUI:moveBattlefield(time)
end

function BattleBaseController:refreshBuff(side, buffList)
    self.battleUI:refreshBuff(side, buffList)
end

function BattleBaseController:clearBuff(side)
    self.battleUI:clearBuff(side)
end

function BattleBaseController:showBuffTips(side, autoClose)
    if side == BattleConst.SIDE_ATK then
        local buffList = self.atkTeam:getBuffList()
        if #buffList <= 0 then
            return
        end
        self.battleUI:showLeftBuffTips(buffList, autoClose)
    else
        local buffList = self.defTeam:getBuffList()
        if #buffList <= 0 then
            return
        end
        self.battleUI:showRightBuffTips(buffList, autoClose)
    end
end

function BattleBaseController:showCombo(count, side)
    self.battleUI:showCombo(count, side)
end

function BattleBaseController:hideCombo()
    self.battleUI:hideCombo()
end

function BattleBaseController:showCounterAttack(count, side)
    self.battleUI:showCounterAttack(count, side)
end

function BattleBaseController:hideCounterAttack()
    self.battleUI:hideCounterAttack()
end

function BattleBaseController:prepareFight()
    local count = 0
	local totalCount = 3
	local function onPreloadFinished()
		count = count + 1
		if count == totalCount then
			self:onLoadComplete()
		end
	end
    UIManager:closeAllUI()
    self.battleUI = UIManager:showUI(self:getBattleUIPath(), {battleController = self})
	self.battleUI:addLoadUICompleteListener(function()
        BattleHelper:setEffectTextCache(self.battleUI:getBattleNumberRed(),
                                        self.battleUI:getBattleNumberGreen(),
                                        self.battleUI:getBattleNumberBlue(),
                                        self.battleUI:getBattleNumberWhite(),
                                        self.battleUI:getBattleNumberSpecial())
        self:initAtkUnits(onPreloadFinished)
        self:initDefUnits(onPreloadFinished)
        self.battleUI:refreshChessBoard(self:getChessBoardBgName())
        self.battleUI:loadBg(self:getScene())
	end)
    BattleHelper:setBaseOrder(self.battleUI:getUIOrder())
    BattleHelper:setBattleData(self.battleData)
    BattleBoardTouchHelper:init(self)
    self:loadOtherRes(onPreloadFinished)
end

function BattleBaseController:initAtkUnits(callback)
    local atkTeamEntity = self.battleData:getAtkTeam()
    local count = 0
    local totalCount = atkTeamEntity:getMembersCount()
    local function onloadFinished()
		count = count + 1
		if count == totalCount then
            self.battleUI:refreshAtkHp(atkTeamEntity:getHp(), atkTeamEntity:getHpPercent())
			callback()
		end
	end
    local members = atkTeamEntity:getAllMembers()
    for k, v in pairs(members) do
        local modelId = v:getModelId()
        BattleHelper:loadBattleHeroModel(modelId, self.battleUI:getBattleNode(), function(spineObject)
			local heroComp = spineObject:addLuaComponent(BattleConst.TYPEOF_LUA_COMP.BATTLE_HERO_COMPONENT)
			heroComp:initWithEntity(modelId, v, self)
            if v:getIsMainUnit() then
                self.atkTeam:addUnit(heroComp, true)
            else
                self.atkTeam:addUnit(heroComp)
                heroComp:hideOutsideScreen()
            end
			onloadFinished()
		end)
    end
    if totalCount == 0 then
        callback()
    end
end

function BattleBaseController:initDefUnits(callback)
    local initIndex = self:getWaveIndex()
    if initIndex <= 0 then
        initIndex = 1
    end
    local monsterId = self:getNextMonsterId(initIndex)
    local unitEntity = self.battleData:addMonster(monsterId, nil, self)
    local modelId = unitEntity:getModelId()
    BattleHelper:loadBattleHeroModel(modelId, self.battleUI:getBattleNode(), function(spineObject)
        local monsterComp = spineObject:addLuaComponent(BattleConst.TYPEOF_LUA_COMP.BATTLE_MONSTER_COMPONENT)
        monsterComp:initWithEntity(modelId, unitEntity, self)
        self.defTeam:addUnit(monsterComp, true)
        self.battleUI:refreshDefHp(unitEntity:getHp(), unitEntity:getHpPercent())
        callback()
    end)
end

function BattleBaseController:refreshHp(side, num, percent)
    if side == BattleConst.SIDE_ATK then
        self.battleUI:refreshAtkHp(num, percent)
    else
        self.battleUI:refreshDefHp(num, percent)
    end
end

function BattleBaseController:getOtherSideMainUnit(side)
    if side == BattleConst.SIDE_ATK then
        return self.defTeam:getMainUnit()
    else
        return self.atkTeam:getMainUnit()
    end
end

function BattleBaseController:getOtherSideTeam(side)
    if side == BattleConst.SIDE_ATK then
        return self.defTeam
    else
        return self.atkTeam
    end
end

function BattleBaseController:getSideTeam(side)
    if side == BattleConst.SIDE_ATK then
        return self.atkTeam
    else
        return self.defTeam
    end
end

function BattleBaseController:getCurActionTeam(side)
    side = side or self.curActionSide
    local isAtkAction = side == SIDE_ATK
    local team = isAtkAction and self.atkTeam or self.defTeam
    return team
end

function BattleBaseController:getCurActionSide()
    return self.curActionSide
end

function BattleBaseController:getCurActionOtherSide()
    if self.curActionSide == SIDE_ATK then
        return SIDE_DEF
    else
        return SIDE_ATK
    end
end

function BattleBaseController:getCurActionUnitComp()
    return self:getCurActionTeam():getMainUnit()
end

function BattleBaseController:getCurOtherActionUnitComp()
    local side = self:getCurActionOtherSide()
    if not side then
        return
    end
    local team = self:getCurActionTeam(side)
    if not team then
        return
    end
    return team:getMainUnit()
end

function BattleBaseController:getCurActionBoardRowRange(side)
    side = side or self.curActionSide
    local isAtkAction = side == SIDE_ATK
    if isAtkAction then
        return self:getAtkMinRow() + 1, self:getRowCount()
    else
        return 1, self:getAtkMinRow()
    end
end

function BattleBaseController:getPosIdInCurActionBoardRowRange(posId)
    local min, max = self:getCurActionBoardRowRange()
    local r = ModuleManager.BattleManager:getPosRC(posId).r
    if r < min or r > max then
        return false
    end

    return true
end

function BattleBaseController:getPosIdInActionBoardRowRange(side, posId)
    local min, max = self:getCurActionBoardRowRange(side)
    local r = ModuleManager.BattleManager:getPosRC(posId).r
    if r < min or r > max then
        return false
    end

    return true
end

function BattleBaseController:onLoadComplete()
    UIManager:closeLoading()
    self:handleBuffs()
    if self.snapshot then
        self:dealSnapshotBattleExtraInfo(self.snapshot)
    end
    self:battleStart()
end

function BattleBaseController:battleStart()
    self.atkTeam:prepare()
    self.defTeam:prepare()
    self.isBattleStart = true
	self.tickSid = BattleScheduler:scheduleGlobal(function(dt, originDt)
		self:_tick(dt, originDt)
	end, 0)

    if self.snapshot then
        self:enterNextWaveBySnapshot(self.snapshot)
    else
        self:enterNextWave()
    end
end

function BattleBaseController:addTimeSpeed()
    if self.skillSlowDownDuration then
        return
    end
    self.battleData:addTimeSpeed()
end

function BattleBaseController:resetTimeSpeed(isDeadReset)
    if isDeadReset then
        if self.skillSlowDownDuration then
            return
        end
    end

    self.battleData:resetTimeSpeed()
    if self.skillSlowDownDuration then
        self.skillSlowDownDuration = nil
    end
end

function BattleBaseController:setSkillSlowDown(timeScale, duration)
    self.skillSlowDownDuration = duration
    self.battleData:setSkillTimeSpeed(timeScale)
end

function BattleBaseController:setTimeScale(timeScale)
	GFunc.setDOTweenTimeScale(GConst.DOTWEEN_IDS.BATTLE, timeScale)
	BattleScheduler:setTimeScale(timeScale)
	BattleHelper:setTimeScale(timeScale)
end

function BattleBaseController:addWaveIndex(wave)
    local origin = self:getWaveIndex()
    self.waveIndex = GFunc.encryptNumber(origin + wave)
end

function BattleBaseController:setWaveIndex(wave)
    self.waveIndex = GFunc.encryptNumber(wave)
end

function BattleBaseController:getWaveIndex()
    if self.waveIndex <= 0 then
        return 0
    end
    return GFunc.decryptNumber(self.waveIndex)
end

function BattleBaseController:_findNextDefUnit()
    if self.isBossWave then -- 如果上一波是boss波次，则重新生成棋盘
        self:putBoardCacheSkill(function()
            self.atkTeam:onRoundEnd()
            self:findNextDefUnit()
            self:generateBoard()
        end)
    else
        self.atkTeam:onRoundEnd()
        self:findNextDefUnit()
    end
end

---- start 回合步骤
function BattleBaseController:enterNextWave()
    local waveIndex = self:getWaveIndex()
    if waveIndex ~= 0 and self.curWaveMonsterDead then
        if self.isBossWave then
            self:addTaskProgress(BattleConst.BATTLE_TASK_FIELD.KILL_BOSS, 1)
        else
            self:addTaskProgress(BattleConst.BATTLE_TASK_FIELD.KILL_NORMAL_MONSTER, 1)
        end
        self:setTaskProgress(BattleConst.BATTLE_TASK_FIELD.PASS_WAVE, waveIndex)
    end

    if waveIndex >= self.maxWaveIndex then
        self.victory = self.curWaveMonsterDead
        self:postWaveOver(not self.curWaveMonsterDead)
        self:battleEnd()
        return
    end

    local atkTeam = self.battleData:getAtkTeam()
    if not atkTeam or atkTeam:getIsDead() then
        self.victory = false
        self:postWaveOver(true)
        self:battleEnd()
        return
    end

    if waveIndex ~= 0 then -- 第一波
        self:postWaveOver(false)
    end

    self.curWaveMonsterDead = false
    self:addWaveIndex(1)
    waveIndex = self:getWaveIndex()
    self:refreshWave(waveIndex)
    if waveIndex == 1 then -- 第一波
        self.needWaitingBoardOver = true
        self:generateBoard(true)
    else
        -- 上报关卡结束
        self.defTeam:prepare()
    end

    self.waveDurationTime = 0
    self.eliminateCount = 0

    self:snapshotBattleInfo()

    self.isBossWave = self.defTeam:getMainUnit().unitEntity:getIsBoss()
    self:postFightStart()
    if not self.needWaitingBoardOver then
        self:enterRoundBegin()
    end
    if not self.isBossWave then
        self.battleUI:hideBuffTips()
    end
end

function BattleBaseController:enterNextWaveBySnapshot(snapShot)
    local atkTeam = self.battleData:getAtkTeam()
    if not atkTeam or atkTeam:getIsDead() then
        self.victory = false
        self:battleEnd()
        return
    end

    self.curWaveMonsterDead = false
    self:refreshWave(self:getWaveIndex())
    self.needWaitingBoardOver = true
    self:generateBoard(true, snapShot)

    self.waveDurationTime = 0
    self.eliminateCount = 0

    self:snapshotBattleInfo()

    self.isBossWave = self.defTeam:getMainUnit().unitEntity:getIsBoss()
    self:postFightStart()
    if not self.needWaitingBoardOver then
        self:enterRoundBegin()
    end
    if not self.isBossWave then
        self.battleUI:hideBuffTips()
    end
end

function BattleBaseController:enterRoundBegin()
    self.battleData:clearBreakGridEdgeTag()
    self:hideTouchCancel()
    self:resetSideActionCount()
    self:setCurActionSide(SIDE_ATK)
    self.needWaitingBoardOver = nil
    local waveIndex = self:getWaveIndex()
    self.waveRoundCount[waveIndex] = (self.waveRoundCount[waveIndex] or 0) + 1
    self.battleUI:enterShowBoardAni(function()
        self:enterEliminationBegin()
    end)
    table.clear(self.lastRoundBreakedGridType)
end

function BattleBaseController:takeGridEffect()
    local haveGridEffectSucc = false
    local gridEntities = self.battleData:getGridEnties()
    local effectGrid = {}
    for posId, entity in pairs(gridEntities) do
        if entity:getEffectType() then
            table.insert(effectGrid, entity)
        end
    end

    effectGrid = table.shuffle(effectGrid)
    local availableEffectTypeMap
    for _, entity in ipairs(effectGrid) do
        local effectType = entity:getEffectType()
        if effectType ~= BattleConst.GRID_EFFECT_TYPE.CROSS_MOVE_NOT_BREAK and (not availableEffectTypeMap or not availableEffectTypeMap[effectType]) then
            local succ = BATTLE_GRID_EFFECT_HANDLE.gridEffectOn(entity:getPosId(), gridEntities, BattleConst.GRID_EFFECT_TRIGGER_TYPE.ON_ROUND_BEGIN, self)
            if succ and (effectType == BattleConst.GRID_EFFECT_TYPE.CROSS_SPREAD or
                        effectType == BattleConst.GRID_EFFECT_TYPE.CROSS_SPREAD_NOT_BREAK) then
                if not availableEffectTypeMap then
                    availableEffectTypeMap = {}
                end
                availableEffectTypeMap[effectType] = true
                haveGridEffectSucc = succ
            end
        end
    end

    for _, entity in ipairs(effectGrid) do -- gridEffect == 6的最后处理
        local effectType = entity:getEffectType()
        if effectType == BattleConst.GRID_EFFECT_TYPE.CROSS_MOVE_NOT_BREAK and (not availableEffectTypeMap or not availableEffectTypeMap[effectType]) then
            local succ = BATTLE_GRID_EFFECT_HANDLE.gridEffectOn(entity:getPosId(), gridEntities, BattleConst.GRID_EFFECT_TRIGGER_TYPE.ON_ROUND_BEGIN, self)
            if succ then
                if not availableEffectTypeMap then
                    availableEffectTypeMap = {}
                end
                availableEffectTypeMap[effectType] = true
                haveGridEffectSucc = succ
            end
        end
    end

    return haveGridEffectSucc
end

function BattleBaseController:enterEliminationBegin()
    self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_BEGIN
    self:enterRefreshBoard(true, function()
        local haveGridEffectSucc = self:takeGridEffect()
        if haveGridEffectSucc then -- 如果成功，则等待效果播放完成后，进入消除逻辑
            if self.haveGridEffectSuccSid then
                ModuleManager.BattleManager:unscheduleGlobal(self.haveGridEffectSuccSid)
                self.haveGridEffectSuccSid = nil
            end
            ModuleManager.BattleManager:performWithDelayGlobal(function()
                self:enterElimination(true)
            end, 1.1)
        else
            self:enterElimination(true)
        end
    end)
end

function BattleBaseController:enterElimination(needDelay)
    if self.haveGridEffectSuccSid then
        ModuleManager.BattleManager:unscheduleGlobal(self.haveGridEffectSuccSid)
        self.haveGridEffectSuccSid = nil
    end

    if self.showSelectSkillSid then
        ModuleManager.BattleManager:unscheduleGlobal(self.showSelectSkillSid)
        self.showSelectSkillSid = nil
    end

    if self.battleData:useAddlvCount() then
        self:tryShowSelectSkillComp(needDelay)
        return
    end

    self.battleUI:hideAllBoardSfxs()

    -- 检查棋盘
    local find, pathList = self:findAttention()
    if not find then -- 如果没找到，就要打乱棋盘
        self:shuffleBoard(function()
            self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_ELIMINATION
        end)
    else
        self.attentionList = pathList
        -- ModuleManager.BattleManager:performWithDelayGlobal(function()
        --     for _, posId in ipairs(pathList) do
        --         local entity = self.battleData:getGridEntity(posId)
        --         if entity and entity:getCell() then
        --             entity:getCell():showAni()
        --         end
        --     end
        -- end, 2)
        self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_ELIMINATION
    end
end

function BattleBaseController:enterBattleStep()
    self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_TEAM_ACTION
    self.battleTeamActionList = table.clearOrCreate(self.battleTeamActionList)

    local atkAction = function()
        self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_ATK_STEP
        self:exeInstructions(function()
            self:enterNextTeamAction()
        end, self.curActionSide)
    end

    local defAction = function()
        self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_DEF_STEP
        self.defTeam:mainUnitUseAllSkills(BattleConst.ATTACK_ACTION_STATE.NORMAL, function()
            self:enterNextTeamAction()
        end)
    end

    if self.battleData:getAtkTeam():getFirstHand() < self.battleData:getDefTeam():getFirstHand() then
        self:addTeamActionList(defAction, 1)
        self:addTeamActionList(atkAction, 2)
    else
        self:addTeamActionList(atkAction, 1)
        self:addTeamActionList(defAction, 2)
    end

    self:enterNextTeamAction()
end


function BattleBaseController:addTeamActionList(func, index)
    if not self.battleTeamActionList then
        self.battleTeamActionList = {}
    end

    index = index or 1
    table.insert(self.battleTeamActionList, index, func)
end

function BattleBaseController:enterNextTeamAction()
    self.atkTeam:onActionOver()
    self.defTeam:onActionOver()

    self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_TEAM_ACTION_OVER
    self:hideCombo()
    self:hideCounterAttack()

    self:checkTeamIsDead(function() self:enterRoundEnd() end, function()
        if not self.battleTeamActionList or not self.battleTeamActionList[1] then
            self:enterRoundEnd()
            return
        end
    
        local action = table.remove(self.battleTeamActionList, 1)
        action()
    end)
end

function BattleBaseController:checkTeamIsDead(callback, falseCallback)
    local defTeam = self.battleData:getDefTeam()
    local atkTeam = self.battleData:getAtkTeam()
    if atkTeam:getIsDead() and defTeam:getIsDead() then -- 都死了，直接结算
        self.curWaveMonsterDead = true
        self:enterNextWave()
        return true
    end

    if not defTeam or defTeam:getIsDead() then -- 怪物死了， 直接进入刷新逻辑
        self.curWaveMonsterDead = true
        self:onDefDead(function()
            self.defTeam:removeAllBuff()
            if self.battleData:getDefTeam():getIsDead() then
                if self:getWaveIndex() >= self.maxWaveIndex then
                    if callback() then
                        callback()
                    end
                else
                    self:_findNextDefUnit()
                end
            else
                if callback() then
                    callback()
                end
            end
        end)
        return true
    end

    if not atkTeam or atkTeam:getIsDead() then -- 英雄死了， 直接结算
        self:enterNextWave()
        return true
    end

    if falseCallback then
        falseCallback()
    end
end

function BattleBaseController:getIsAtkStep()
    return self.roundStep == BattleConst.BATTLE_ROUND_STEP.ON_ATK_STEP
end

function BattleBaseController:enterRefreshBoard(isRoundBeginCheck, callback)
    if not isRoundBeginCheck then
        self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_REFRESH_BOARD
    end
    self.onFillBoardOverCallback = callback
    self.isRoundBeginCheck = isRoundBeginCheck
    if self.isRoundBeginCheck and self.waitingFillCount > 0 then
        self.isWaitingFill = true
        return
    end

    self:fillBoard(self.isRoundBeginCheck)
end

function BattleBaseController:enterRoundEnd()
    self.roundStep = BattleConst.BATTLE_ROUND_STEP.ON_END
    local defTeam = self.battleData:getDefTeam()
    if not defTeam or defTeam:getIsDead() then -- 怪物死了， 直接进入刷新逻辑
        self.curWaveMonsterDead = true
        self.atkTeam:onRoundEnd()
        self:enterNextWave()
        return
    end

    local atkTeam = self.battleData:getAtkTeam()
    if not atkTeam or atkTeam:getIsDead() then -- 英雄死了， 直接结算
        self.defTeam:onRoundEnd()
        self:enterNextWave()
        return
    end

    self.atkTeam:onRoundEnd()
    self.defTeam:onRoundEnd()

    self:checkTeamIsDead(function() self:enterNextWave() end, function()
        self:onRoundEnd()
    end)
end

function BattleBaseController:onRoundEnd(toNextWave)
    if toNextWave then
        self:enterNextWave()
    else
        self:enterRoundBegin()
    end
end

---- end回合步骤
function BattleBaseController:onTouchEvent(eventType, posId, isVirtual)
    BattleBoardTouchHelper:onTouchEvent(eventType, posId, isVirtual)
end

function BattleBaseController:showTouchCancel()
    self.battleUI:showTouchCancel()
end

function BattleBaseController:hideTouchCancel()
    self.battleUI:hideTouchCancel()
end

function BattleBaseController:clearGridSequence()
    self:hideTouchCancel()
    local sequence = self.battleData:getGridSequence()
    local count = #sequence
    if count <= 0 then
        self.battleData:clearGridSequence()
        self:onLinkChange()
        return
    end

    local snapshot = self.battleData:getFirstSequenceSnapshot()
    if snapshot then -- 如果有快照，则恢复一次
        for posId, info in pairs(snapshot) do
            self.battleData:setInfoBySnapshop(posId, info)
        end
    end

    self.battleData:clearGridSequence()
    self:onLinkChange()
end

function BattleBaseController:onLinkOver()
    local hp = self.atkTeam:getMainUnit().unitEntity:getHp()
    local hpPercent = self.atkTeam:getMainUnit().unitEntity:getHpPercent()
    self.battleUI:setAtkHp(hp, hpPercent)

    local hp = self.defTeam:getMainUnit().unitEntity:getHp()
    local hpPercent = self.defTeam:getMainUnit().unitEntity:getHpPercent()
    self.battleUI:setDefHp(hp, hpPercent)

    self.battleUI:hideAllSfxLine()
    local sequence = self.battleData:getGridSequence()
    local count = #sequence
    if count < self:getMinEliminationCount() then
        return
    end

    local isAtkAction = self.curActionSide == SIDE_ATK
    local skillId = self.battleData:getSequenceHadSkill()
    local skillEntity
    if skillId then
        skillEntity = self:getSkillEntityBySkillId(skillId)
        if isAtkAction then
            self:addTaskProgress(BattleConst.BATTLE_TASK_FIELD.BOARD_SKILL_RELEASE_COUNT, 1)
        end
    end

    self.teampSkillBreakEnergyMap = table.clearOrCreate(self.teampSkillBreakEnergyMap)
    if skillEntity then
        for posId, info in pairs(self.battleData:getSkillInfluenceGrids()) do
            local entity = self.battleData:getGridEntity(posId)
            if entity then
                local multiple = skillEntity and skillEntity:getSkillBreakEnergyMultiple() or 1
                if multiple > 1 then
                    entity:getCell():setCountStr(skillEntity:getSkillBreakEnergyMultipleStr())
                    local elementType = entity:getElementType()
                    if entity:canLink() and elementType and elementType > 0 then
                        self.teampSkillBreakEnergyMap[elementType] = (self.teampSkillBreakEnergyMap[elementType] or 0) + (multiple - 1)
                    end
                end
            end
        end
    end

    local aniSequence, influenceElementTypeMap, lineCount, elementTypeMap, linkElementType, effectGridMap = self:calculateCurElimination()

    if not self:getCurActionUnitComp():getActiveSkillLimit() then
        for elementType, count in pairs(elementTypeMap) do
            self.teampSkillBreakEnergyMap[elementType] = (self.teampSkillBreakEnergyMap[elementType] or 0) + count
        end
        self:addSkillEnergy(self.teampSkillBreakEnergyMap)
    end
    self.battleData:clearGridSequence()
    self.battleUI:disableUITouch()
    self.battleUI:eliminationAni(aniSequence, effectGridMap, function()
        self:enterRefreshBoard(nil, function()
            self:onLinkOverDone(skillEntity, linkElementType, lineCount, influenceElementTypeMap, elementTypeMap)
        end)
    end, self.curActionSide)

    for element, count in pairs(elementTypeMap) do
        self.totalEliminateCountMap[element] = (self.totalEliminateCountMap[element] or 0) + count
    end

    self.eliminateCount = self.eliminateCount + 1
    self.eliminateTotalCount = self.eliminateTotalCount + 1
    if count > self.maxLinkCount then
        self.maxLinkCount = count
    end
end

function BattleBaseController:onLinkOverDone(skillEntity, linkElementType, lineCount, influenceElementTypeMap, elementTypeMap)
    self.battleUI:enterHideBoardAni(function()
        self:generateInstructions(skillEntity, linkElementType, lineCount, influenceElementTypeMap, elementTypeMap)
        self:enterBattleStep()
    end)
end

function BattleBaseController:calculateCurElimination(onlyCheck)
    local sequence = self.battleData:getGridSequence()
    local skillId = self.battleData:getSequenceHadSkill()
    local skillEntity
    if skillId then
        skillEntity = self:getSkillEntityBySkillId(skillId)
    end
    self.breakedMap = table.clearOrCreate(self.breakedMap)
    self.boomGridIds = table.clearOrCreate(self.boomGridIds)
    self.sequenceMap = table.clearOrCreate(self.sequenceMap)
    self.aniSequence = table.clearOrCreate(self.aniSequence)
    for idx, info in ipairs(sequence) do
        self.sequenceMap[info.posId] = idx
    end

    local time = 0
    local skillTime = BattleConst.SKILL_ELIMINATION_TIME
    for idx, info in ipairs(sequence) do
        local posId = info.posId
        self:dealGridBreak(posId, GRID_BREAK_CONDITION.LINE, time, self.breakedMap, self.sequenceMap, self.aniSequence, self.boomGridIds, onlyCheck)
        time = time + BattleConst.ELIMINATION_INTERVAL
    end

    local randomPosList, influenceElementTypeMap
    for i, info in ipairs(self.aniSequence) do
        if info.isSkill and skillEntity then
            randomPosList, influenceElementTypeMap = self:dealSkillElement(info.timeIdx + skillTime, self.breakedMap, self.sequenceMap, self.aniSequence, self.boomGridIds, onlyCheck)
            local aniUnit = self.aniSequence[i]
            if not BattleConst.NO_EFFECT_GRID_SKILL_TYPE[skillEntity:getSkillType()] then
                aniUnit.rangeList = skillEntity:getBoardRange()
                aniUnit.randomPosList = randomPosList
            end
            break
        end
    end

    self.elementTypeMap = table.clearOrCreate(self.elementTypeMap)
    self.effectGridMap = table.clearOrCreate(self.effectGridMap)
    local linkElementType
    local lineCount = 0
    local gridEntities = self.battleData:getGridEnties()
    for _, info in ipairs(self.aniSequence) do
        local entity = gridEntities[info.posId]
        local elementType = entity:getElementType()
        if not info.noAni and info.isIdle then
            if not info.isSkill then
                if not entity:isElmentTypeInvalid() then
                    self.elementTypeMap[elementType] = (self.elementTypeMap[elementType] or 0) + 1
                end
                if self.boomGridIds[info.posId] and self.boomGridIds[info.posId][GRID_BREAK_CONDITION.LINE] then
                    lineCount = lineCount + 1
                    linkElementType = elementType
                end
            end
        end
        if entity:getEffectType() and info.isIdle then
            self.effectGridMap[info.posId] = true
        end
    end

    return self.aniSequence, influenceElementTypeMap, lineCount, self.elementTypeMap, linkElementType, self.effectGridMap, randomPosList
end

function BattleBaseController:dealGridBreak(posId, condition, time, breakedMap, sequenceMap, aniSequence, gridMap, onlyCheck)
    self:setGridBreakCondition(gridMap, posId, condition)
    if breakedMap[posId] or (sequenceMap[posId] and condition ~= GRID_BREAK_CONDITION.LINE) then
        return
    end

    local gridEntities = self.battleData:getGridEnties()
    local entity = gridEntities[posId]
    local breaked, isIdle = entity:tryBreakGrid(condition, true)
    local aniUnit = self:getEliminattionAniInfo(posId, time)
    aniUnit.noAni = entity:isElmentTypeInvalid()
    aniUnit.isIdle = isIdle
    if entity:getSkillId() then
        aniUnit.isSkill = true
    end

    if breaked or entity:canBreakByThisCondition(condition) then
        breakedMap[posId] = true

        aniUnit.breakSfxName = entity:getBreakSfx()
        aniUnit.callback = function()
            local gridType = entity:getGridType()
            self.lastRoundBreakedGridType[gridType] = true
            self.totalBreakedGridType[gridType] = (self.totalBreakedGridType[gridType] or 0) + 1
            entity:tryBreakGrid(condition)
            if entity:getIsIdle() then
                self:dealGridEdge(posId)
            end
        end

        table.insert(aniSequence, aniUnit)
    end

    if isIdle then
        if condition == GRID_BREAK_CONDITION.LINE then
            local outline = BattleConst.UP_DOWN_LEFT_RIGHT[posId]
            for _, id in ipairs(outline) do
                if self.battleData:getGridEntity(id) then
                    if not BOARD_HELER:hasGridEdgeBetween(self, posId, id) then
                        self:dealGridBreak(id, GRID_BREAK_CONDITION.AROUND, time, breakedMap, sequenceMap, aniSequence, gridMap, onlyCheck)
                    end
                end
            end
        end
        if entity:getEffectType() then
            local succ, list = BATTLE_GRID_EFFECT_HANDLE.gridEffectOn(posId, gridEntities, BattleConst.GRID_EFFECT_TRIGGER_TYPE.ON_GRID_BREAK, self, onlyCheck)
            if list then
                aniUnit.aniPosList = table.clearOrCreate(aniUnit.aniPosList)
                aniUnit.overCallback = aniUnit.callback
                aniUnit.callback = nil
                for index, id in ipairs(list) do
                    if id ~= posId then
                        local timeIdx = time + BattleConst.GRID_BREAK_EFFECT_INTERVAL * (index - 1) -- 因为第一个是自己，所以-1
                        self:dealGridBreak(id, GRID_BREAK_CONDITION.SKILL, timeIdx, breakedMap, sequenceMap, aniSequence, gridMap, onlyCheck)
                        table.insert(aniUnit.aniPosList, id)
                    end
                end

                ---- 技能效果特效
                aniUnit.effectSfxName = entity:getEffectSfx()
                aniUnit.effectSfxFlow = entity:getEffectSfxFlow()
                aniUnit.effectSfxDir = entity:getEffectParams()[1]
            end
        end
        aniUnit.bftcTime = entity:getBftcTime()
        if entity:getBreakFlyToCharacter() then
            aniUnit.breakFlyToCharacter = true
            aniUnit.noAni = false
            aniUnit.overCallback = aniUnit.callback
            aniUnit.callback = nil
            if entity:getBreakFlyToCharacterIcon() then
                aniUnit.callback = function()
                    local cell = entity:getCell()
                    if not cell then
                        return
                    end
                    cell:setGridTypeIcon(entity:getBreakFlyToCharacterIcon())
                    self:dealGridEdge(posId)
                end
            end
        end
    end

    return isIdle
end

function BattleBaseController:dealGridEdge(posId)
    -- 能进来一定已经可以消除了
    if not self.upDownLeftRightList then
        self.upDownLeftRightList = {BattleConst.BOARD_RANGE_TYPE.UP, BattleConst.BOARD_RANGE_TYPE.DOWN, BattleConst.BOARD_RANGE_TYPE.LEFT, BattleConst.BOARD_RANGE_TYPE.RIGHT}
        self.upDownLeftRightOppositeMap = {
            [BattleConst.BOARD_RANGE_TYPE.UP] = BattleConst.BOARD_RANGE_TYPE.DOWN,
            [BattleConst.BOARD_RANGE_TYPE.DOWN] = BattleConst.BOARD_RANGE_TYPE.UP,
            [BattleConst.BOARD_RANGE_TYPE.LEFT] = BattleConst.BOARD_RANGE_TYPE.RIGHT,
            [BattleConst.BOARD_RANGE_TYPE.RIGHT] = BattleConst.BOARD_RANGE_TYPE.LEFT
        }
    end

    for _, direction in ipairs(self.upDownLeftRightList) do
        -- 周围的
        local aroundId = ModuleManager.BattleManager:getPosByDirection(posId, direction, self.battleData:getRowCount())
        if aroundId then
            local breaked, breakSfx, breakCount, cell = self.battleData:breakGridEdge(aroundId, self.upDownLeftRightOppositeMap[direction])
            if breaked and breakSfx and breakCount and cell then
                if self.battleUI then
                    self.battleUI:getSfxGridEdgeBreak(breakSfx, breakCount, function(obj)
                        local posX, posY = cell:getBaseObject():fastGetAnchoredPosition()
                        obj:setLocalPosition(posX, posY, 0)
                        obj:play()
                    end)
                end
            end
        end

        -- 本身
        local breaked, breakSfx, breakCount, cell = self.battleData:breakGridEdge(posId, direction)
        if breaked and breakSfx and breakCount and cell then
            if self.battleUI then
                self.battleUI:getSfxGridEdgeBreak(breakSfx, breakCount, function(obj)
                    local posX, posY = cell:getBaseObject():fastGetAnchoredPosition()
                    obj:setLocalPosition(posX, posY, 0)
                    obj:play()
                end)
            end
        end
    end
end

function BattleBaseController:dealSkillElement(time, breakedMap, sequenceMap, aniSequence, boomGridIds, onlyCheck)
    local randomPosList
    local influenceElementTypeMap = {}
    for posId, info in pairs(self.battleData:getSkillInfluenceGrids()) do
        local entity = self.battleData:getGridEntity(posId)
        if not entity:getIsIdle() then
            if entity:isEmptyIdle() then
                if info.direction == BattleConst.BOARD_RANGE_TYPE.RANDOM then
                    if not randomPosList then
                        randomPosList = {}
                    end
                    table.insert(randomPosList, posId)
                end
                influenceElementTypeMap[entity:getElementType()] = (influenceElementTypeMap[entity:getElementType()] or 0) + 1
            end
            self:dealGridBreak(posId, GRID_BREAK_CONDITION.SKILL, time, breakedMap, sequenceMap, aniSequence, boomGridIds, onlyCheck)
        end
    end

    return randomPosList, influenceElementTypeMap
end

function BattleBaseController:getEliminattionAniInfo(posId, timeIdx)
    return {
        posId = posId,
        noAni = nil,
        aniPosList = nil,
        breakSfxName = nil,
        timeIdx = timeIdx,
        conditions = nil,
        isSkill = false,
        isIdle = false,
        callback = nil,
        overCallback = nil,
        bftcTime = 0,
        effectSfxName = nil,
        effectSfxFlow = nil,
        effectSfxDir = nil,
    }
end

function BattleBaseController:setGridBreakCondition(gridMap, posId, condition)
    if not gridMap[posId] then
        gridMap[posId] = {}
        gridMap[posId][condition] = true
    end
    gridMap[posId][condition] = true
end

function BattleBaseController:tryShowSelectSkillComp(needDelay, onlyCommonSkill)
    self.canChoseSkillCount = 1
    local skillList = self:getRandomSkillList(nil, onlyCommonSkill)
    if needDelay then
        self.showSelectSkillSid = ModuleManager.BattleManager:performWithDelayGlobal(function()
            self.battleUI:showSelectSkillComp(skillList, onlyCommonSkill)
            self.showSelectSkillSid = nil
        end, 0.3)
    else
        self.battleUI:showSelectSkillComp(skillList, onlyCommonSkill)
    end

    BIReport:postShowFightSkillSelect(self.battleType, self.battleData, skillList, self.chapterId, self.totalDurationTime, self:getWaveIndex())
end


function BattleBaseController:fillBoard(isRoundBeginCheck)
    local reverse = self.curActionSide == SIDE_DEF
    self.fillBoardPathMap = table.clearOrCreate(self.fillBoardPathMap)
    self.fillColumnCount = table.clearOrCreate(self.fillColumnCount)
    self.fillGridMap = table.clearOrCreate(self.fillGridMap)

    if reverse then
        for c = 1, BattleConst.COLUMN_COUNT do
            for r = 1, self:getRowCount() do
                local posId = ModuleManager.BattleManager:getPosId(r, c)
                local entity = self.battleData:getGridEntity(posId)
                if entity and entity:getIsIdle() then
                    self:fillThisPos(posId, self.fillColumnCount, self.fillGridMap, reverse)
                end
            end
        end
    else
        for c = 1, BattleConst.COLUMN_COUNT do
            for r = self:getRowCount(), 1, -1 do
                local posId = ModuleManager.BattleManager:getPosId(r, c)
                local entity = self.battleData:getGridEntity(posId)
                if entity and entity:getIsIdle() then
                    self:fillThisPos(posId, self.fillColumnCount, self.fillGridMap, reverse)
                end
            end
        end
    end

    while true do
        local find = false
        for c = 1, BattleConst.COLUMN_COUNT do
            local list = self.fillGridMap[c]
            if list and list[1] then -- 此列有需要填充的元素
                local entity = table.remove(list, 1)
                if entity then
                    self.battleData:setGridInfo(entity:getPosId(), self:getRandomGridInfo())
                end
                find = true
            end
        end

        if not find then
            break
        end
    end

    for posId, entity in pairs(self.battleData:getGridEnties()) do
        if #entity:getPath() > 0 then
            self.fillBoardPathMap[posId] = entity:getPath()
            entity:clearPath()
        end
    end

    self.battleUI:fallGrid(self.fillBoardPathMap, isRoundBeginCheck, function()
        self:onFillBoardOver(isRoundBeginCheck)
        self.isRoundBeginCheck = nil
        self.isWaitingFill = false
    end)
end

function BattleBaseController:onFillBoardOver(isRoundBeginCheck)
    self.battleUI:enableUITouch()

    if not isRoundBeginCheck then -- 检查一些表现
        if self.showMysteryBoxIndexs[1] then -- 检查宝箱
            local index = table.remove(self.showMysteryBoxIndexs, 1)
            local boardList, _, mysteryBoxIndexMap = self:getInitBoard()
            local rewards = mysteryBoxIndexMap[index]
            if rewards then
                ModuleManager.BattleManager:showBoxOpenUI(rewards,  function()
                    self:onFillBoardOver()
                end)
            else
                self:onFillBoardOver()
            end
            return
        end

        if self.battleData:useCommonSelectSkillCount() then -- 检查神灯
            self:tryShowSelectSkillComp(false, true)
            return
        end
    end

    if isRoundBeginCheck then
        EventManager:dispatchEvent(EventManager.CUSTOM_EVENT.BOARD_FILL_OVER)
        self:popBoardCacheSkill(function()
            self:generateSkill(function()
                if self.onFillBoardOverCallback then
                    local callback = self.onFillBoardOverCallback
                    self.onFillBoardOverCallback = nil
                    callback()
                else
                    self:enterElimination(true)
                end
            end)
        end)
    else
        self:generateSkill(function()
            self.battleUI:refreshSkill(nil, nil, self:getCurActionSide())
            if self.onFillBoardOverCallback then
                local callback = self.onFillBoardOverCallback
                self.onFillBoardOverCallback = nil
                callback()
            end
        end)
    end
end

function BattleBaseController:generateInstructions(skillEntity, elementType, lineCount, influenceElementTypeMap, elementTypeMap)
    self.instructions = BATTLE_INSTRUCTIONS_HELPER.generateInstructions(skillEntity, elementType, lineCount, influenceElementTypeMap, elementTypeMap, self)
end

function BattleBaseController:exeInstructions(callback, side)
    side = side or self:getCurActionSide()
    if not self.instructions or #self.instructions <= 0 then
        callback()
        return
    end
    local instruction = table.remove(self.instructions)
    local func = BattleBaseController._doInstruction[instruction.name]
    if func then
        func(self, side, instruction, function()
            self.battleData:resetTimeSpeed()
            self:exeInstructions(callback, side)
        end)
    else
        self:exeInstructions(callback, side)
    end
end

function BattleBaseController:getIsLastInstruction()
    if not self.instructions or not self.instructions[1] then
        return true
    end

    return false
end

function BattleBaseController:generateBoard(isFirst, snapshot)
    local boardList, _, mysteryBoxIndexMap = self:getInitBoard()
    if self.curBoardIndex and self.curBoardIndex >= #boardList then
        if isFirst then
            self.needWaitingBoardOver = false
        end
        return
    end

    if not self.battleUI then
        if isFirst then
            self.needWaitingBoardOver = false
        end
        return
    end

    self.curBoardIndex = (self.curBoardIndex or 0) + 1
    if snapshot and snapshot.curBoardIndex then
        self.curBoardIndex = snapshot.curBoardIndex
    end
    if not boardList[self.curBoardIndex] then -- 容错
        if isFirst then
            self.needWaitingBoardOver = false
        end
        return
    end
    local board = boardList[self.curBoardIndex].board
    local mysteryBoard = boardList[self.curBoardIndex].mysteryBoard
    if mysteryBoard and mysteryBoxIndexMap and mysteryBoxIndexMap[self.curBoardIndex] then
        board = mysteryBoard
    end
    local gridEdge = boardList[self.curBoardIndex].gridEdge
    self.battleUI:switchBoard(function()
        self.battleData:refreshBoard(board, gridEdge, self:getBlockIcon(), snapshot)
        self.battleUI:initGridCell(function()
            if isFirst then
                self.needWaitingBoardOver = false
            end
        end)
    end, function()
    end, isFirst)
end

function BattleBaseController:onGotMysteryBoxIndexs()
    self.gotMysteryBoxIndexs[self.curBoardIndex] = true
    table.insert(self.showMysteryBoxIndexs, self.curBoardIndex)
end


function BattleBaseController:putBoardCacheSkill(callback)
    if not self.battleUI then
        return
    end
    self.battleData:cacheBoardSkill()
    local skillList, skillCount = self.battleData:getCacheBoardSkill()
    self.battleUI:cacheSkillAni(skillList, false, callback)
end

function BattleBaseController:popBoardCacheSkill(callback)
    local skillList, skillCount = self.battleData:getCacheBoardSkill()
    self.battleData:clearCacheBoardSkill()
    if self.battleUI and skillCount > 0 then
        self.popSkillPosIdList = table.clearOrCreate(self.popSkillPosIdList)
        for posId, entity in pairs(self.battleData:getGridEnties()) do
            if entity:isEmptyIdle() and not entity:getIsIdle() then
                table.insert(self.popSkillPosIdList, posId)
            end
        end

        self.popSkillPosIdList = table.shuffle(self.popSkillPosIdList)
        self.popNewSkillId = table.clearOrCreate(self.popNewSkillId)
        for index, info in ipairs(skillList) do
            if self.popSkillPosIdList[1] then
                self.popNewSkillId[index] = info
                self.popNewSkillId[index].posId = table.remove(self.popSkillPosIdList)
                self:setGridSkillId(self.popNewSkillId[index].posId, info.skillId, true)
            else
                break
            end
        end

        self.battleUI:cacheSkillAni(self.popNewSkillId, true, function()
            for index, info in ipairs(self.popNewSkillId) do
                self.battleData:setGridDirty(info.posId)
            end

            if callback then
                callback()
            end
        end)
    else
        if callback then
            callback()
        end
    end
end

function BattleBaseController:generateSkill(callback)
    self.generateSkillMap = table.clearOrCreate(self.generateSkillMap)
    self.generateExcludeMap = table.clearOrCreate(self.generateExcludeMap)
    for _, skillEntity in pairs(self:getSkillEntities()) do
        if skillEntity:getEnergyEnough() then
            local list = self:getSkillElementList(skillEntity:getPosition(), 1, true, self.generateExcludeMap)
            if list[1] then
                self.generateSkillMap[skillEntity:getPosition()] =
                {
                    skillId = skillEntity:getSkillId(),
                    posId = list[1]
                }
                self.generateExcludeMap[list[1]] = true
            end
        end
    end

    if not self.battleUI then
        if callback then
            callback()
        end
        return
    end

    self.battleUI:generateSkillAni(self.generateSkillMap, function()
        for elementType, info in pairs(self.generateSkillMap) do
            self:setGridSkillId(info.posId, info.skillId)
        end

        if callback then
            callback()
        end
    end, self.curActionSide)
end

function BattleBaseController:setGridSkillId(posId, skillId, noDirty)
    local entity = self.battleData:getGridEntity(posId)
    if entity then
        entity:setSkilId(skillId, noDirty, self.curActionSide)
        local skillEntity = self:getSkillEntityBySkillId(skillId)
        if skillEntity and entity:getElementType() ~= skillEntity:getPosition() then
            entity:setElementType(skillEntity:getPosition(), noDirty)
        end
    end
end


function BattleBaseController:generateGridType(skillTypeParameter, monsterPos)
    if not skillTypeParameter then
        return
    end

    self.generateGridTypeList = table.clearOrCreate(self.generateGridTypeList)
    local count = 0
    for posId, entity in pairs(self.battleData:getGridEnties()) do
        if entity:isEmptyIdle() then
            table.insert(self.generateGridTypeList, entity)
            count = count + 1
        end
    end
    self.generateGridTypeList = table.shuffle(self.generateGridTypeList)
    if count > 0 then
        self.generateGridTypeMap = table.clearOrCreate(self.generateGridTypeMap)
        local minCount = math.min(skillTypeParameter[2], count)
        for i = minCount, 1, -1 do
            local entity = table.remove(self.generateGridTypeList, math.random(1, i))
            self.generateGridTypeMap[entity:getPosId()] = {
                gridType = skillTypeParameter[1],
                elementType = entity:getElementType()
            }
        end

        self.battleUI:showMonsterSkillAni(self.generateGridTypeMap, monsterPos, function()
            for posId, info in pairs(self.generateGridTypeMap) do
                self.battleData:setGridInfo(posId, info)
            end
        end)
    end
end


function BattleBaseController:lockElement(lcokElementType, isUnlock)
    if not self.lockElementElementTypeMap then
        self.lockElementElementTypeMap = table.clearOrCreate(self.lockElementElementTypeMap)
    else
        for k, v in pairs(self.lockElementElementTypeMap) do
            self.lockElementElementTypeMap[k] = table.clearOrCreate(self.lockElementElementTypeMap[k])
        end
    end
    if not self.lockElementMap then
        self.lockElementMap = table.clearOrCreate(self.lockElementMap)
    else
        for k, v in pairs(self.lockElementMap) do
            self.lockElementMap[k] = table.clearOrCreate(self.lockElementMap[k])
        end
    end
    self.lockElementList = table.clearOrCreate(self.lockElementList)
    local locked = false
    for posId, entity in pairs(self.battleData:getGridEnties()) do
        local elementType = entity:getElementType()
        if not isUnlock then
            if entity:isEmptyIdle() then
                local elementTypeMapUnit = self.lockElementElementTypeMap[elementType]
                if not elementTypeMapUnit or not elementTypeMapUnit[1] then
                    self.lockElementElementTypeMap[elementType] = table.clearOrCreate(self.lockElementElementTypeMap[elementType])
                    elementTypeMapUnit = self.lockElementElementTypeMap[elementType]
                    if not isUnlock then
                        table.insert(self.lockElementList, elementType)
                    end
                end

                table.insert(elementTypeMapUnit, posId)
            end
            if entity:isLock() then
                locked = true
            end
        else
            if entity:isLock() then
                if not self.lockElementMap[elementType] then
                    self.lockElementMap[elementType] = table.clearOrCreate(self.lockElementMap[elementType])
                end
                table.insert(self.lockElementMap[elementType], posId)
            end
        end
    end

    if isUnlock then
        self.battleData:clearAllCacheLockElement(lcokElementType, nil)
        for elementType, list in pairs(self.lockElementMap) do
            for _, posId in ipairs(list) do
                self.battleData:setGridType(posId, BattleConst.GRID_TYPE.EMPTY)
            end
        end
    else
        if locked then -- 锁定过就不新锁了
            return
        end
        local elementType = lcokElementType
        if elementType == BattleConst.ELEMENT_TYPE.NONE then
            if not self.lockElementList[1] then
                return
            end
            elementType = self.lockElementList[math.random(1, #self.lockElementList)]
        end
        self.battleData:cacheLockElement(elementType, true)
        local list = self.lockElementElementTypeMap[elementType]
        if list then
            for _, posId in ipairs(list) do
                self.battleData:setGridType(posId, BattleConst.GRID_TYPE.LOCK)
            end
        end
    end
end

function BattleBaseController:getSkillElementListRow()
    self.skillElementListRow = table.clearOrCreate(self.skillElementListRow)
    local min, max = self:getCurActionBoardRowRange()
    for row = min, max do
        table.insert(self.skillElementListRow, row)
    end
    return self.skillElementListRow
end

function BattleBaseController:getSkillElementList(elementType, count, useAlternate, excludeMap)
    self.getSkillElementListResult = table.clearOrCreate(self.getSkillElementListResult)
    local gridEntities = self.battleData:getGridEnties()
    if not gridEntities then
        return self.getSkillElementListResult
    end

    self.getSkillElementListSameElementList = table.clearOrCreate(self.getSkillElementListSameElementList)
    self.getSkillElementListAlternateList = table.clearOrCreate(self.getSkillElementListAlternateList)
    local addCount = 0

    for _, row in ipairs(self:getSkillElementListRow()) do
        for column = 1, BattleConst.COLUMN_COUNT do
            local posId = ModuleManager.BattleManager:getPosId(row, column)
            local entity = gridEntities[posId]
            if entity and entity:canChangeInfo() and not excludeMap[posId] then
                if entity:getElementType() == elementType then
                    table.insert(self.getSkillElementListSameElementList, posId)
                else
                    table.insert(self.getSkillElementListAlternateList, posId)
                end
            end
        end

        local remainCount = count - addCount
        if remainCount <= 0 then
            return self.getSkillElementListResult
        end

        for i = 1, remainCount do
            if not self.getSkillElementListSameElementList[i] then
                break
            end
            table.insert(self.getSkillElementListResult, table.remove(self.getSkillElementListSameElementList, math.random(1, #self.getSkillElementListSameElementList)))
            addCount = addCount + 1
            if addCount >= count then
                return self.getSkillElementListResult
            end
        end

        if addCount < count and useAlternate then
            for i = 1, count - addCount do
                if not self.getSkillElementListAlternateList[1] then
                    break
                end
                table.insert(self.getSkillElementListResult, table.remove(self.getSkillElementListAlternateList, math.random(1, #self.getSkillElementListAlternateList)))
                addCount = addCount + 1
                if addCount >= count then
                    return self.getSkillElementListResult
                end
            end
        end

        if addCount >= count then
            return self.getSkillElementListResult
        end
    end

    return self.getSkillElementListResult
end


---- 从一个点直接遍历所有相关的路径
function BattleBaseController:fillThisPos(posId, columnCount, gridMap, reverse)
    local entity = self.battleData:getGridEntity(posId)
    if not entity or not entity:getIsIdle() then
        return
    end

    local list
    if reverse then
        list = BattleConst.DOWN_LINE_FILL_LIST[posId]
    else
        list = BattleConst.UP_LINE_FILL_LIST[posId]
    end
    if not list[1] then -- 第一排
        if reverse then
            local gridEdgeEntity = self.battleData:getGridEdgeEntity(posId, BattleConst.BOARD_RANGE_TYPE.DOWN)
            if gridEdgeEntity and not gridEdgeEntity:getIsIdle() then
                return
            end
        else
            local gridEdgeEntity = self.battleData:getGridEdgeEntity(posId, BattleConst.BOARD_RANGE_TYPE.UP)
            if gridEdgeEntity and not gridEdgeEntity:getIsIdle() then
                return
            end
        end

        local rc = ModuleManager.BattleManager:getPosRC(posId)
        local c = rc.c
        if not columnCount[c] then
            columnCount[c] = 0
        end
        columnCount[c] = columnCount[c] + 1

        local fallPosId = posId
        local fallEntity = self.battleData:getGridEntity(fallPosId)
        if not fallEntity then -- 异常情况，理论上不可能不存在
            return
        end

        local newStartPosId
        for i = columnCount[c], 1, -1 do
            if reverse then
                newStartPosId = ModuleManager.BattleManager:getLastLineLastRowPosId(i, c, self:getRowCount())
            else
                newStartPosId = ModuleManager.BattleManager:getFirstLineLastRowPosId(i, c)
            end

            local curPos = self:getPosInfo(newStartPosId)
            fallEntity:addPath({x = curPos.x, y = curPos.y})
        end

        local curPos = self:getPosInfo(posId)
        fallEntity:addPath({x = curPos.x, y = curPos.y})

        self.battleData:exchangeGridEntities(posId, fallPosId)
        if not gridMap[c] then
            gridMap[c] = {}
        end
        table.insert(gridMap[c], fallEntity)
    else
        for index, fallPosId in ipairs(list) do
            local fallEntity = self.battleData:getGridEntity(fallPosId)
            if not fallEntity then -- 异常情况，理论上不可能不存在
                return
            end
            if self:judgeGridEdgeCanFall(posId, fallPosId, reverse) then
                if not fallEntity:isCantFallType() then
                    if fallEntity:getIsIdle() then
                        self:fillThisPos(fallPosId, columnCount, gridMap, reverse)
                    end
                    fallEntity = self.battleData:getGridEntity(fallPosId)
                    if not fallEntity:getIsIdle() then
                        if not fallEntity:getPath()[1] then
                            local curPos = self:getPosInfo(fallPosId)
                            fallEntity:addPath({x = curPos.x, y = curPos.y})
                        end

                        local curPos = self:getPosInfo(posId)
                        fallEntity:addPath({x = curPos.x, y = curPos.y})

                        self.battleData:exchangeGridEntities(posId, fallPosId)
                        self:fillThisPos(fallPosId, columnCount, gridMap, reverse)
                        return
                    end
                end
            end
        end
    end
end

function BattleBaseController:judgeGridEdgeCanFall(posId, fallPosId, reverse)
    return BattleBoardTouchHelper:judgeGridEdgeCanLink(fallPosId, posId)
end


function BattleBaseController:getRandomGridInfo()
    local list, fixedRandomGrid = self:getInitBoard()
    local fixedRandomList = fixedRandomGrid[self.curBoardIndex]

    local gridType = 0
    local elementType
    if fixedRandomList and fixedRandomList[1] then
        elementType = table.remove(fixedRandomList, 1)
    else
        local map = self.battleData:getElementTypeMap()
        self.getRandomGridInfoIndexs = table.clearOrCreate(self.getRandomGridInfoIndexs)
        self.getRandomGridInfoTypeList = table.clearOrCreate(self.getRandomGridInfoTypeList)
        for typeName, typeNum in pairs(BattleConst.ELEMENT_TYPE) do
            if not self:getSealElementType()[typeNum] and self:getSkillEntityByElement(typeNum) then
                local weight = ((map[typeNum] or 0) + 1) * BattleConst.ELEMENT_WIGHT
                if self.elementWeightMap and self.elementWeightMap[typeNum] then
                    weight = weight + self.elementWeightMap[typeNum]
                end
                if weight > BattleConst.MAX_ELEMENT_WIGHT then
                    weight = BattleConst.MAX_ELEMENT_WIGHT
                end
                table.insert(self.getRandomGridInfoIndexs, weight)
                table.insert(self.getRandomGridInfoTypeList, typeNum)
            end
        end

        local index = GFunc.getRandomIndex(self.getRandomGridInfoIndexs)
        elementType = self.getRandomGridInfoTypeList[index]
    end

    return {gridType = gridType, elementType = elementType}
end


function BattleBaseController:findSkillInfluenceGrids()
    local girds = self.battleData:clearSkillInfluenceGrids()
    for posId, _ in pairs(girds) do
        local entity = self.battleData:getGridEntity(posId)
        if entity:getCell() then
            entity:getCell():showCircle(false)
        end
    end

    local sequence = self.battleData:getGridSequence()
    self.skillInfluenceGridsSequenceEntities = table.clearOrCreate(self.skillInfluenceGridsSequenceEntities)
    for _, info in ipairs(sequence) do
        local entity = self.battleData:getGridEntity(info.posId)
        table.insert(self.skillInfluenceGridsSequenceEntities, entity)
    end

    for _, info in ipairs(sequence) do
        local entity = self.battleData:getGridEntity(info.posId)
        local skillId = entity:getSkillId()
        if skillId then
            local skillEntity = self:getSkillEntityBySkillId(skillId)
            if skillEntity then
                BATTLE_BOARD_SKILL_HANDLE.activeBoardSkill(info.posId, skillEntity, self.battleData:getGridEnties(), self.skillInfluenceGridsSequenceEntities, self)
            end
        end
    end
end

function BattleBaseController:getRandomSkillList(getCount, onlyCommonSkill, excludeMap)
    local fixedList = self:getFixedRogueSkill()
    if fixedList[1] then
        return table.remove(fixedList, 1)
    end

    getCount = getCount or BattleConst.SKILL_SELECT_COUNT
    self.randomSkillList = table.clearOrCreate(self.randomSkillList)
    self.randomSkillMap = table.clearOrCreate(self.randomSkillMap)
    self.randomSkillNewSkillPool = table.clearOrCreate(self.randomSkillNewSkillPool)
    self.randomSkillSkillWeight = table.clearOrCreate(self.randomSkillSkillWeight)
    local cfg = ConfigManager:getConfig("skill_rogue")
    local skillPool = self:getSkillPool()
    local count = 0

    if not onlyCommonSkill then
        for elementType, list in pairs(skillPool) do -- 先遍历一下未解锁的技能
            if not self:isUnlockedSkillElementType(elementType) then
                local skillEntity = self:getSkillEntityByElement(elementType)
                if skillEntity then
                    local skillId = skillEntity:getUnlockId()
                    if skillId and not self.randomSkillMap[skillId] then
                        local skillCfg = cfg[skillId]
                        table.insert(self.randomSkillNewSkillPool, skillId)
                        table.insert(self.randomSkillSkillWeight, skillCfg.weight)
                        count = count + 1
                        self.randomSkillMap[skillId] = true
                    end
                end
            end
        end
    
        if count >= 3 then -- 如果未解锁的技能大于等于3，则直接返回三个解锁技能
            for i = 1, 3 do
                local index = GFunc.getRandomIndex(self.randomSkillSkillWeight)
                local skillId = table.remove(self.randomSkillNewSkillPool, index)
                table.remove(self.randomSkillSkillWeight, index)
                count = count - 1
                table.insert(self.randomSkillList, skillId)
            end
    
            return table.shuffle(self.randomSkillList)
        end

        if excludeMap then
            for skillId, _ in pairs(excludeMap) do
                self.randomSkillMap[skillId] = true
            end
        end
    
        for elementType, list in pairs(skillPool) do
            if self:isUnlockedSkillElementType(elementType) then
                for _, skillId in ipairs(list) do
                    local skillCfg = cfg[skillId]
                    if skillCfg and (not skillCfg.limit_times or self:getSkillCount(skillId) < skillCfg.limit_times) then

                        if not self.randomSkillMap[skillId] and (not skillCfg.unlock or self:getSkillCount(skillCfg.unlock) > 0) then
                            table.insert(self.randomSkillNewSkillPool, skillId)
                            table.insert(self.randomSkillSkillWeight, skillCfg.weight)
                            count = count + 1
                            self.randomSkillMap[skillId] = true
                        end
                    end
                end
            end
        end
    
        if count > 0 then
            local index = GFunc.getRandomIndex(self.randomSkillSkillWeight)
            local skillId = table.remove(self.randomSkillNewSkillPool, index)
            table.remove(self.randomSkillSkillWeight, index)
            count = count - 1
            table.insert(self.randomSkillList, skillId)
            getCount = getCount - 1
        end
    end

    for skillId, info in pairs(cfg) do
        if not self:getNotInvolvedSkills()[skillId] then
            if info.universal then
                if not info.limit_times or self:getSkillCount(skillId) < info.limit_times then
                    if not self.randomSkillMap[skillId] then
                        table.insert(self.randomSkillNewSkillPool, skillId)
                        table.insert(self.randomSkillSkillWeight, info.weight)
                        count = count + 1
                    end
                end
            end
        end
    end

    for i = 1, getCount do
        local index = GFunc.getRandomIndex(self.randomSkillSkillWeight)
        local skillId = table.remove(self.randomSkillNewSkillPool, index)
        table.remove(self.randomSkillSkillWeight, index)
        count = count - 1
        table.insert(self.randomSkillList, skillId)
        if count <= 0 then
            break
        end
    end

    local result = table.shuffle(self.randomSkillList)
    return result
end

function BattleBaseController:dealSelectSkill(skillId, value, side, isSnapshot)
    side = side or self:getCurActionSide()
    self.battleData:addSkillCount(skillId, value, side)
    BATTLE_ROGUE_SKILL_HANDLE.takeEffect(skillId, self.battleData, self, value, side, isSnapshot)

    local skillEntities = self:getSkillEntities(side)
    for _, entity in pairs(skillEntities) do
        entity:gotUpSKill(skillId)
    end
end

function BattleBaseController:onSelectSkill(skillId, value, pos, side)
    if not self.canChoseSkillCount or self.canChoseSkillCount <= 0 then
        return
    end
    self.canChoseSkillCount = self.canChoseSkillCount - 1
    side = side or self:getCurActionSide()
    self:dealSelectSkill(skillId, value, side)

    BIReport:postFightSkillSelect(self.battleType, self.battleData, {skillId}, self.chapterId, self.totalDurationTime, self:getWaveIndex())

    local elementType = ModuleManager.HeroManager:getSkillRoguePosition(skillId)
    if elementType then
        if self.battleUI then
            self.battleUI:gotOneSkillAni(skillId, elementType, function()
                self:selectSKillNextToStep()
                self.battleUI:refreshBoard()
                self.battleUI:refreshSkill(nil, nil, self:getCurActionSide())
            end, pos)
            return
        end
    end

    self:selectSKillNextToStep()

    self.battleUI:showCommonSkillTips(skillId)
end

function BattleBaseController:selectSKillNextToStep()
    if self.roundStep == BattleConst.BATTLE_ROUND_STEP.ON_REFRESH_BOARD then
        self:onFillBoardOver()
    else
        self:enterElimination()
    end
end


function BattleBaseController:changeElementType(count, elementType, side)
    self.changeElementTypeMap = table.clearOrCreate(self.changeElementTypeMap)
    self.changeElementTypeList = table.clearOrCreate(self.changeElementTypeList)
    local listCount = 0
    for _, entity in pairs(self.battleData:getGridEnties()) do
        if entity:canChangeInfo() and entity:getElementType() ~= elementType then
            if side then
                if self:getPosIdInActionBoardRowRange(side, entity:getPosId()) then
                    table.insert(self.changeElementTypeList, entity)
                    listCount = listCount + 1
                end
            else
                table.insert(self.changeElementTypeList, entity)
                listCount = listCount + 1
            end
        end
    end

    count = math.min(count, listCount)
    for i = 1, count do
        if listCount <= 0 then
            break
        end
        local index = math.random(1, listCount)
        self.changeElementTypeList[index], self.changeElementTypeList[listCount] = self.changeElementTypeList[listCount], self.changeElementTypeList[index]
        local entity = table.remove(self.changeElementTypeList)
        listCount = listCount - 1
        self.changeElementTypeMap[entity] = elementType
    end

    self:changeElementTypeByMap(self.changeElementTypeMap)
end

function BattleBaseController:changeElementTypeByMap(changeMap)
    local index = 1
    for entity, elementType in pairs(changeMap) do
        self.battleData:setGridInfo(entity:getPosId(), {gridType = entity:getGridType(), elementType = elementType})
        self.battleUI:playChangeElementSfx(entity:getPosId(), index)
        index = index + 1
    end
end

function BattleBaseController:killGrids(posIdList)
    if not posIdList[1] then
        return
    end

    for _, posId in ipairs(posIdList) do
        local entity = self.battleData:getGridEntity(posId)
        entity:setIsIdle(true)
    end

    self.battleUI:removeGridOutOfScreen(posIdList)
end

function BattleBaseController:killRowOrColumn(infoList)
    self.killRowOrColumnMap = table.clearOrCreate(self.killRowOrColumnMap)
    for _, info in ipairs(infoList) do
        if info.posList then
            for i, posId in ipairs(info.posList) do
                if not self.killRowOrColumnMap[posId] then
                    self.killRowOrColumnMap[posId] = true
                    local entity = self.battleData:getGridEntity(posId)
                    entity:setIsIdle(true)
                end
            end
            self.battleUI:removeGridOutOfScreen(info.posList)
        end
    end
end

function BattleBaseController:addHeroAttr(attrName, value, side)
    if not self.battleData or not self.battleData.atkTeam then
        return
    end

    local attr = BUFF_NAME_TO_ATTR[attrName]
    if attr then
        self.battleData:getTeamBySide(side):addAttr(attr[1], value, attr[2])
    else
        local func = BattleBuffHandle.addAttribute[attrName]
        if func then
            local unitComp
            for matchType, comp in pairs(self:getCurActionTeam(side):getUnitComp()) do
                unitComp = comp
                break
            end
            if unitComp then
                func(unitComp, value)
            end
        end
    end
end

---- 快照一次棋盘
function BattleBaseController:snapshotBoard()
    local snapshot = {}
    for _, entity in pairs(self.battleData:getGridEnties()) do
        snapshot[entity:getPosId()] = entity:getSnapshoptInfo()
    end
    return snapshot
end

function BattleBaseController:snapshotGridEdge()
    local snapshot = {}
    for posId, info in pairs(self.battleData:getGridEdgeEntities()) do
        for direction, entity in pairs(info) do
            if not entity:getIsIdle() then
                table.insert(snapshot, {pos = posId, type = entity:getType(), direction = direction})
            end
        end
    end
    return snapshot
end

function BattleBaseController:showAttention()
    if not self.attentionList then
        return
    end

    if self.attentionSid then
        ModuleManager.BattleManager:unscheduleGlobal(self.attentionSid)
        self.attentionSid = nil
    end

    self.attentionSid = ModuleManager.BattleManager:performWithDelayGlobal(function()
        for _, posId in ipairs(self.attentionList) do
            local entity = self.battleData:getGridEntity(posId)
            if entity and entity:getCell() then
                entity:getCell():showAni()
            end
        end
    end, 2)
end


function BattleBaseController:shuffleBoard(callback)
    local changeInfo = self:getShuffleBoardInfo()
    if changeInfo then
        self.battleData:setGridEntitiesPosId(changeInfo)
        self.battleUI:shuffleBoard(changeInfo, callback)
    else
        self.resetList = table.clearOrCreate(self.resetList)
        for posId, entity in pairs(self.battleData:getGridEnties()) do
            if self:getPosIdInCurActionBoardRowRange(posId) and entity:isCanFallStatus() and not entity:getCantUpset() then
                table.insert(self.resetList, entity)
            end
        end
        local resetInfo = self:resetGrids(self.resetList)
        if not resetInfo then
            if EDITOR_MODE then
                Logger.logHighlight("----- 处于无法消除状态 -----")
            end
            if callback then
                callback()
            end
        else
            if self.resetGridSid then
                ModuleManager.BattleManager:unscheduleGlobal(self.resetGridSid)
                self.resetGridSid = nil
            end

            self.resetGridSid = ModuleManager.BattleManager:performWithDelayGlobal(function()
                local count = 1
                for posId, info in pairs(resetInfo) do
                    self.battleData:setInfoBySnapshop(posId, info)
                    self.battleUI:playChangeElementSfx(posId, count)
                    count = count + 1
                end
                self.resetGridSid = nil
                if callback then
                    callback()
                end
            end, 0.5)
        end
    end
end

function BattleBaseController:getShuffleBoardInfo()
    self.shuffleBoardPosList = table.clearOrCreate(self.shuffleBoardPosList)
    self.shuffleBoardAnySkillList = table.clearOrCreate(self.shuffleBoardAnySkillList)
    self.shuffleBoardPosMap = table.clearOrCreate(self.shuffleBoardPosMap)
    self.shuffleBoardCountMap = table.clearOrCreate(self.shuffleBoardCountMap)
    self.shuffleBoardCantLinkMap = table.clearOrCreate(self.shuffleBoardCantLinkMap)
    if not self.shuffleBoardList then
        self.shuffleBoardList = table.clearOrCreate(self.shuffleBoardList)
    else
        for elementType, _ in pairs(self.shuffleBoardList) do
            self.shuffleBoardList[elementType] = table.clearOrCreate(self.shuffleBoardList[elementType])
        end
    end
    local anySkillCount = 0
    for posId, entity in pairs(self.battleData:getGridEnties()) do
        if self:getPosIdInCurActionBoardRowRange(posId) and entity:isCanFallStatus() and not entity:getCantUpset() then
            if entity:getSkillId() then
                local skillEntity = self:getSkillEntityBySkillId(entity:getSkillId())
                local elementType = skillEntity:getPosition()
                if skillEntity:getIgnoreElementType() then
                    table.insert(self.shuffleBoardAnySkillList, entity)
                    anySkillCount = anySkillCount + 1
                else
                    if not self.shuffleBoardList[elementType] then
                        self.shuffleBoardList[elementType] = table.clearOrCreate(self.shuffleBoardList[elementType])
                    end
                    table.insert(self.shuffleBoardList[elementType], entity)
                    self.shuffleBoardCountMap[elementType] = (self.shuffleBoardCountMap[elementType] or 0) + 1
                end
            else
                local elementType = entity:getElementType()
                if not self.shuffleBoardList[elementType] then
                    self.shuffleBoardList[elementType] = table.clearOrCreate(self.shuffleBoardList[elementType])
                end
                table.insert(self.shuffleBoardList[elementType], entity)
                self.shuffleBoardCountMap[elementType] = (self.shuffleBoardCountMap[elementType] or 0) + 1
                if not entity:canLink() then
                    self.shuffleBoardCantLinkMap[elementType] = (self.shuffleBoardCantLinkMap[elementType] or 0) + 1
                end
            end
            table.insert(self.shuffleBoardPosList, posId)
            self.shuffleBoardPosMap[posId] = true
        end
    end

    for elementType, list in pairs(self.shuffleBoardList) do
        table.sort(self.shuffleBoardList[elementType], function(a, b)
            if a:getSkillId() and not b:getSkillId() then
                return false
            elseif not a:getSkillId() and b:getSkillId() then
                return true
            else
                return a:getPosId() < b:getPosId()
            end
        end)
    end


    local needCount = self:getMinEliminationCount()
    local find = false
    for elementType, list in pairs(self.shuffleBoardList) do
        local count = self.shuffleBoardCountMap[elementType] or 0
        local cantLinkCount = self.shuffleBoardCantLinkMap[elementType] or 0
        local skillCount = 0
        if anySkillCount > 0 then
            skillCount = 1
        end
        if count + skillCount - cantLinkCount >= needCount then
            local haveSkill = false
            local listCount = 0
            self.shuffleBoardTempList = table.clearOrCreate(self.shuffleBoardTempList)
            find = false
            local add = false
            for _, entity in ipairs(list) do
                add = false
                if haveSkill then
                    if not entity:getSkillId() then
                        add = entity:canLink()
                    end
                else
                    if entity:getSkillId() then
                        haveSkill = true
                    end
                    add = entity:canLink()
                end
                if add then
                    table.insert(self.shuffleBoardTempList, entity)
                    listCount = listCount + 1

                    if listCount >= needCount then -- 可连接的 普通的元素+元素技能
                        find = true
                        break
                    end
                end
            end

            if listCount >= needCount then -- 可连接的 普通的元素+元素技能
                find = true
                break
            elseif not haveSkill and skillCount > 0 then -- 可连接的 普通元素 + 任意元素技能
                table.insert(self.shuffleBoardTempList, self.shuffleBoardAnySkillList[1])
                listCount = listCount + 1
                if listCount >= needCount then
                    find = true
                    break
                end
            end
        end
    end

    if find then
        return self:shufflePos(self.shuffleBoardTempList, self.shuffleBoardPosMap, needCount, self.shuffleBoardPosList)
    end
end

function BattleBaseController:shufflePos(tempList, posMap, needCount, posList)
    local gotPos, useMap, list = self:findCanLinkPosList(posMap, needCount)

    if gotPos and list[1] then
        self.shufflePosInfo = table.clearOrCreate(self.shufflePosInfo)
        self.shufflerPosUsedPos = table.clearOrCreate(self.shufflerPosUsedPos)
        self.shufflerSetedPos = table.clearOrCreate(self.shufflerSetedPos)
        for index, entity in ipairs(tempList) do
            self.shufflePosInfo[entity:getPosId()] = list[index]
            self.shufflerPosUsedPos[list[index]] = true
            self.shufflerSetedPos[entity:getPosId()] = true
        end

        self.shufflePosList1 = table.clearOrCreate(self.shufflePosList1)
        self.shufflePosList2 = table.clearOrCreate(self.shufflePosList2)
        for index = #posList, 1, -1 do
            local posId = posList[index]
            if not self.shufflerPosUsedPos[posId] then
                table.insert(self.shufflePosList2, posId)
            end
            if not self.shufflerSetedPos[posId] then
                table.insert(self.shufflePosList1, posId)
            end
        end

        self.shufflePosList2 = table.shuffle(self.shufflePosList2)
        for index, posId in ipairs(self.shufflePosList1) do
            if not self.shufflePosList2[index] then
                break
            end
            self.shufflePosInfo[posId] = self.shufflePosList2[index]
        end

        return self.shufflePosInfo
    end
end

function BattleBaseController:findAttention()
    local find = false
    local min, max = self:getCurActionBoardRowRange()
    for r = min, max do
        for c = 1, GConst.BattleConst.COLUMN_COUNT  do
            local posId = ModuleManager.BattleManager:getPosId(r, c)
            local gridEntity = self.battleData:getGridEntity(posId)
            local mainElementType = gridEntity:getElementType()
            if gridEntity:canChangeInfo() then
                self.findAttentionPathList = table.clearOrCreate(self.findAttentionPathList)
                self.findAttentionPosIdMap = table.clearOrCreate(self.findAttentionPosIdMap)
                self:findLinkLine(posId, self.findAttentionPosIdMap, false, mainElementType, self.findAttentionPathList)
                if table.nums(self.findAttentionPathList) >= self:getMinEliminationCount() then
                    find = true
                    break
                end
            end
        end
        if find then
            break
        end
    end

    return find, self.findAttentionPathList
end

function BattleBaseController:_dealResetGridsDataFunc(posList)
    self.dealResetFunc1PosMap = table.clearOrCreate(self.dealResetFunc1PosMap)
    self.dealResetFunc1LockElementMap = table.clearOrCreate(self.dealResetFunc1LockElementMap)
    self.dealResetFunc1KeepSnapList = table.clearOrCreate(self.dealResetFunc1KeepSnapList)
    self.dealResetFunc1KeepSnapSkillList = table.clearOrCreate(self.dealResetFunc1KeepSnapSkillList)
    self.dealResetFunc1EmptySnapList = table.clearOrCreate(self.dealResetFunc1EmptySnapList)
    local emptyCount = 0
    for _, entity in ipairs(posList) do
        local posId = entity:getPosId()
        self.dealResetFunc1PosMap[posId] = entity
        if entity:isEmptyIdle() then
            emptyCount = emptyCount + 1
            table.insert(self.dealResetFunc1EmptySnapList, entity:getSnapshoptInfo())
        elseif entity:isLock() and not entity:getSkillId() then
            self.dealResetFunc1LockElementMap[entity:getElementType()] = true
            emptyCount = emptyCount + 1
            local snapInfo = entity:getSnapshoptInfo()
            snapInfo.gridType = BattleConst.GRID_TYPE.EMPTY
            table.insert(self.dealResetFunc1EmptySnapList, snapInfo)
        else
            if entity:getSkillId() then
                table.insert(self.dealResetFunc1KeepSnapSkillList, entity:getSnapshoptInfo())
            else
                table.insert(self.dealResetFunc1KeepSnapList, entity:getSnapshoptInfo())
            end
        end
    end

    return self.dealResetFunc1PosMap, self.dealResetFunc1LockElementMap, emptyCount, self.dealResetFunc1KeepSnapList, self.dealResetFunc1KeepSnapSkillList, self.dealResetFunc1EmptySnapList
end


function BattleBaseController:_dealResetGridsDataFunc2(useMap, emptySnapList, mainElement, backupSkill, keepSnapList, posMap, canRandomElmentList, elementCount, lockElementMap)
    self.dealResetFunc2ResetPosInfo = table.clearOrCreate(self.dealResetFunc2ResetPosInfo)
    for posId, _ in pairs(useMap) do
        local snapInfo
        if emptySnapList[1] then
            snapInfo = table.remove(emptySnapList)
            snapInfo.elementType = mainElement
            snapInfo.posId = posId
            snapInfo.gridType = BattleConst.GRID_TYPE.EMPTY
        else
            snapInfo = backupSkill
        end
        self.dealResetFunc2ResetPosInfo[posId] = snapInfo
    end

    for _, snap in ipairs(emptySnapList) do
        table.insert(keepSnapList, snap)
    end

    keepSnapList = table.shuffle(keepSnapList)

    for posId, entity in pairs(posMap) do
        if not useMap[posId] then
            local snapInfo
            if keepSnapList[1] then
                snapInfo = table.remove(keepSnapList)
                snapInfo.posId = posId
                if not snapInfo.skillId or snapInfo.skillId <= 0 then
                    if snapInfo.gridType == BattleConst.GRID_TYPE.EMPTY then
                        snapInfo.elementType = canRandomElmentList[math.random(1, elementCount)]
                        if lockElementMap[snapInfo.elementType] then
                            snapInfo.gridType = BattleConst.GRID_TYPE.LOCK
                        end
                    end
                end
            end

            if snapInfo then
                self.dealResetFunc2ResetPosInfo[posId] = snapInfo
            end
        end
    end

    return self.dealResetFunc2ResetPosInfo
end

function BattleBaseController:resetGrids(posList)
    local needCount = self:getMinEliminationCount()
    if not posList[needCount] then
        return
    end

    local posMap, lockElementMap, emptyCount, keepSnapList, keepSnapSkillList, emptySnapList = self:_dealResetGridsDataFunc(posList)

    local canUseSkillCount = 0
    if keepSnapSkillList[1] then -- 技能可以直接链接， 不判断元素技能了
        canUseSkillCount = 1
    end

    if emptyCount + canUseSkillCount < needCount then -- 格子不够
        return
    end

    local backupSkill
    if emptyCount < needCount then
        backupSkill = table.remove(keepSnapSkillList)
    end

    for _, snap in ipairs(keepSnapSkillList) do
        table.insert(keepSnapList, snap)
    end

    local gotPos, useMap = self:findCanLinkPosList(posMap, needCount)
    if not gotPos then
        return
    end

    self.canRandomElmentList = table.clearOrCreate(self.canRandomElmentList)

    local elementCount = 0
    for typeName, typeNum in pairs(BattleConst.ELEMENT_TYPE) do
        if not lockElementMap[typeNum] and  not self:getSealElementType()[typeNum] and self:getSkillEntityByElement(typeNum) then
            table.insert(self.canRandomElmentList, typeNum)
            elementCount = elementCount + 1
        end
    end

    if elementCount <= 0 then
        return
    end

    local mainElement = self.canRandomElmentList[math.random(1, elementCount)]

    for typeNum, _ in pairs(lockElementMap) do
        table.insert(self.canRandomElmentList, typeNum)
        elementCount = elementCount + 1
    end

    local resetPosInfo = self:_dealResetGridsDataFunc2(useMap, emptySnapList, mainElement, backupSkill, keepSnapList, posMap, self.canRandomElmentList, elementCount, lockElementMap)

    return resetPosInfo
end

function BattleBaseController:findCanLinkPosList(posMap, needCount)
    self.findCanLinkList = table.clearOrCreate(self.findCanLinkList)
    self.findCanUseMap = table.clearOrCreate(self.findCanUseMap)
    local gotPos = false
    for posId, _ in pairs(posMap) do
        table.clear(self.findCanLinkList)
        table.clear(self.findCanUseMap)
        local count = 0
        local findPodId = posId
        gotPos = false
        while true do
            local aounrdList = BattleConst.GRID_OUT_LINE_POS_ID[findPodId]
            if not aounrdList then
                break
            end
            local got = false
            for id, status in pairs(aounrdList) do
                if posMap[id] and not self.findCanUseMap[id] and BattleBoardTouchHelper:judgeGridEdgeCanLink(findPodId, id) then
                    table.insert(self.findCanLinkList, id)
                    count = count + 1
                    self.findCanUseMap[id] = true
                    findPodId = id
                    got = true
                    break
                end
            end
            if not got then
                break
            end
            if count >= needCount then
                gotPos = true
                break
            end
        end

        if gotPos then
            break
        end
    end

    return gotPos, self.findCanUseMap, self.findCanLinkList
end

function BattleBaseController:findLinkLine(posId, posIdMap, hadSkill, mainElementType, lineList)
    posIdMap[posId] = true
    table.insert(lineList, posId)
    local list = BattleConst.GRID_OUT_LINE_POS_ID[posId]
    if not list then
        return hadSkill
    end

    if #lineList >= self:getMinEliminationCount() then
        return hadSkill
    end

    local lineCount = 0
    local maxLineList
    local maxPosIdMap
    local maxGotSkill
    for aroundposId, _ in pairs(list) do
        if self:getPosIdInCurActionBoardRowRange(aroundposId) and not posIdMap[aroundposId] and BattleBoardTouchHelper:judgeGridEdgeCanLink(posId, aroundposId) then
            local gridEntity = self.battleData:getGridEntity(aroundposId)
            if gridEntity then
                if gridEntity:canLink() and not gridEntity:getSkillId() then
                    if not mainElementType or gridEntity:getElementType() == mainElementType then
                        mainElementType = mainElementType or gridEntity:getElementType()
                        local tempIdMap = GFunc.getTable(posIdMap)
                        local newList = GFunc.getTable(lineList)
                        local gotSkill = self:findLinkLine(aroundposId, tempIdMap, hadSkill, mainElementType, newList)
                        local count = #newList
                        if count > lineCount then
                            lineCount = count
                            maxLineList = newList
                            maxPosIdMap = tempIdMap
                            maxGotSkill = gotSkill
                        end
                    end
                elseif gridEntity:canLink() and gridEntity:getSkillId() and not hadSkill and mainElementType then
                    local skillId = gridEntity:getSkillId()
                    local skillEntity = self:getSkillEntityBySkillId(skillId)
                    if skillEntity then
                        if skillEntity:getIgnoreElementType() or skillEntity:getPosition() == mainElementType then
                            local tempIdMap = GFunc.getTable(posIdMap)
                            local newList = GFunc.getTable(lineList)
                            local gotSkill = self:findLinkLine(aroundposId, tempIdMap, true, mainElementType, newList)
                            local count = #newList
                            if count > lineCount then
                                lineCount = count
                                maxLineList = newList
                                maxPosIdMap = tempIdMap
                                maxGotSkill = gotSkill
                            end
                        end
                    end
                end
            end
        end
    end

    if lineCount > 0 then
        for index, id in ipairs(maxLineList) do
            lineList[index] = id
        end

        for _, id in pairs(maxPosIdMap) do
            posIdMap[id] = true
        end

        hadSkill = maxGotSkill
    end

    return hadSkill
end

function BattleBaseController:generateMonsterById(monsterId, callback)
    local unitEntity = self.battleData:addMonster(monsterId, true, self)
    local modelId = unitEntity:getModelId()
    BattleHelper:loadBattleHeroModel(modelId, self.battleUI:getBattleNode(), function(spineObject)
        self.defTeam:removeAllUnits()
        local monsterComp = spineObject:addLuaComponent(GConst.BattleConst.TYPEOF_LUA_COMP.BATTLE_MONSTER_COMPONENT)
        monsterComp:initWithEntity(modelId, unitEntity, self)
        self.defTeam:addUnit(monsterComp, true)
        self.battleUI:refreshDefHp(unitEntity:getHp(), unitEntity:getHpPercent())
        monsterComp:playEnterBattlefield(false, callback)
    end)
end

function BattleBaseController:addBattleExp(exp)
    if not self.battleData or not exp then
        return
    end
    self.battleData:addExp(exp)
end

function BattleBaseController:addTaskProgress(fieldName, count)
    if self:getCurActionSide() ~= SIDE_ATK then
        return
    end
    if not count then
        return
    end
    self.taskProgress[fieldName] = (self.taskProgress[fieldName] or 0) + count
end

function BattleBaseController:setTaskProgress(fieldName, count)
    if not count then
        return
    end
    self.taskProgress[fieldName] = count
end


function BattleBaseController:getTaskProgress()
    return self.taskProgress
end

function BattleBaseController:addFillWaitingCount()
    self.waitingFillCount = self.waitingFillCount + 1
end

function BattleBaseController:reduceFillWaitingCount()
    self.waitingFillCount = self.waitingFillCount - 1
end

function BattleBaseController:_tick(dt, originDt)
    self.realTime = self.realTime + dt
    self.waveDurationTime = self.waveDurationTime + originDt
    self.totalDurationTime = self.totalDurationTime + originDt
	if self.isPause then
		return
	end
    if self.needWaitingBoardOver == false then
        self:enterRoundBegin()
    end
    if self.waitingFillCount <= 0 and self.isWaitingFill and self.isRoundBeginCheck then
        self:fillBoard(self.isRoundBeginCheck)
    end
	self.time = self.time + dt
    self.atkTeam:tick(dt)
    self.defTeam:tick(dt)
    local count = #self.effectTexts
    for i = count, 1, -1 do
        self.effectTexts[i]:tick(dt)
        if self.effectTexts[i]:getDuration() < 0 then
            BattleHelper:recycleEffectText(self.effectTexts[i])
            table.remove(self.effectTexts, i)
        end
    end
    self:checkDelayEffectText(dt)
    self:checkSkillSlowDown(dt)
	self:tick(dt)
    BattleBoardTouchHelper:tick(dt)
end

function BattleBaseController:battleEnd()
    if self.battleEndSid then
        ModuleManager.BattleManager:unscheduleGlobal(self.battleEndSid)
        self.battleEndSid = nil
    end
    self.battleUI:disableUITouch()
    self.battleEndSid = ModuleManager.BattleManager:performWithDelayGlobal(function()
        if self.battleUI then
            self.battleUI:enableUITouch()
        end

        -- 处理战斗任务
        local curWaveIndex = self:getWaveIndex()
        if self.victory then
            self:setTaskProgress(GConst.BattleConst.BATTLE_TASK_FIELD.KILLS_BOSS_TURN, self.waveRoundCount[curWaveIndex])
        end

        local teamEntity = self.battleData:getAtkTeam()
        local hpp = math.floor(teamEntity:getHpPercent() * 100 + 0.0001)
        self:setTaskProgress(GConst.BattleConst.BATTLE_TASK_FIELD.SPARE_HP, hpp)

        local totalRound = 0
        for wave, round in pairs(self.waveRoundCount) do
            if wave == curWaveIndex then
                if self.victory then
                    totalRound = totalRound + round
                end
            else
                totalRound = totalRound + round
            end
        end
        self:setTaskProgress(GConst.BattleConst.BATTLE_TASK_FIELD.TOTAL_TURN, totalRound)
        -- end处理战斗任务

        self:controllBattleEnd()
        if self.victory then
            ModuleManager.TaskManager:addTaskProgress(GConst.TaskConst.TASK_TYPE.X_BATTLE_VICTORY)
        end
    end, 1)
end

function BattleBaseController:clear()
    if self.alreadyClear then
		return
	end
	self.alreadyClear = true
    if self.tickSid then
		BattleScheduler:unscheduleGlobal(self.tickSid)
		self.tickSid = nil
	end
    BattleScheduler:clear()
    BattleHelper:clear()
    BattlePassive:clear()
    BattlePool:clear()
    self:unBindAll()
    self.battleData:clear()
    self.battleData:resetTimeSpeed()
    ModuleManager.BattleManager:unscheduleAll()

    if DataManager.TutorialData:getIsInTutorial() then
        ModuleManager.TutorialManager:stopTutorial()
    end
end

function BattleBaseController:endBattleAndExit()
    BATTLE_SNAPSHOT_HELPER:clearSnap(self)
	ModuleManager.BattleManager:exitBattle()
end

function BattleBaseController:checkSkillSlowDown(dt)
    if self.skillSlowDownDuration == nil then
        return
    end
    self.skillSlowDownDuration = self.skillSlowDownDuration - dt
    if self.skillSlowDownDuration >= 0 then
        return
    end
    self.skillSlowDownDuration = nil
    self:resetTimeSpeed()
end

function BattleBaseController:checkDelayEffectText(dt)
	if self.delayEffectTextCount <= 0 then
		return
	end
	for i = self.delayEffectTextCount, 1, -1 do
		local delayEffectText = self.delayEffectTextList[i]
		delayEffectText.time = delayEffectText.time - dt
		if delayEffectText.time <= 0 then
            local effectTextComp = BattleHelper:getEffectText(self.battleUI:getNumberNode(), delayEffectText.colorType)
            effectTextComp:showEffectNumber(delayEffectText.effectType, delayEffectText.num, delayEffectText.x, delayEffectText.y, delayEffectText.showCombo)
            table.insert(self.effectTexts, effectTextComp)
			local tailDelayEffectText = self.delayEffectTextList[self.delayEffectTextCount]
			delayEffectText.colorType = tailDelayEffectText.colorType
			delayEffectText.effectType = tailDelayEffectText.effectType
			delayEffectText.num = tailDelayEffectText.num
			delayEffectText.x = tailDelayEffectText.x
			delayEffectText.y = tailDelayEffectText.y
			delayEffectText.time = tailDelayEffectText.time
            delayEffectText.showCombo = tailDelayEffectText.showCombo
			self.delayEffectTextCount = self.delayEffectTextCount - 1
		end
	end
end

function BattleBaseController:showEffectNumber(colorType, effectType, num, x, y, delayTime, showCombo)
    if delayTime > 0 then
        self.delayEffectTextCount = self.delayEffectTextCount + 1
        local obj = self.delayEffectTextList[self.delayEffectTextCount]
        if obj == nil then
            obj = {}
            self.delayEffectTextList[self.delayEffectTextCount] = obj
        end
        obj.colorType = colorType
        obj.effectType = effectType
        obj.num = num
        obj.x = x
        obj.y = y
        obj.time = delayTime
        obj.showCombo = showCombo
    else
        local effectTextComp = BattleHelper:getEffectText(self.battleUI:getNumberNode(), colorType)
        effectTextComp:showEffectNumber(effectType, num, x, y, showCombo)
        table.insert(self.effectTexts, effectTextComp)
    end
end

function BattleBaseController:getFxNode()
    return self.battleUI:getFxNode()
end

function BattleBaseController:shakeScreen(shakeType, duration)
    self.battleUI:shakeScreen(shakeType, duration)
end

local function _addCurRoundAttr(self, side, instruction, callback)
    if instruction.effectList then
        local defComp = self.defTeam:getMainUnit()
        local atkComp = self.atkTeam:getMainUnit()
        local isAtkSide = side == SIDE_ATK
        local actionComp = isAtkSide and atkComp or defComp
        for _, effect in ipairs(instruction.effectList) do
            local target
            if effect:getTargetSide() == BattleConst.SIDE_DEF then
                target = isAtkSide and defComp or atkComp
            elseif effect:getTargetSide() == BattleConst.SIDE_ATK then
                target = isAtkSide and atkComp or defComp
            else
                local matchType = BattleConst.SIDE_OBJ_TO_MATCH_TYPE[effect:getTargetSide()]
                if matchType then
                    if isAtkSide then
                        target = self.atkTeam:getUnitComp()[matchType]
                    else
                        target = self.defTeam:getUnitComp()[matchType]
                    end
                end
            end
            if target then
                actionComp:takeEffect(effect, target)
            end
        end
    end

    callback()
end

local function _assisting(self, side, instruction, callback)
    local actionTeam = self.atkTeam
    if side == SIDE_DEF then
        actionTeam = self.defTeam
    end
    actionTeam:useAssistingSkill(instruction.assistingList, #self.instructions == 0, callback)
end

local function _generalAttack(self, side, instruction, callback)
    local actionTeam = self.atkTeam
    if side == SIDE_DEF then
        actionTeam = self.defTeam
    end
    actionTeam:useNormalSkill(instruction.skillMatch, instruction.count, #self.instructions == 0, BattleConst.EFFECT_TYPE.DIRECT, BattleConst.ATTACK_ACTION_STATE.NORMAL, callback)
end

local function _playSkill(self, side, instruction, callback)
    local actionTeam = self.atkTeam
    if side == SIDE_DEF then
        actionTeam = self.defTeam
    end
    actionTeam:useSkill(instruction.skillMatch, instruction.count, #self.instructions == 0, BattleConst.EFFECT_TYPE.DIRECT, BattleConst.ATTACK_ACTION_STATE.NORMAL, callback)
end

BattleBaseController._doInstruction = {
    [BattleConst.INSTRUCTION_NAME.ADD_CUR_ROUND_ATTR] = _addCurRoundAttr,
    [BattleConst.INSTRUCTION_NAME.ASSISTING] = _assisting,
    [BattleConst.INSTRUCTION_NAME.GENERAL_ATTACK] = _generalAttack,
    [BattleConst.INSTRUCTION_NAME.PLAY_SKILL] = _playSkill,
}

function BattleBaseController:calExpectedInjury(mainElementType, count, skillId)
    local atkCompMap = self:getCurActionTeam():getUnitComp()
    if not atkCompMap then
        return 0
    end
    local atkUnitComp = atkCompMap[mainElementType]
    if mainElementType and not atkUnitComp then
        return 0
    end
    if not mainElementType or not atkUnitComp then
        count = 0
        atkUnitComp = self:getCurActionTeam():getMainUnit()
    end
    local dmg = BattleFormula:getExpectedDamageResult(atkUnitComp, count, self:getCurOtherActionUnitComp(), skillId, atkCompMap)
    return dmg
end

return BattleBaseController