box-server/nodes/battle/lib/battleAiUtils.lua

local battleUtils = require "battle.battleUtils"
local battleAdapt = require "adapt.battleAdapt"
local battleHero = require "battle.battleHero"
local battleLog = require "battle.battleLog"
local battleConst = require "battle.battleConst"
local battleAiAssistSkillEvaluate = require "battleAiAssistSkillEvaluate"

local AI_MODEL_TEST = false

-- AI 工具类
local root = {}

local function log2Client(core, logStr)
    if not logStr then
        return
    end
    battleLog:logClient(logStr)

    core:notifyClientLog(logStr)
end

local function showDataLog(data)
    local tab = {}
    for key, value in pairs(data) do
        if type(value) ~= "table" then
            tab[key] = value
        end
    end

end

-- 获取指定龙的战力评价
function root:getLongEvaluate(core, actionCastle, ids, linkColor, skip, enableExSkill)
    local params = self:getParams(core, actionCastle, ids, linkColor)

    local blockList = self:getBlockList(core, ids)

    local exceptBlockList = {}

    if not skip then
        local exceptIds = {1111, 2031, 2041, 2131, 3041, 3071, 4091, 4101}
        local heroBlockExceptIds = {1031, 2131, 2041}

        local enemyHasExceptSkill = false
        for _, block in ipairs(params.enemySkillBlockList) do
            if table.member(exceptIds, block.skillId) then
                enemyHasExceptSkill = true
            end
        end
        for _, block in ipairs(blockList) do
            if table.member(exceptIds, block.skillId) or block.skillId == 1111 and enemyHasExceptSkill then
                table.insert(exceptBlockList, block)
            end
        end

        local selfHasHeroBlockExceptSkill = false
        for _, block in ipairs(blockList) do
            if table.member(heroBlockExceptIds, block.skillId) then
                selfHasHeroBlockExceptSkill = true
            end
        end
        if selfHasHeroBlockExceptSkill then
            for _, id in ipairs(ids) do
                if core:getHeroByBlockId(id) then
                    table.insert(exceptBlockList, battleUtils:getColorBlockByID(core.map, id))
                end
            end
        end
    end

    local skillInfoList = self:getSkillInfoList(core, blockList)
    local exSkillInfoList = {}
    if enableExSkill then
        exSkillInfoList = self:getExSkillInfoList(core, actionCastle, blockList, skillInfoList)
    end

    local longList = {}
    for _, v in ipairs(blockList) do
        table.insert(longList, {v.y, v.x})
    end
    log2Client(core, string.format("===> 开始评价龙：%s", cjson_encode(longList)))

    --[[
    -- 测试代码
    local allSkillId = {
        1011,
        1021,
        1031,
        1041,
        1051,
        1061,
        1071,
        1081,
        1091,
        1101,
        1111,
        1121,
        1131,
        2011,
        2021,
        2031,
        2041,
        2051,
        2061,
        2071,
        2081,
        2091,
        2101,
        2111,
        2121,
        2131,
        3011,
        3021,
        3031,
        3041,
        3051,
        3061,
        3071,
        3081,
        3091,
        3101,
        3111,
        3121,
        3131,
        4011,
        4021,
        4031,
        4041,
        4051,
        4061,
        4071,
        4081,
        4091,
        4101,
        4111,
        4121,
        4131,
        2211,
        1211,
        4211,
        3211,
        2221,
        1221,
        4221,
        3221,
        2231,
        1231,
        4231,
        3231,
        2241,
        1241,
        4241,
        3241,
        2251,
        1251,
        4251,
        3251,
        2261,
        1261,
        4261,
        3261,
        2351,
        1351,
        4351,
        3351,
        2361,
        1361,
        4361,
        3361,
        2281,
        1281,
        4281,
        3281,
        2291,
        1291,
        4291,
        3291,
        2311,
        1311,
        4311,
        3311,
        2321,
        1321,
        4321,
        3321,
        2331,
        1331,
        4331,
        3331,
        2341,
        1341,
        4341,
        3341
    }
    local skillInfoList = {}
    for _, v in ipairs(allSkillId) do
        local skillInfo = {skillId = v, skillBase = 10, skillCount = 3}
        if v == 3031 then
            skillInfo.data3031 = {}
            skillInfo.data3031[0] = true
            skillInfo.data3031[1] = true
            skillInfo.data3031[2] = true
            skillInfo.data3031[3] = true
        end
        if v == 3241 then
            skillInfo.data3241 = {}
            skillInfo.data3241[0] = true
            skillInfo.data3241[1] = true
            skillInfo.data3241[2] = true
            skillInfo.data3241[3] = true
        end
        table.insert(skillInfoList, skillInfo)
    end
    ]]
    local ret = 0
    local exSkillGridId = nil
    if self:isKill(core, skillInfoList, params) then
        ret = 1000000

        log2Client(core, "斩杀")
    else
        --]]
        local skillTotalEv = 0
        for _, v in ipairs(skillInfoList) do
            local skillEv = self:getSkillEvaluate(core, v, params)
            log2Client(core, string.format("===> 获取技能[%s]评价, 评价结果是: %s", v.skillId, tostring(skillEv)))
            if skillEv then
                skillTotalEv = skillTotalEv + skillEv
            end
        end

        -- 怒气技能评价
        local exSkillEv = 0
        if exSkillInfoList and #exSkillInfoList > 0 then
            local config = battleAdapt:getSkillSetConfig()
            local secondIds = {}
            for _, v in ipairs(skillInfoList) do
                table.insert(secondIds, v.skillId)
            end

            for _, v in ipairs(exSkillInfoList) do
                local skillEv = self:getSkillEvaluate(core, v, params)
                if skillEv then
                    local skillSetTotalEv = self:getSkillSetTotalEv(config, v.skillId, secondIds) * params.baseAttack
                    local total = skillEv + skillSetTotalEv

                    local msg =
                        string.format(
                        "===> 获取怒气技能[%s]评价, 评价结果是: %s + %s = %s",
                        v.skillId,
                        skillEv,
                        skillSetTotalEv,
                        tostring(total)
                    )
                    log2Client(core, msg)

                    if total > exSkillEv then
                        exSkillEv = total
                        exSkillGridId = v.id
                    end
                end
            end
        end

        ------------------------------------------------------------
        do
            -- 辅助技能AI评分
            -- 辅助技能评分和英雄相关

            for _, v in ipairs(skillInfoList or {}) do
                local assistSkillLevel = actionCastle:getAssistSkillLv(v.skillId)

                -- TODO: Debug 测试代码,上线前修改过来.
                -- v.newHeroAssistSkillLevel = 2

                v.newHeroAssistSkillLevel = assistSkillLevel or 0
                local skillEvaluate =
                    battleAiAssistSkillEvaluate:getAiAssistSkillEvaluate(core, actionCastle, v, params)
                if skillEvaluate and skillEvaluate > 0 then
                    skillTotalEv = skillTotalEv + skillEvaluate
                end
            end
        end

        ------------------------------------------------------------

        -- 天赋技能AI评分
        local baseAttack = params.baseAttack
        local linkCount = params.linkCount
        local rebelHeroTotalEv = params.rebelHeroTotalEv
        local yEv = self:getYEvaluate(core, params.newHeroY, baseAttack)
        local talentEv = self:getTalentEvaluate(core, params, skillInfoList)
        local more3Ev = linkCount > 3 and baseAttack or 0

        ret = baseAttack * linkCount + skillTotalEv + rebelHeroTotalEv + yEv + talentEv + more3Ev + exSkillEv

        -- TODO: Debug 测试代码,AI跑分第一阶段.
        if AI_MODEL_TEST then
            ret = baseAttack * linkCount + math.floor(baseAttack * 3.1 + 0.5)
        end

        ---[[
        log2Client(
            core,
            string.format(
                "===> 战力评价结果: %s = 基战%s * 长度%s + 技战%s + 叛战%s + 落战%s + 天赋%s + 超3连%s + 怒气%s\n\n++++++++++++++++++++\n",
                ret,
                baseAttack,
                linkCount,
                skillTotalEv,
                rebelHeroTotalEv,
                yEv,
                talentEv,
                more3Ev,
                exSkillEv
            )
        )
    end

    if table.empty(exceptBlockList) then
        return ret, exSkillGridId, nil
    else
        return ret, exSkillGridId, {blocks = blockList, exceptBlocks = exceptBlockList}
    end
end

-- 获取普通的怒气技能选项
function root:getNormatlExSkillGridId(core, actionCastle, ids)
    local blockList = self:getBlockList(core, ids)

    local skillInfoList = self:getSkillInfoList(core, blockList)
    local exSkillInfoList = self:getExSkillInfoList(core, actionCastle, blockList, skillInfoList)
    if exSkillInfoList and #exSkillInfoList > 0 then
        local skillInfo = exSkillInfoList[math.random(#exSkillInfoList)]
        return skillInfo.id
    else
        return nil
    end
end

-- 获取参数
function root:getParams(core, actionCastle, ids, linkColor)
    local linkHeroInfo = self:getLinkHeroResult(core, actionCastle, ids, linkColor)
    local enemyHeroList = linkHeroInfo.enemyHeroList
    local selfHeroList = linkHeroInfo.selfHeroList
    local rebelHeroList = linkHeroInfo.rebelHeroList
    local newHero = linkHeroInfo.newHero
    local newHeroX = linkHeroInfo.newHeroX
    local newHeroY = linkHeroInfo.newHeroY
    local absorbBuffList = linkHeroInfo.absorbBuffList
    local enemySkillBlockList = linkHeroInfo.enemySkillBlockList
    local enemyBeforeSkillBlockList = linkHeroInfo.enemyBeforeSkillBlockList
    local selfNormalBlockCount = linkHeroInfo.selfNormalBlockCount
    local yDirection = linkHeroInfo.yDirection
    local selfSkillBlockList = linkHeroInfo.selfSkillBlockList
    local newBlockXYMap = self:getNewBlockXYMap(core, actionCastle, ids)

    local enemyCastle = core:getEnemyCastle(actionCastle)
    local averageBaseAttack = self:getAverageBaseAttack(core, actionCastle)
    local enemyAverageBaseAttack = self:getAverageBaseAttack(core, enemyCastle)
    local enemyHeroCount = #enemyHeroList
    local enemyHeroTotalEv = self:getHeroListEvaluate(core, enemyHeroList)
    local enemyCastleHp = enemyCastle.castleCurHp
    local enemyCastleMaxHp = enemyCastle.castleMaxHp
    local selfHeroCount = #selfHeroList
    local selfHeroTotalEv = self:getHeroListEvaluate(core, selfHeroList)
    local selfCastleHp = actionCastle.castleCurHp
    local selfCastleMaxHp = actionCastle.castleMaxHp
    local rebelHeroTotalEv = self:getHeroListEvaluate(core, rebelHeroList)
    local newHeroAttack = newHero:getHp()
    local baseAttack = self:getBaseAttack(core, actionCastle, linkColor)
    local linkCount = #ids
    local enemyHasDun = enemyCastle:hasBuffType(battleConst.BUFF_TYPE.CASTLE_SHIELD)
    local selfHasPoison = actionCastle:hasBuffType(battleConst.BUFF_TYPE.POISON)
    local enemyCurseEv = self:getCastleBuffEv(enemyCastle, battleConst.BUFF_TYPE.CURSE)
    local enemyHasAssassin = enemyCastle:hasBuffType(battleConst.BUFF_TYPE.ASSASSIN)

    local ret = {
        averageBaseAttack = averageBaseAttack, -- 我方卡组平均卡牌基础战力
        enemyAverageBaseAttack = enemyAverageBaseAttack, -- 敌方卡组平均卡牌基础战力
        enemyHeroList = enemyHeroList, -- 敌方英雄列表：消除色块后的。计算了叛变
        enemyHeroCount = enemyHeroCount, -- 敌方英雄个数：消除色块后的。计算了叛变
        enemyHeroTotalEv = enemyHeroTotalEv, -- 敌方英雄总战力：消除色块后的。计算了叛变
        enemyCastleHp = enemyCastleHp, -- 敌方基地血量
        enemyCastleMaxHp = enemyCastleMaxHp, -- 敌方基地最大血量
        enemyHasDun = enemyHasDun, -- 敌方是否有盾
        selfHasPoison = selfHasPoison, -- 我方基地是否中毒
        enemyCurseEv = enemyCurseEv, -- 诅咒战力
        enemyHasAssassin = enemyHasAssassin, -- 敌方基地是否有刺客BUFF
        selfHeroList = selfHeroList, -- 我方英雄列表：消除色块后的。计算了叛变，包含新英雄
        selfHeroCount = selfHeroCount, -- 我方英雄个数：消除色块后的。计算了叛变，包含新英雄
        selfHeroTotalEv = selfHeroTotalEv, -- 我方英雄总战力：消除色块后的。计算了叛变，包含新英雄
        selfCastleHp = selfCastleHp, -- 我方基地血量
        selfCastleMaxHp = selfCastleMaxHp, -- 我方基地最大血量
        rebelHeroTotalEv = rebelHeroTotalEv, -- 叛变英雄总战力
        newHeroAttack = newHeroAttack, -- 新英雄攻击力：计算了连线英雄的继承。不计buff、护盾
        baseAttack = baseAttack, -- 普通色块基础战力: 连线将生成的英雄的基础战力
        linkCount = linkCount, -- 色块数量：即连线的长度
        newHeroX = newHeroX, -- 新英雄的落点X
        newHeroY = newHeroY, -- 新英雄的落点Y
        absorbBuffList = absorbBuffList, -- 新英雄继承的buff列表
        newHero = newHero, -- 新英雄
        enemySkillBlockList = enemySkillBlockList, -- 敌方技能色块列表：消除色块后的。
        enemyBeforeSkillBlockList = enemyBeforeSkillBlockList, -- 敌方技能色块列表：消除色块前的。
        selfNormalBlockCount = selfNormalBlockCount, -- 我方普通色块数量：消除色块后的。
        yDirection = yDirection, -- 获取Y方向掉落的方向：1表示向上掉落，-1表示向下掉落
        newBlockXYMap = newBlockXYMap, -- 消除后的色块位置
        selfSkillBlockList = selfSkillBlockList -- 我方的技能数
    }

    return ret
end

function root:getHeroMinHp(heroList)
    if not heroList or #heroList <= 0 then
        return 0
    end

    local minHp
    for index, value in ipairs(heroList) do
        local hp = value:getHp()
        if not minHp or minHp > hp then
            minHp = hp
        end
    end

    return minHp or 0
end

-- 技能色块平均收益
function root:getSkillAvgEvaluate(core, skillInfo, params, skillBlockList, skillId)
    local skillCount = skillInfo.skillCount

    local blockList = {}
    for _, block in ipairs(skillBlockList or {}) do
        if block.skillId ~= (skillId or 1111) then
            table.insert(blockList, block)
        end
    end
    if #blockList <= 0 then
        return 0
    end

    skillCount = math.min(skillCount, #blockList)

    local skillInfoList = self:getSkillInfoList(core, blockList)
    local skillTotalEv = 0
    for _, v in ipairs(skillInfoList) do
        local skillEv = self:getSkillEvaluate(core, v, params)
        if skillEv then
            skillTotalEv = skillTotalEv + skillEv
        end
    end
    local evaluate = skillTotalEv / #blockList * skillCount

    return math.floor(evaluate + 0.5)
end

function root:getLowHeroCount(newHeroAttack, enemyHeroList)
    local ev = 0
    local lowHeroCount = 0
    for _, hero in ipairs(enemyHeroList) do
        local hp = hero:getHp()
        if hp < (newHeroAttack * 0.25) then
            lowHeroCount = lowHeroCount + 1
        end
    end
    return lowHeroCount
end

-- 获取联系后的英雄结果
function root:getLinkHeroResult(core, actionCastle, ids, linkColor)
    -- 连线前所有英雄
    local oldAllHero = core:getAllHero()
    -- 连线包含的英雄列表，将合并到新英雄
    local linkHeroList = {}
    -- 反之
    local notLinkHeroList = {}
    -- 掉落方向
    local yDirection = self:getYDirection(core, actionCastle)
    -- 格子列表
    local blockList = self:getBlockList(core, ids)

    for _, v in ipairs(oldAllHero) do
        local id = v.bindBlock.id
        if table.indexof(ids, id) then
            table.insert(linkHeroList, v)
        else
            table.insert(notLinkHeroList, v)
        end
    end

    -- 每行y方向掉落的数量
    local yDeltaList = {}
    for i = 1, core.areaW do
        table.insert(yDeltaList, 0)
    end
    -- 新英雄的落点
    local lastBlock = blockList[#blockList]
    local newHeroX = lastBlock.x
    local newHeroY = lastBlock.y
    yDeltaList[lastBlock.x + 1] = -1
    for _, v in ipairs(blockList) do
        yDeltaList[v.x + 1] = yDeltaList[v.x + 1] + 1
        if v.x == lastBlock.x and (v.y - lastBlock.y) * yDirection > 0 then
            -- (第2行空了 - 落地在第3行) * -1 > 0，英雄-1行
            -- (第8行空了 - 落地在第7行) * 1 > 0，英雄+1行
            newHeroY = newHeroY + yDirection
        end
    end

    local enemyHeroList = {}
    local selfHeroList = {}
    local rebelHeroList = {}
    for _, v in ipairs(notLinkHeroList) do
        local isSelf = self:isSelfBlock(yDirection, v.bindBlock.y)
        if isSelf then
            table.insert(selfHeroList, v)
        else
            local deltaY = yDirection * yDeltaList[v.bindBlock.x + 1]
            local isSelf = self:isSelfBlock(yDirection, v.bindBlock.y + deltaY)
            if isSelf then
                table.insert(selfHeroList, v)
                table.insert(rebelHeroList, v)
            else
                table.insert(enemyHeroList, v)
            end
        end
    end

    table.sort(
        selfHeroList,
        function(a, b)
            return a:getHp() < b:getHp()
        end
    )
    table.sort(
        enemyHeroList,
        function(a, b)
            return a:getHp() < b:getHp()
        end
    )

    local enemyBeforeSkillBlockList = {}
    local enemySkillBlockList = {}
    local selfSkillBlockList = {}
    local selfNormalBlockCount = 0
    for _, block in ipairs(core.map) do
        if block.skillId > 0 then
            if not self:isSelfBlock(yDirection, block.y) then
                table.insert(enemyBeforeSkillBlockList, block)
                local deltaY = yDirection * yDeltaList[block.x + 1]
                if not self:isSelfBlock(yDirection, block.y + deltaY) then
                    table.insert(enemySkillBlockList, block)
                end
            else
                local deltaY = yDirection * yDeltaList[block.x + 1]
                if self:isSelfBlock(yDirection, block.y + deltaY) then
                    table.insert(selfSkillBlockList, block)
                end
            end
        else
            if self:isSelfBlock(yDirection, block.y) then
                selfNormalBlockCount = selfNormalBlockCount + 1
            else
                local deltaY = yDirection * yDeltaList[block.x + 1]
                if self:isSelfBlock(yDirection, block.y + deltaY) then
                    selfNormalBlockCount = selfNormalBlockCount + 1
                end
            end
        end
    end

    local absorbHeroHp = 0
    local absorbBuffList = {} -- 不严谨的buffList，仅用于天赋buff的判定
    for _, v in ipairs(linkHeroList) do
        absorbHeroHp = absorbHeroHp + v:getHp()
        table.arry_merge(absorbBuffList, v.buffList)
    end

    local playerData = actionCastle:getMainPlayer()
    local cardInfo = playerData:getCardByColor(linkColor)
    local cardId = cardInfo.id
    local baseAttack = cardInfo.attack
    local talentSkillLevel = cardInfo.talentSkillLevel
    local heroLv = #ids
    local hp = math.floor(baseAttack * heroLv + absorbHeroHp)
    local heroParams = {
        id = cardId,
        hp = hp,
        maxHp = hp,
        attack = hp,
        level = heroLv,
        cardLv = baseAttack,
        block = lastBlock,
        isCall = false,
        exHp = 0,
        exAttack = 0,
        talentSkillLevel = talentSkillLevel
    }
    local newHero = self:newHero(heroParams)
    table.insert(selfHeroList, newHero)

    return {
        enemyHeroList = enemyHeroList,
        selfHeroList = selfHeroList,
        rebelHeroList = rebelHeroList,
        newHero = newHero,
        newHeroX = newHeroX,
        newHeroY = newHeroY,
        absorbBuffList = absorbBuffList,
        enemySkillBlockList = enemySkillBlockList,
        enemyBeforeSkillBlockList = enemyBeforeSkillBlockList,
        selfNormalBlockCount = selfNormalBlockCount,
        yDirection = yDirection,
        selfSkillBlockList = selfSkillBlockList
    }
end

-- 获取消除后色块对应的位置
function root:getNewBlockXYMap(core, actionCastle, ids)
    local needUpdateIds = table.clone(ids, true)
    table.remove(needUpdateIds)
    battleUtils:setBlockUpdateState(core.map, needUpdateIds)
    local map = {}
    for x = 0, 4 do
        local xyBlockList = battleUtils:getNewXYBlockList(core.map, actionCastle.seat, x)
        for y = 0, 9 do
            local battleBlock = xyBlockList[y + 1]
            map[battleBlock.id] = {x = x, y = y}
        end
    end
    battleUtils:setBlockNormalState(core.map, needUpdateIds)
    return map
end

-- 获取落点的战力评估
function root:getYEvaluate(core, y, baseAttack)
    local evList
    if core.areaH == 5 then
        -- evList = {0.5, 0, -0.5, -1, -2, -2, -1, -0.5, 0, 0.5}
        evList = {2, 1, -0.5, -1.5, -3, -3, -1.5, -0.5, 1, 2}
    elseif core.areaH == 6 then
        evList = {1, 0.5, 0, -0.5, -1, -2, -2, -1, -0.5, 0, 0.5, 1}
    elseif core.areaH == 7 then
        evList = {1, 0.5, 0, -0.5, -1, -2, -2, -2, -2, -1, -0.5, 0, 0.5, 1}
    else
        evList = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    end
    return evList[y + 1] * baseAttack
end

function root:getTalentEvaluate(core, params, skillInfoList)
    local absorbBuffList = params.absorbBuffList
    local newHero = params.newHero
    local heroId = newHero.id

    local talentId = battleAdapt:getTalentIdByCardID(heroId)
    if not talentId then
        return 0
    end

    local talentInfo = battleAdapt:getTalentByID(talentId)
    local exBuffIds = talentInfo.exBuffIds
    local exSkillIds = talentInfo.exSkillIds
    if exBuffIds then
        if self:isExcludeBuff(exBuffIds, absorbBuffList) then
            return 0
        end
    end
    if exSkillIds then
        if self:isExcludeSkill(exSkillIds, skillInfoList) then
            return 0
        end
    end

    local funcName = string.format("getTalentEvaluate%s", talentId)
    local func = self[funcName]
    if not func then
        log.warning("！！！天赋评价需要接入 " .. funcName)
        return 0
    end

    return func(self, core, talentInfo, params)
end

-- 判断是否是被buff排斥
function root:isExcludeBuff(exBuffIds, buffList)
    for _, v in ipairs(buffList) do
        local buffId = v.buffId
        if table.indexof(exBuffIds, buffId) then
            return true
        end
    end

    return false
end

-- 判断是否是被技能排斥
function root:isExcludeSkill(exSkillIds, skillInfoList)
    for _, v in ipairs(skillInfoList) do
        local skillId = v.skillId
        if table.indexof(exSkillIds, skillId) then
            return true
        end
    end

    return false
end

-- 获取Y方向掉落的方向：1表示向上掉落，-1表示向下掉落
function root:getYDirection(core, actionCastle)
    local castles = core:getAllCastle()
    if actionCastle == castles[1] then
        -- 自己在下方，向下掉落
        return -1
    else
        -- 自己在上方，向上掉落
        return 1
    end
end

-- 判断是否是自己格子
function root:isSelfBlock(yDirection, y)
    if yDirection == -1 then
        -- 自己在下方，0~4是自己的
        return y < 5
    else
        -- 自己在上方，5~9是自己的
        return y >= 5
    end
end

-- 新建英雄
function root:newHero(heroParams)
    local hero = battleHero.new(heroParams)
    return hero
end

-- 卡组平均卡牌基础战力
function root:getAverageBaseAttack(core, actionCastle)
    local playerData = actionCastle:getMainPlayer()
    local cards = playerData.cards
    local total = 0
    for _, v in ipairs(cards) do
        total = total + v.attack
    end

    return math.floor(total / 4 + 0.5)
end

-- 普通色块基础战力: 连线将生成的英雄的基础战力
function root:getBaseAttack(core, actionCastle, linkColor)
    local playerData = actionCastle:getMainPlayer()
    local cardInfo = playerData:getCardByColor(linkColor)

    return cardInfo.attack
end

-- 基地buff战力
function root:getCastleBuffEv(actionCastle, buffType)
    local ev = 0
    local buffs = actionCastle:getBuffByType(buffType)
    for _, buff in ipairs(buffs) do
        ev = ev + buff.cardLv
    end
    return ev
end

-- 获取指定的格子列表
function root:getBlockList(core, ids)
    local ret = {}
    for _, v in ipairs(ids) do
        local block = battleUtils:getColorBlockByID(core.map, v)
        table.insert(ret, block)
    end

    return ret
end

-- 获取技能色块信息列表
function root:getSkillInfoList(core, blockList)
    local ret = {}

    local skillInfoMap = {}
    for _, v in ipairs(blockList) do
        if v.skillId > 0 then
            if not skillInfoMap[v.skillId] then
                local skillInfo = {
                    id = v.id,
                    skillId = v.skillId,
                    skillBase = v.cardLv,
                    skillCount = 1,
                    x = v.x,
                    y = v.y
                }
                if v.skillId == 3031 then
                    skillInfo.data3031 = skillInfo.data3031 or {}
                    skillInfo.data3031[skillInfo.x] = true
                end

                -- 这奇葩的做法,反来者不要骂我.
                if v.skillId == 3241 then
                    skillInfo.data3241 = skillInfo.data3241 or {}
                    skillInfo.data3241[skillInfo.x] = true
                end

                table.insert(ret, skillInfo)
                skillInfoMap[v.skillId] = skillInfo
            else
                -- 可叠加的色块处理
                if self:getSkillEnableAdd(v.skillId) then
                    local skillInfo = skillInfoMap[v.skillId]
                    local canAdd = true
                    if v.skillId == 3031 then
                        canAdd = false
                        skillInfo.data3031 = skillInfo.data3031 or {}
                        skillInfo.data3031[v.x] = true
                    end

                    -- 这奇葩的做法,反来者不要骂我.
                    if v.skillId == 3241 then
                        canAdd = false
                        skillInfo.data3241 = skillInfo.data3241 or {}
                        skillInfo.data3241[v.x] = true
                    end

                    if canAdd then
                        skillInfo.skillCount = skillInfo.skillCount + 1
                    end
                end
            end
        end
    end

    return ret
end

-- 获取额外技能色块信息列表
function root:getExSkillInfoList(core, actionCastle, blockList, skillInfoList)
    local skillBlocks = core:getCastleSkillBlockObjs(actionCastle)

    local ret = {}

    for _, v in ipairs(skillBlocks) do
        if not v:isLock() then
            local skillId = v.skillId
            -- 技能不能在连线上
            if not table.indexof(blockList, v) then
                -- 技能不可叠加
                if not table.key_find(skillInfoList, "skillId", skillId) and not table.key_find(ret, "skillId", skillId) then
                    local skillInfo = {
                        id = v.id,
                        skillId = v.skillId,
                        skillBase = v.cardLv,
                        skillCount = 1,
                        x = v.x,
                        y = v.y
                    }
                    if v.skillId == 3031 then
                        skillInfo.data3031 = {[skillInfo.x] = true}
                    end

                    -- 这奇葩的做法,反来者不要骂我.
                    if v.skillId == 3241 then
                        skillInfo.data3241 = {[skillInfo.x] = true}
                    end

                    table.insert(ret, skillInfo)
                end
            end
        end
    end

    return ret
end

-- 获取技能配置
function root:getSkillConfig(skillId)
    return battleAdapt:getSkillByID(skillId)
end

-- 判断技能是否可以叠加
function root:getSkillEnableAdd(skillId)
    local config = self:getSkillConfig(skillId) or {}
    return config.isAdd and config.isAdd == 1
end

-- 获取技能组合的总评价
function root:getSkillSetTotalEv(config, firstId, secondIds)
    local ret = 0

    if secondIds and #secondIds > 0 then
        for _, v in ipairs(secondIds) do
            ret = ret + self:getSkillSetEv(config, firstId, v)
        end
    end

    return ret
end

-- 获取技能组合评价
function root:getSkillSetEv(config, firstId, secondId)
    for _, v in ipairs(config) do
        if v.firstId == firstId and v.secondId == secondId then
            return v.ev
        end
    end

    return 0
end

-- 获取英雄的战力
function root:getHeroEvaluate(core, hero)
    -- local buffs = hero:getBuffByType(battleConst.BUFF_TYPE.VALUE_SHIELD)
    -- local shield = 0
    -- for _, buff in ipairs(buffs) do
    --     shield = shield + (buff.hp or 0)
    -- end
    -- return hero:getHp() + shield * 0.5
    return hero:getHp()
end

-- 获取英雄列表的总战力
function root:getHeroListEvaluate(core, heroList)
    local ret = 0
    for _, v in ipairs(heroList) do
        ret = ret + self:getHeroEvaluate(core, v)
    end

    return ret
end

-- 判断是否斩杀
function root:isKill(core, skillInfoList, params)
    local enemyHasDun = params.enemyHasDun
    local enemyCastleHp = params.enemyCastleHp
    local enemyCastleMaxHp = params.enemyCastleMaxHp
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroCount = params.selfHeroCount
    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList
    local selfHasPoison = params.selfHasPoison
    local selfCastleHp = params.selfCastleHp
    local selfNormalBlockCount = params.selfNormalBlockCount
    local enemyCurseEv = params.enemyCurseEv
    local enemyHasAssassin = params.enemyHasAssassin
    local rebelHeroTotalEv = params.rebelHeroTotalEv

    local enemyHeroHighestEv =
        enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0
    local enemyHeroLowestEv = enemyHeroList[1] and self:getHeroEvaluate(core, enemyHeroList[1]) or 0
    local selfHeroLowestEv = selfHeroList[1] and self:getHeroEvaluate(core, selfHeroList[1]) or 0

    if enemyHasDun then
        return false
    end

    local function getSkill(skillId)
        for _, skill in ipairs(skillInfoList) do
            if skill.skillId == skillId then
                return skill
            end
        end
    end

    if getSkill(3041) then
        return enemyCastleMaxHp * 0.1 >= enemyCastleHp
    end

    -- 小青
    if getSkill(3351) then
        return enemyCastleMaxHp * 0.1 >= enemyCastleHp
    end

    local A = selfHeroTotalEv
    local skill = getSkill(1031)
    if skill then
        A = A + selfHeroCount * 2 * skill.skillBase * skill.skillCount
    end

    skill = getSkill(2011)
    if skill then
        A = A + 3 * skill.skillBase * math.min(skill.skillCount, math.floor(selfNormalBlockCount / 3))
    end

    skill = getSkill(2051)
    if skill then
        A = A + selfHeroCount * 1 * skill.skillBase * skill.skillCount
    end

    skill = getSkill(2131)
    if skill then
        A = A + enemyHeroHighestEv - selfHeroLowestEv
    end

    skill = getSkill(3101)
    if skill then
        A = A + 2 * skill.skillBase * skill.skillCount
    end

    skill = getSkill(4351)
    if skill then
        A = A + 2 * skill.skillBase * skill.skillCount
    end

    skill = getSkill(3121)
    if skill then
        A = A + 2 * skill.skillBase * skill.skillCount
    end

    local B = enemyHeroTotalEv
    skill = getSkill(3071)
    if skill then
        for i = 1, skill.skillCount do
            if enemyHeroList[i] then
                B = B - self:getHeroEvaluate(core, enemyHeroList[i])
            end
        end
    end

    -- 旧的乔乔
    skill = getSkill(4031)
    if skill then
        for i = 1, skill.skillCount do
            if enemyHeroList[i] then
                B = B - self:getHeroEvaluate(core, enemyHeroList[i])
            end
        end
    end

    -- 新的乔乔
    skill = getSkill(2361)
    if skill then
        for i = 1, skill.skillCount do
            if enemyHeroList[i] then
                B = B - self:getHeroEvaluate(core, enemyHeroList[i])
            end
        end
    end

    skill = getSkill(4101)
    if skill then
        for i = 1, skill.skillCount do
            if enemyHeroList[#enemyHeroList + 1 - i] then
                B = B - self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList + 1 - i])
            end
        end
    end

    skill = getSkill(2131)
    if skill then
        B = B - (enemyHeroHighestEv - selfHeroLowestEv)
    end

    local C = 0
    skill = getSkill(2041)
    if skill then
        C = C + enemyCastleMaxHp * 0.25 * math.min(skill.skillCount, selfHeroCount)
    end

    skill = getSkill(2071)
    if skill then
        C = C + 2 * skill.skillBase * skill.skillCount
    end

    skill = getSkill(4011)
    if skill then
        C = C + enemyCastleMaxHp * 0.15 * skill.skillCount
    end

    skill = getSkill(4091)
    if skill then
        C = C + (enemyCastleHp + selfCastleHp) / 2 - selfCastleHp
    end

    local k1 = getSkill(3111) and 1.5 or 1

    local k2 = 0
    for _, hero in ipairs(enemyHeroList) do
        local buffs = hero:getBuffByType(battleConst.BUFF_TYPE.VALUE_SHIELD)
        for _, buff in ipairs(buffs) do
            k2 = k2 + (buff.hp or 0)
        end
    end

    local k3 = selfHasPoison and 0.5 or 1

    local n = 0
    for _, hero in ipairs(enemyHeroList) do
        n = n + #hero:getBuffByType(battleConst.BUFF_TYPE.LIFE_SHIELD)
    end
    local k4 = 0
    for i = 1, n do
        if selfHeroList[#selfHeroList + 1 - i] then
            k4 = k4 + 0.5 * self:getHeroEvaluate(core, selfHeroList[#selfHeroList + 1 - i])
        end
    end

    local k5 = 1
    for _, hero in ipairs(enemyHeroList) do
        if hero:hasBuffType(battleConst.BUFF_TYPE.ALL_SHIELD) then
            k5 = 0.5
            break
        end
    end

    local k6 = 0
    for _, hero in ipairs(selfHeroList) do
        local buffs = hero:getBuffByType(battleConst.BUFF_TYPE.RESUME)
        for _, buff in ipairs(buffs) do
            k6 = k6 + 3 * buff.cardLv
        end
    end

    local k7 = 0
    for _, hero in ipairs(selfHeroList) do
        if hero:hasBuffType(battleConst.BUFF_TYPE.BRIBE) then
            k7 = k7 + self:getHeroEvaluate(core, hero)
        end
    end

    local k8 = 0
    for _, hero in ipairs(selfHeroList) do
        local buffs = hero:getBuffByType(battleConst.BUFF_TYPE.CALL)
        for _, buff in ipairs(buffs) do
            k8 = k8 + 2 * buff.cardLv
        end
    end

    local k9 = 0
    for _, hero in ipairs(selfHeroList) do
        if hero:hasBuffType(battleConst.BUFF_TYPE.LOCK) then
            k9 = k9 + self:getHeroEvaluate(core, hero)
        end
    end

    local k10 = 0
    for _, hero in ipairs(selfHeroList) do
        if hero:hasBuffType(battleConst.BUFF_TYPE.FREEZE) then
            k10 = k10 + self:getHeroEvaluate(core, hero)
        end
    end

    local k11 = 2 * enemyCurseEv

    local k12 = enemyHasAssassin and rebelHeroTotalEv or 0

    local ret = math.max((A - k4 + k6 - k7 + k8 - k9 - k10 - k12) * k1 * k3 * k5 - (B + k2), 0) + (C + k11)
    log2Client(
        core,
        string.format(
            "===> 斩杀评价：A=%s B=%s C=%s k1=%s k2=%s k3=%s k4=%s k5=%s k6=%s k7=%s k8=%s k9=%s k10=%s k11=%s k12=%s ret=%s",
            A,
            B,
            C,
            k1,
            k2,
            k3,
            k4,
            k5,
            k6,
            k7,
            k8,
            k9,
            k10,
            k11,
            k12,
            ret
        )
    )
    return ret > enemyCastleHp
end

function root:getSkillEvaluate(core, skillInfo, params)
    local skillId = skillInfo.skillId
    local funcName = string.format("getSkillEvaluate%s", skillId)

    -- TODO: Debug 测试代码,上线前修改过来.
    -- showDataLog(params)

    local func = self[funcName]
    if func then
        return func(self, core, skillInfo, params)
    else
        battleLog:logError(string.format("技能[%d],对应的功能方法不存在!", skillId))
        return self:getSkillEvaluateCommon(core, skillInfo, params)
    end
end

-- 技能评价 - 不叠加 - 3221 装备护甲，使受到的伤害降低50%。持续到死亡 (参考 3051 SWAT 生成英雄的血量*65%)
function root:getSkillEvaluateCommon(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack

    return newHeroAttack * 0.65
end

-- 技能评价 - 可叠加 - 1011 机器人 (15%*我方基地最大血量*50%)+根据我方基地血量百分比(30%、10%)增加不同个普通色块数的战力(0.5、1)
function root:getSkillEvaluate1011(core, skillInfo, params)
    local skillCount = skillInfo.skillCount

    local baseAttack = params.baseAttack
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp

    local ev = 0.15 * selfCastleMaxHp * 0.5 * skillCount

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.1 then
        ev = ev + baseAttack * 1 * skillCount
    elseif percent <= 0.3 then
        ev = ev + baseAttack * 0.5 * skillCount
    end

    return ev
end

-- 技能评价 - 可叠加 - 2011 洛克犬 3*对应技能色块战力*75%
function root:getSkillEvaluate2011(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    return 3 * skillBase * 0.75 * skillCount
end

-- 技能评价 - 可叠加 - 3011 特警 max{(5*敌方平均技能色块战力+max{(敌方所有英雄战力总和-我方所有英雄战力总和),0} - 我方所有英雄战力总和), 0}*50%+根据我方基地血量百分比(30%、10%)增加不同个普通色块数的战力(1.5、3)
function root:getSkillEvaluate3011(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local baseAttack = params.baseAttack

    local ev =
        math.max(5 * enemyAverageBaseAttack + math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) - selfHeroTotalEv, 0) *
        0.5

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.1 then
        ev = ev + baseAttack * 3
    elseif percent <= 0.3 then
        ev = ev + baseAttack * 1.5
    end

    return ev * skillCount
end

-- 技能评价 - 可叠加 - 4011 扎克 敌方基地最大血量*15%*50%
-- 有盾
-- 收益值=0
function root:getSkillEvaluate4011(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local enemyHasDun = params.enemyHasDun
    local enemyCastleMaxHp = params.enemyCastleMaxHp

    if enemyHasDun then
        return 0
    end

    return enemyCastleMaxHp * 0.15 * 0.5 * skillCount
end

-- 技能评价 - 不叠加 - 1021 修理师 根据我方基地血量百分比（100%，50%）增加不同倍对应技能色块的战力（2,1）
function root:getSkillEvaluate1021(core, skillInfo, params)
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local percent = selfCastleHp / selfCastleMaxHp
    local skillBase = skillInfo.skillBase
    if percent <= 0.5 then
        return skillBase
    end

    return skillBase * 2
end

-- 技能评价 - 不叠加 - 2021 朋克头 敌方所有英雄战力总和*50%*75%
-- 有盾
-- 若对方只有一个英雄则为0
-- 多个英雄：
-- 敌方所有英雄战力总和*50%*50%
function root:getSkillEvaluate2021(core, skillInfo, params)
    local enemyHasDun = params.enemyHasDun
    local enemyHeroCount = params.enemyHeroCount
    local enemyHeroTotalEv = params.enemyHeroTotalEv

    if enemyHasDun then
        return enemyHeroCount > 1 and enemyHeroTotalEv * 0.5 * 0.5 or 0
    end

    return enemyHeroTotalEv * 0.75 * 0.5
end

-- 技能评价 - 可叠加 - 3021 罗杰 我方平均技能色块战力*3*65%
function root:getSkillEvaluate3021(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local averageBaseAttack = params.averageBaseAttack

    return averageBaseAttack * 3 * 0.65 * skillCount
end

-- 技能评价 - 不叠加 - 4021 神枪手 min(max{(敌方最强英雄战力-生成英雄的血量),0}, 生成英雄的血量)*75%，如果对方没英雄，收益值=生成英雄的血量*50%
-- 有盾
-- min(max{(敌方最强英雄战力-生成英雄的血量),0}, 生成英雄的血量)*75%，对方没英雄时，收益值=0
function root:getSkillEvaluate4021(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local enemyHasDun = params.enemyHasDun

    if not enemyHeroList[#enemyHeroList] then
        return not enemyHasDun and newHeroAttack * 0.5 or 0
    else
        return math.min(
            math.max(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) - newHeroAttack, 0),
            newHeroAttack
        ) * 0.75
    end
end

-- 技能评价 - 可叠加 - 1031 博士 我方所有英雄数*2*对应技能色块战力
function root:getSkillEvaluate1031(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local selfHeroCount = params.selfHeroCount
    local skillBase = skillInfo.skillBase

    return selfHeroCount * skillBase * 2 * skillCount
end

-- 技能评价 - 可叠加 - 2031 死神 (我方基地最大血量*25%*50%-我方最弱英雄战力*100%)+根据我方基地血量百分比(30%、10%)增加不同个普通色块数的战力(1、1.5)
function root:getSkillEvaluate2031(core, skillInfo, params)
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local baseAttack = params.baseAttack
    local skillCount = skillInfo.skillCount
    local selfHeroList = params.selfHeroList

    local ev = 0
    for i = 1, skillCount do
        if selfHeroList[i] then
            ev = ev + selfCastleMaxHp * 0.25 * 0.5 - self:getHeroEvaluate(core, selfHeroList[i]) * 1

            local percent = selfCastleHp / selfCastleMaxHp
            if percent <= 0.1 then
                ev = ev + baseAttack * 1.5
            elseif percent <= 0.3 then
                ev = ev + baseAttack * 1
            end
        end
    end

    return ev
end

-- 技能评价 - 可叠加 - 3031 间谍 同列上敌方英雄战力总和+英雄落点变化收益（生成英雄落点变化收益+我方英雄落点变化收益]
-- 生成英雄落点变化收益=用完技能后的落地收益-生成英雄后用技能前的落地收益
-- 我方英雄落点变化收益= 满足数量1*普通色块基础战力+满足数量2*0.5*普通色块基础战力
-- 满足数量1 = 用完技能后落点Y轴变化≥3的我方英雄数 （与生成英雄后用技能前的Y轴对比）
-- 满足数量2 = 用完技能后落点Y轴变化 = 2 的我方英雄数（与生成英雄后用技能前的Y轴对比）
function root:getSkillEvaluate3031(core, skillInfo, params)
    local xMap = skillInfo.data3031
    local totalHeroEvaluate = 0
    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList
    local baseAttack = params.baseAttack
    local yDirection = params.yDirection
    local newHeroX = params.newHeroX
    local newHeroY = params.newHeroY
    local newBlockXYMap = params.newBlockXYMap

    local xHeros = {}
    local function changeToXHeros(heroList)
        for _, hero in ipairs(heroList) do
            if xMap[hero.bindBlock.x] then
                if not xHeros[hero.bindBlock.x] then
                    xHeros[hero.bindBlock.x] = {}
                end
                table.insert(xHeros[hero.bindBlock.x], {hero = hero, point = newBlockXYMap[hero.bindBlock.id]})
            end
        end
    end
    changeToXHeros(enemyHeroList)
    changeToXHeros(selfHeroList)

    local newHeroLastY = -1
    local selfYChange3Count = 0
    local selfYChange2Count = 0
    local function calc(v, yDirection)
        local sortY, getY
        if yDirection < 0 then
            sortY = function(a, b)
                return a.point.y < b.point.y
            end
            getY = function(i)
                return i - 1
            end
        elseif yDirection > 0 then
            sortY = function(a, b)
                return a.point.y > b.point.y
            end
            getY = function(i)
                return 10 - i
            end
        end
        table.sort(v, sortY)
        for i = 1, #v do
            local y = getY(i)
            if v[i].point.x == newHeroX and v[i].point.y == newHeroY then
                newHeroLastY = y
            else
                local beforeIsSelf = self:isSelfBlock(yDirection, v[i].point.y)
                local afterIsSelf = self:isSelfBlock(yDirection, y)
                if not beforeIsSelf and afterIsSelf then
                    totalHeroEvaluate = totalHeroEvaluate + self:getHeroEvaluate(core, v[i].hero)
                elseif beforeIsSelf and afterIsSelf then
                    local change = math.abs(y - v[i].point.y)
                    if change >= 3 then
                        selfYChange3Count = selfYChange3Count + 1
                    elseif change == 2 then
                        selfYChange2Count = selfYChange2Count + 1
                    end
                end
            end
        end
    end
    for _, v in pairs(xHeros) do
        calc(v, yDirection)
    end

    local enemyHeroEv = totalHeroEvaluate
    local newHeroEv = 0
    if newHeroLastY > 0 then
        newHeroEv = self:getYEvaluate(core, newHeroLastY, baseAttack) - self:getYEvaluate(core, newHeroY, baseAttack)
    end
    local selfHeroEv = selfYChange3Count * 1 * baseAttack + selfYChange2Count * 0.5 * baseAttack
    totalHeroEvaluate = enemyHeroEv + newHeroEv + selfHeroEv

    return totalHeroEvaluate
end

-- 技能评价 - 可叠加 - 4031 化学老师 敌方最弱英雄战力*75%
function root:getSkillEvaluate4031(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local skillCount = skillInfo.skillCount

    local ev = 0
    for i = 1, skillCount do
        if enemyHeroList[i] then
            ev = ev + self:getHeroEvaluate(core, enemyHeroList[i]) * 0.75
        end
    end

    return ev
end

-- 技能评价 - 可叠加 - 1041 医师 根据敌方英雄站位算出收益值(60%:30%:10%:0:0)
-- eg:敌方英雄战力分布：第一排:第二排:第三排:第四排:第五排=100:50:30:50:30(第一排为接近中线的那排)
-- 收益值为=100*60%+50*30%+30*10%+50*0%+30*0%=78
--
-- 叠加比例上升(30%:20%:10%:5%:5%) max为100%
-- 连接技能色块数=x；
-- 基础比例为(a,b,c,d,e)
-- 叠加比例为(f,g,h,i,j)
-- 最终比例{min(a+(x-1)f,100),min(b+(x-1)g,100),…,min(e+(x-1)j,100)}
function root:getSkillEvaluate1041(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local newBlockXYMap = params.newBlockXYMap
    local enemyHeroEv = {}
    local areaH = core.areaH
    for i = 1, areaH * 2 do
        table.insert(enemyHeroEv, 0)
    end
    local enemyHeroList = params.enemyHeroList
    for _, hero in ipairs(enemyHeroList) do
        enemyHeroEv[newBlockXYMap[hero.bindBlock.id].y + 1] =
            enemyHeroEv[newBlockXYMap[hero.bindBlock.id].y + 1] + hero:getHp()
    end
    local enemyHeroParam = {0, 0, 0.1, 0.3, 0.6, 0.6, 0.3, 0.1, 0, 0}
    -- 半场行数超过5的，给补充0.6在中间
    for i = 1, areaH - 5 do
        table.insert(enemyHeroParam, 6, 0.6)
        table.insert(enemyHeroParam, 6, 0.6)
    end
    local addHeroParam = {0.05, 0.05, 0.1, 0.2, 0.3, 0.3, 0.2, 0.1, 0.05, 0.05}
    -- 半场行数超过5的，给补充0.3在中间
    for i = 1, areaH - 5 do
        table.insert(enemyHeroParam, 6, 0.3)
        table.insert(enemyHeroParam, 6, 0.3)
    end
    for i = 1, #enemyHeroParam do
        enemyHeroParam[i] = math.min(enemyHeroParam[i] + addHeroParam[i] * (skillCount - 1), 1)
    end
    local totalHeroEvaluate = 0
    for i = 1, #enemyHeroParam do
        totalHeroEvaluate = totalHeroEvaluate + enemyHeroEv[i] * enemyHeroParam[i]
    end
    return totalHeroEvaluate
end

-- 技能评价 - 可叠加 - 2041 爆破专家 (敌方基地最大血量*25%*50%-我方最弱英雄战力*100%)
-- 有盾
-- -我方最弱英雄战力*75%
function root:getSkillEvaluate2041(core, skillInfo, params)
    local enemyHasDun = params.enemyHasDun
    local enemyCastleMaxHp = params.enemyCastleMaxHp
    local selfHeroList = params.selfHeroList
    local skillCount = skillInfo.skillCount

    local ev = 0
    for i = 1, skillCount do
        if selfHeroList[i] then
            if enemyHasDun then
                ev = ev - self:getHeroEvaluate(core, selfHeroList[i]) * 0.75
            else
                ev = ev + enemyCastleMaxHp * 0.25 * 0.5 - self:getHeroEvaluate(core, selfHeroList[i]) * 1
            end
        end
    end

    return ev
end

-- 技能评价 - 可叠加 - 3041 极限特工 (新英雄战力 + 敌战力总和) * 0.5 - 我方战力总和
function root:getSkillEvaluate3041(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv

    return (newHeroAttack + enemyHeroTotalEv) * 0.5 - selfHeroTotalEv
end

-- 技能评价 - 可叠加 - 4041 黑帮 敌方受到的伤害总和*75%
-- 敌方受到的伤害总和=sum( min{hero_1_hp,3倍对应技能色块战力}, … , min{hero_999_hp,3倍对应技能色块战力})
function root:getSkillEvaluate4041(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 3 * skillCount
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    for _, hero in ipairs(enemyHeroList) do
        ev = ev + math.min(damage, self:getHeroEvaluate(core, hero))
    end

    return ev * 0.75
end

-- 技能评价 - 不叠加 - 1051 布雷泽 生成英雄的血量*50%*75%
function root:getSkillEvaluate1051(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack

    return newHeroAttack * 0.5 * 0.75
end

-- 技能评价 - 可叠加 - 2051 查理 (我方基地最大血量*15%*50%+我方所有英雄数*1*对应技能色块战力)
function root:getSkillEvaluate2051(core, skillInfo, params)
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfHeroCount = params.selfHeroCount
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount

    return (selfCastleMaxHp * 0.15 * 0.5 + selfHeroCount * 1 * skillBase) * skillCount
end

-- 技能评价 - 不叠加 - 3051 SWAT 生成英雄的血量*65%
function root:getSkillEvaluate3051(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack

    return newHeroAttack * 0.65
end

-- 技能评价 - 不叠加 - 4051 纵火犯 if 敌方所有英雄战力总和 - 我方所有英雄战力总和 >0: 敌方所有英雄数*对应技能色块战力*1*75% + 普通色块基础站力*1
-- else  :敌方所有英雄数*对应技能色块战力*1*75%
function root:getSkillEvaluate4051(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local enemyHeroCount = params.enemyHeroCount
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local baseAttack = params.baseAttack

    if enemyHeroTotalEv - selfHeroTotalEv > 0 then
        return enemyHeroCount * skillBase * 1 * 0.75 + baseAttack * 1
    else
        return enemyHeroCount * skillBase * 1 * 0.75
    end
end

-- 技能评价 - 可叠加 - 1061 辐射工兵 1*普通色块基础战力+max{(敌方所有英雄数-2),0}*2*对应技能色块战力*75%
function root:getSkillEvaluate1061(core, skillInfo, params)
    local baseAttack = params.baseAttack
    local enemyHeroCount = params.enemyHeroCount
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount

    return (baseAttack + math.max(enemyHeroCount - 2, 0) * 2 * skillBase * 0.75) * skillCount
end

-- 技能评价 - 可叠加 - 2061 派对DJ （我方所有英雄战力总和-敌方所有英雄战力总和）≥2*普通色块基础战力→2*普通色块基础战力，else0.5*普通色块基础战力
function root:getSkillEvaluate2061(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local baseAttack = params.baseAttack
    local skillCount = skillInfo.skillCount

    if (selfHeroTotalEv - enemyHeroTotalEv) >= 2 * baseAttack then
        return 2 * baseAttack * skillCount
    else
        return 0.5 * baseAttack * skillCount
    end
end

-- 技能评价 - 不叠加 - 3061 无人机队长 我方所有英雄战力总和*50%
function root:getSkillEvaluate3061(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv

    return selfHeroTotalEv * 0.5
end

-- 技能评价 - 不叠加 - 4061 杀手 max{(敌方最强英雄战力-生成英雄的血量),0}*75%+生成英雄的血量参数(≥7*色块数，+3*普通色块基础战力)
function root:getSkillEvaluate4061(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local linkCount = params.linkCount
    local baseAttack = params.baseAttack

    local ev = 0
    if enemyHeroList[#enemyHeroList] then
        ev = ev + math.max(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) - newHeroAttack, 0) * 0.75
    end
    if linkCount >= 7 then
        ev = ev + 3 * baseAttack
    end

    return ev
end

-- 技能评价 - 不叠加 - 1071 齐姆 连线数*对应技能色块战力*65%
function root:getSkillEvaluate1071(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local linkCount = params.linkCount

    return skillBase * linkCount * 0.65
end

-- 技能评价 - 可叠加 - 2071 温蒂 if 我方基地当前血量 ≥ 我方基地最大血量*50% : 2*对应技能色块战力*50%+2*对应技能色块战力*30%+2*对应技能色块战力*20%   else:2*对应技能色块战力*50%
-- 有盾
-- if 我方基地当前血量 ≥ 我方基地最大血量*50% :
-- 2*对应技能色块战力*30%+2*对应技能色块战力*20%
-- else:0
function root:getSkillEvaluate2071(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    local selfCastleHp = params.selfCastleHp
    local selfCastleMaxHp = params.selfCastleMaxHp
    local enemyHasDun = params.enemyHasDun

    if enemyHasDun then
        if selfCastleHp >= selfCastleMaxHp * 0.5 then
            return skillBase * 2 * 0.3 * skillCount + skillBase * 2 * 0.2 * skillCount
        else
            return 0
        end
    end

    if selfCastleHp >= selfCastleMaxHp * 0.5 then
        return skillBase * 2 * 0.5 * skillCount + skillBase * 2 * 0.3 * skillCount + skillBase * 2 * 0.2 * skillCount
    else
        return skillBase * 2 * 0.5 * skillCount
    end
end

-- 技能评价 - 可叠加 - 3071 查克警长 敌方最弱英雄战力*60%（如果对方只有一个目标囚禁＞贿赂）+敌方最弱英雄战力*补偿参数 ；补偿参数= 根据敌方基地血量百分比(100,60,30)赋值不同(-75%,-50%,0)
function root:getSkillEvaluate3071(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local enemyCastleHp = params.enemyCastleHp
    local enemyCastleMaxHp = params.enemyCastleMaxHp
    local skillCount = skillInfo.skillCount

    local percent = enemyCastleHp / enemyCastleMaxHp

    local ev = 0
    for i = 1, skillCount do
        if enemyHeroList[i] then
            local heroEv = self:getHeroEvaluate(core, enemyHeroList[i])
            ev = ev + heroEv * 0.6
            if percent <= 0.3 then
                ev = ev + heroEv * 0
            elseif percent <= 0.6 then
                ev = ev + heroEv * -0.5
            else
                ev = ev + heroEv * -0.75
            end
        end
    end

    return ev
end

-- 技能评价 - 不叠加 - 4071 忍者 根据敌方hero数不同的公式
-- hero=1→生成英雄的血量*75%*50%
-- hero≥2→min{敌方第二强英雄战力，生成英雄的血量*75%}*75%
-- 有盾
-- hero=1→收益值=0
-- hero≥2→min{敌方第二强英雄战力，生成英雄的血量*75%}*75%
function root:getSkillEvaluate4071(core, skillInfo, params)
    local enemyHasDun = params.enemyHasDun
    local newHeroAttack = params.newHeroAttack
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    if #enemyHeroList == 1 then
        ev = ev + (not enemyHasDun and newHeroAttack * 0.75 * 0.5 or 0)
    elseif #enemyHeroList >= 2 then
        ev = ev + math.min(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList - 1]), newHeroAttack * 0.75) * 0.75
    end

    return ev
end

-- 技能评价 - 可叠加 - 1081 特斯拉教授 （我方所有英雄战力总和-敌方英雄所有战力总和）≥2*普通色块基础战力→1.5*对应技能色块战力，else 1*对应技能色块战力
function root:getSkillEvaluate1081(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local baseAttack = params.baseAttack
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount

    if (selfHeroTotalEv - enemyHeroTotalEv) >= 2 * baseAttack then
        return 1.5 * skillBase * skillCount
    else
        return 1 * skillBase * skillCount
    end
end

-- 技能评价 - 可叠加 - 2081 真希 4*2*对应技能色块战力*50%*修正参数（敌方拥有一个低于2*对应技能色块战力的英雄则乘一个修正参数，参数为75%）
-- 有盾
-- 4*2*对应技能色块战力*50%*修正参数*偏正参数
-- 修正参数=敌方拥有一个低于2*对应技能色块战力的英雄则乘一个修正参数，参数为75%
-- 偏正参数=敌方英雄数/敌方英雄数+1
-- 叠加第二次时为:
-- 4*2*对应技能色块战力*50%*修正参数*偏正参数*0.5
-- 叠加第三次…第N次时为：
-- 0
function root:getSkillEvaluate2081(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount
    local enemyHasDun = params.enemyHasDun
    local enemyHeroList = params.enemyHeroList

    local count = 0
    for _, hero in ipairs(enemyHeroList) do
        if self:getHeroEvaluate(core, hero) < 2 * skillBase then
            count = count + 1
        end
    end

    if enemyHasDun then
        local ev = 4 * 2 * skillBase * 0.5 * 0.75 ^ count * (#enemyHeroList / (#enemyHeroList + 1))
        if skillCount > 1 then
            ev = ev + 4 * 2 * skillBase * 0.5 * 0.75 ^ count * (#enemyHeroList / (#enemyHeroList + 1)) * 0.5
        end
        return ev
    end

    return 4 * 2 * skillBase * 0.5 * 0.75 ^ count * skillCount
end

-- 技能评价 - 不叠加 - 3081 爱丽丝 2*普通色块基础战力
function root:getSkillEvaluate3081(core, skillInfo, params)
    local baseAttack = params.baseAttack

    return 2 * baseAttack
end

-- 技能评价 - 不叠加 - 4081 解脱者 max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*50%+0.5普通色块基础战力
function root:getSkillEvaluate4081(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local baseAttack = params.baseAttack

    return math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.5 + 0.5 * baseAttack
end

-- 技能评价 - 不叠加 - 1091 海德博士 根据我方基地血量百分比（100%，50%）增加不同倍对应技能色块的战力（5,2.5）
function root:getSkillEvaluate1091(core, skillInfo, params)
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local skillBase = skillInfo.skillBase

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.5 then
        return skillBase * 2.5
    else
        return skillBase * 5
    end
end

-- 技能评价 - 不叠加 - 2091 露西 max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*75%
function root:getSkillEvaluate2091(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv

    return math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.75
end

-- 技能评价 - 不叠加 - 3091 刺客 1.5*普通色块基础战力
function root:getSkillEvaluate3091(core, skillInfo, params)
    local baseAttack = params.baseAttack

    return 1.5 * baseAttack
end

-- 技能评价 - 不叠加 - 4091 魔术师 2*(双方基地总血量/2-我方基地当前血量)*50%
function root:getSkillEvaluate4091(core, skillInfo, params)
    local selfCastleHp = params.selfCastleHp
    local enemyCastleHp = params.enemyCastleHp

    return 2 * ((selfCastleHp + enemyCastleHp) / 2 - selfCastleHp) * 0.5
end

-- 技能评价 - 不叠加 - 1101 德布林格尔 (max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}+5*敌方平均技能色块战力)*50%*50%
function root:getSkillEvaluate1101(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    return (math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) + 5 * enemyAverageBaseAttack) * 0.5 * 0.5
end

-- 技能评价 - 不叠加 - 2101 鲜血女王 min{生成英雄的血量,敌方最强英雄战力}*75%（站位在左边两列时），else min{max{敌方所有英雄战力总和-我方所有英雄战力总和+生成英雄的血量,1*普通色块基础战力},生成英雄的血量}*75%
function root:getSkillEvaluate2101(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    local baseAttack = params.baseAttack
    local newHeroX = params.newHeroX
    local yDirection = params.yDirection
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyHeroList = params.enemyHeroList

    if (yDirection < 0 and newHeroX < 2) or (yDirection > 0 and newHeroX > 2) then
        local enemyHeroHighestEv = 0
        if enemyHeroList[#enemyHeroList] then
            enemyHeroHighestEv = self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList])
        end
        return math.min(newHeroAttack, enemyHeroHighestEv) * 0.75
    else
        return (math.min(math.max(enemyHeroTotalEv - selfHeroTotalEv + newHeroAttack, 1 * baseAttack), newHeroAttack)) *
            0.75
    end
end

-- 技能评价 - 可叠加 - 3101 汤米 2*对应技能色块战力*生成英雄的血量参数(≥7*色块数，1.5否则1)
function root:getSkillEvaluate3101(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount
    local linkCount = params.linkCount

    if linkCount >= 7 then
        return 2 * skillBase * 1.5 * skillCount
    else
        return 2 * skillBase * 1 * skillCount
    end
end

-- 技能评价 - 可叠加 - 4101 魔术先生 敌方最强英雄战力*50%+敌方最强英雄战力*补偿参数 ；补偿参数= 根据敌方基地血量百分比(100,60,30)赋值不同(-75%,-50%,0)
function root:getSkillEvaluate4101(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local enemyCastleHp = params.enemyCastleHp
    local enemyCastleMaxHp = params.enemyCastleMaxHp
    local skillCount = skillInfo.skillCount

    if not enemyHeroList[#enemyHeroList] then
        return 0
    end

    local percent = enemyCastleHp / enemyCastleMaxHp

    local ev = 0
    for i = 1, skillCount do
        if enemyHeroList[#enemyHeroList + 1 - i] then
            local heroEv = self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList + 1 - i])
            ev = ev + heroEv * 0.5
            if percent <= 0.3 then
                ev = ev + heroEv * 0
            elseif percent <= 0.6 then
                ev = ev + heroEv * -0.5
            else
                ev = ev + heroEv * -0.75
            end
        end
    end

    return ev
end

-- 技能评价 - 不叠加 - 1111 冰暴 max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*50%
function root:getSkillEvaluate1111(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    return math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.5
end

-- 技能评价 - 可叠加 - 2111 斯凯特 敌方受到的伤害总和*75%+敌方受到的伤害总和
-- 敌方受到的伤害总和=sum( min(hero_1_hp,1倍对应技能色块战力),…,min(hero_999_hp,1倍对应技能色块战力))
function root:getSkillEvaluate2111(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 1 * skillCount
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    for _, hero in ipairs(enemyHeroList) do
        ev = ev + math.min(damage, hero:getHp())
    end

    return ev * 0.75 + ev
end

-- 技能评价 - 不叠加 - 3111 火舞者 我方所有英雄战力总和*50%*75%
function root:getSkillEvaluate3111(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv

    return selfHeroTotalEv * 0.5 * 0.75
end

-- 技能评价 - 不叠加 - 4111 米斯特 0.5*普通色块基础战力
function root:getSkillEvaluate4111(core, skillInfo, params)
    local baseAttack = params.baseAttack

    return 0.5 * baseAttack
end

-- 技能评价 - 可叠加 - 1121 章鱼博士 平均敌方技能色块收益值（需判断）
-- avg(skill_1_benefit,…,skill_999_benefit)
function root:getSkillEvaluate1121(core, skillInfo, params)
    local enemyBeforeSkillBlockList = params.enemyBeforeSkillBlockList
    local skillCount = skillInfo.skillCount

    local blockList = {}
    for _, block in ipairs(enemyBeforeSkillBlockList) do
        if block.skillId ~= 1121 then
            table.insert(blockList, block)
        end
    end
    if #blockList <= 0 then
        return 0
    end

    skillCount = math.min(skillCount, #blockList)

    local skillInfoList = self:getSkillInfoList(core, blockList)
    local skillTotalEv = 0
    for _, v in ipairs(skillInfoList) do
        local skillEv = self:getSkillEvaluate(core, v, params)
        if skillEv then
            skillTotalEv = skillTotalEv + skillEv
        end
    end

    return skillTotalEv / #blockList * skillCount
end

-- 技能评价 - 不叠加 - 2121 吉姆 对方技能色块数*敌方卡组平均卡牌基础战力+敌方受到的伤害总和*0.75
-- 敌方受到的伤害总和=sum(min(hero_1_hp,2倍对应技能色块战力),…,min(hero_999_hp,2倍对应技能色块战力))
-- [此处hero为技能色块3*3区域的英雄]
function root:getSkillEvaluate2121(core, skillInfo, params)
    local enemySkillBlockList = params.enemySkillBlockList
    local newBlockXYMap = params.newBlockXYMap
    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    local enemyHeroList = params.enemyHeroList
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 2

    local ev = #enemySkillBlockList * enemyAverageBaseAttack

    local enemyHeroMap = {}
    for _, block in ipairs(enemySkillBlockList) do
        local blockPoint = newBlockXYMap[block.id]
        for _, hero in ipairs(enemyHeroList) do
            local heroPoint = newBlockXYMap[hero.bindBlock.id]
            if math.abs(blockPoint.x - heroPoint.x) <= 1 and math.abs(blockPoint.y - heroPoint.y) <= 1 then
                if not enemyHeroMap[hero] then
                    enemyHeroMap[hero] = 0
                end
                enemyHeroMap[hero] = enemyHeroMap[hero] + 1
            end
        end
    end

    for hero, count in pairs(enemyHeroMap) do
        ev = ev + math.min(damage * count, self:getHeroEvaluate(core, hero)) * 0.75
    end

    return ev
end

-- 技能评价 - 可叠加 - 3121 查基 2*对应技能色块战力*生成英雄的血量参数(≥7*色块数，1.5否则1)
function root:getSkillEvaluate3121(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount
    local linkCount = params.linkCount

    if linkCount >= 7 then
        return 2 * skillBase * 1.5 * skillCount
    else
        return 2 * skillBase * 1 * skillCount
    end
end

-- 技能评价 - 可叠加 - 4121 拉德马克斯 3*对应技能色块战力*75%
function root:getSkillEvaluate4121(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    return 3 * skillBase * 0.75 * skillCount
end

-- 技能评价 - 可叠加 - 1131 罗伊德 3*对应技能色块战力*50%+根据我方基地血量百分比(30%、10%)增加不同倍对应技能色块的战力(0.5、1)
function root:getSkillEvaluate1131(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local percent = selfCastleHp / selfCastleMaxHp

    local ev = 3 * skillBase * 0.5 * skillCount
    if percent <= 0.1 then
        ev = ev + skillBase * 1 * skillCount
    elseif percent <= 0.3 then
        ev = ev + skillBase * 0.5 * skillCount
    end

    return ev
end

-- 技能评价 - 不叠加 - 2131 足球迷 敌方所有英雄数=0，则为0；else : (敌方最强英雄战力-我方最弱英雄战力)*175%
function root:getSkillEvaluate2131(core, skillInfo, params)
    local enemyHeroCount = params.enemyHeroCount
    if enemyHeroCount <= 0 then
        return 0
    end

    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList

    local enemyHeroHighestEv =
        enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0
    local selfHeroLowestEv = selfHeroList[1] and self:getHeroEvaluate(core, selfHeroList[1]) or 0

    return (enemyHeroHighestEv - selfHeroLowestEv) * 1.75
end

-- 技能评价 - 不叠加 - 3131 警察 站位参数（1排赋值1.5、2排赋值1,、3排赋值0.5）*普通色块基础战力
function root:getSkillEvaluate3131(core, skillInfo, params)
    local selfHeroList = params.selfHeroList
    local newBlockXYMap = params.newBlockXYMap
    local baseAttack = params.baseAttack
    local areaH = core.areaH

    local ev = 0

    local selfHeroParam = {0, 0, 0.5, 1, 1.5, 1.5, 1, 0.5, 0, 0}
    -- 半场行数超过5的，给补充1.5在中间
    for i = 1, areaH - 5 do
        table.insert(selfHeroParam, 6, 1.5)
        table.insert(selfHeroParam, 6, 1.5)
    end
    for _, hero in ipairs(selfHeroList) do
        ev = ev + selfHeroParam[newBlockXYMap[hero.bindBlock.id].y + 1] * baseAttack
    end

    return ev
end

-- 技能评价 - 不叠加 - 4131 杰西 敌方技能色块数*普通色块基础战力
function root:getSkillEvaluate4131(core, skillInfo, params)
    local enemySkillBlockList = params.enemySkillBlockList
    local baseAttack = params.baseAttack

    return #enemySkillBlockList * baseAttack
end

--#region ----------------------------------------- 新的英雄和技能:功能代码块
-- 技能评价 - 不叠加 - 2211 米斯特 普通色块基础战力(参考: 技能评价 - 不叠加 - 4111)
-- 公式: 1*技能战力*100%
function root:getSkillEvaluate2211(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    return skillBase
end

-- 技能评价 - 不叠加 - 1211 扎克 为主角恢复1格英雄基础战力的血量
-- 公式: 1*技能战力*50%
function root:getSkillEvaluate1211(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    return math.floor(skillBase * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 4211 扎克 对手主角失去1格战力血量
-- 有盾
-- 收益值=0
-- 公式: 1*技能战力*50%
function root:getSkillEvaluate4211(core, skillInfo, params)
    --[[
    local enemyHasDun = params.enemyHasDun
    if enemyHasDun then
        return 0
    end
    local baseAttack = params.baseAttack
    return baseAttack
    ]]
    local skillBase = skillInfo.skillBase
    return math.floor(skillBase * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 3211 无人机队长 我英雄基本战力50%
-- 公式: 生成英雄战力*25%*65%
function root:getSkillEvaluate3211(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.25 * 0.65 + 0.5)
end

-- 技能评价 - 不叠加 - 2221  在下一次攻击时提升50%攻击力(参考 4021)
-- 公式: 生成英雄战力*50%*100%
function root:getSkillEvaluate2221(core, skillInfo, params)
    --[[
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local enemyHasDun = params.enemyHasDun

    if not enemyHeroList[#enemyHeroList] then
        return not enemyHasDun and newHeroAttack * 0.5 or 0
    else
        return math.min(
            math.max(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) - newHeroAttack, 0),
            newHeroAttack
        ) * 0.75
    end
    ]]
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 1221  主角恢复2格战力血量(参考 1011 机器人 (15%*我方基地最大血量*50%)+根据我方基地血量百分比(30%、10%)增加不同个普通色块数的战力(0.5、1))
-- 公式: 2*技能战力*50%
function root:getSkillEvaluate1221(core, skillInfo, params)
    --[[
    local skillCount = skillInfo.skillCount

    local baseAttack = params.baseAttack
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp

    local ev = 0.15 * selfCastleMaxHp * 0.5 * skillCount

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.1 then
        ev = ev + baseAttack * 1 * skillCount
    elseif percent <= 0.3 then
        ev = ev + baseAttack * 0.5 * skillCount
    end

    return ev
    ]]
    local skillBase = skillInfo.skillBase
    return math.floor(2 * skillBase * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 4221 用迷雾屏蔽己方场地，让敌方不可见 (参考 4111 米斯特 0.5*普通色块基础战力)
-- 公式: 0.5*技能战力
function root:getSkillEvaluate4221(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    return math.floor(skillBase * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 3221 装备护甲，使受到的伤害降低50%。持续到死亡 (参考 3051 SWAT 生成英雄的血量*65%)
-- 公式: 生成英雄战力*50%*65%
function root:getSkillEvaluate3221(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.5 * 0.65 + 0.5)
end

-- 技能评价 - 可叠加 - 2231 对手方角失去2格战力血量 (4011 扎克 敌方基地最大血量*15%*50%)
-- 公式: 2*技能战力*50%
function root:getSkillEvaluate2231(core, skillInfo, params)
    --[[
    local skillCount = skillInfo.skillCount
    local enemyHasDun = params.enemyHasDun
    local enemyCastleMaxHp = params.enemyCastleMaxHp

    if enemyHasDun then
        return 0
    end

    return enemyCastleMaxHp * 0.15 * 0.5 * skillCount
    ]]
    local skillBase = skillInfo.skillBase
    return math.floor(2 * skillBase * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 1231 恢复我方国王1个色块战力的血量，提升我方怪兽1个技能色块的基础战力 (2051 查理 (我方基地最大血量*15%*50%+我方所有英雄数*1*对应技能色块战力))
-- 公式: 1*技能色块战力*50%+我方英雄数*1倍技能色块战力*100%
function root:getSkillEvaluate1231(core, skillInfo, params)
    --[[
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfHeroCount = params.selfHeroCount
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount

    return (selfCastleMaxHp * 0.15 * 0.5 + selfHeroCount * 1 * skillBase) * skillCount
    ]]
    local selfHeroCount = params.selfHeroCount
    local skillBase = skillInfo.skillBase
    return math.floor(skillBase * (selfHeroCount + 0.5) + 0.5)
end

-- 技能评价 - 可叠加 - 4231 感染三个敌方的色块，每个被感染的芯片对周围单位造成伤害，直到色块被消掉 (1061 辐射工兵 1*普通色块基础战力+max{(敌方所有英雄数-2),0}*2*对应技能色块战力*75%)
--[[ 公式:
if（我方所有英雄战力总和-敌方英雄所有战力总和）≥2*普通色块基础战力：
1.5*技能战力
else 1*技能战力
]]
function root:getSkillEvaluate4231(core, skillInfo, params)
    --[[
    local baseAttack = params.baseAttack
    local enemyHeroCount = params.enemyHeroCount
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount

    return (baseAttack + math.max(enemyHeroCount - 2, 0) * 2 * skillBase * 0.75) * skillCount
    ]]
    --[[
        if（我方所有英雄战力总和-敌方英雄所有战力总和）≥2*普通色块基础战力：
        1.5*对应技能色块战力
        else 1*对应技能色块战力
    ]]
    local skillBase = skillInfo.skillBase
    local baseAttack = params.baseAttack
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    if (selfHeroTotalEv - enemyHeroTotalEv) >= (2 * baseAttack) then
        return math.floor(skillBase * 1.5 + 0.5)
    else
        return skillBase
    end
end

-- 技能评价 - 可叠加 - 3231 囚禁一个敌方英雄单位几回合 (3071 查克警长 敌方最弱英雄战力*60%（如果对方只有一个目标囚禁＞贿赂）+敌方最弱英雄战力*补偿参数 ；补偿参数= 根据敌方基地血量百分比(100,60,30)赋值不同(-75%,-50%,0))
--[[
-- 公式:
    敌方最弱英雄战力*60%（如果对方只有一个目标囚禁＞贿赂）+敌方最弱英雄战力*补偿参数 ；
    补偿参数= 根据敌方基地血量百分比(100,60,30)赋值不同(-75%,-50%,0)
]]
function root:getSkillEvaluate3231(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local enemyCastleHp = params.enemyCastleHp
    local enemyCastleMaxHp = params.enemyCastleMaxHp
    local skillCount = skillInfo.skillCount

    local percent = enemyCastleHp / enemyCastleMaxHp

    local ev = 0
    for i = 1, skillCount do
        if enemyHeroList[i] then
            local heroEv = self:getHeroEvaluate(core, enemyHeroList[i])
            ev = ev + heroEv * 0.6
            if percent <= 0.3 then
                ev = ev + heroEv * 0
            elseif percent <= 0.6 then
                ev = ev + heroEv * -0.5
            else
                ev = ev + heroEv * -0.75
            end
        end
    end

    return ev
end

-- 技能评价 - 不叠加 - 2241  (参考:  纵火犯)
-- 公式: if 敌方所有英雄战力总和 - 我方所有英雄战力总和 >0: (敌方所有英雄数*对应技能色块战力*1*75% + 普通色块基础站力*1)else  :敌方所有英雄数*对应技能色块战力*1*75%
function root:getSkillEvaluate2241(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local enemyHeroCount = params.enemyHeroCount
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local baseAttack = params.baseAttack

    if enemyHeroTotalEv - selfHeroTotalEv > 0 then
        return enemyHeroCount * skillBase * 1 * 0.75 + baseAttack * 1
    else
        return enemyHeroCount * skillBase * 1 * 0.75
    end
end

-- 技能评价 - 不叠加 - 1241 鸢萝 (参考: 技能评价 - 不叠加 - 2021 朋克头 敌方所有英雄战力总和*50%*75%)
-- 有盾
-- 若对方只有一个英雄则为0
-- 多个英雄：
-- 敌方所有英雄战力总和*50%*50%
function root:getSkillEvaluate1241(core, skillInfo, params)
    --[[
    local enemyHasDun = params.enemyHasDun
    local enemyHeroCount = params.enemyHeroCount
    local enemyHeroTotalEv = params.enemyHeroTotalEv

    local evaluate = math.floor((enemyHeroTotalEv or 0) * 0.5 + 0.5)
    if enemyHasDun then
        return enemyHeroCount > 1 and evaluate or 0
    end

    return evaluate
    ]]
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    return math.floor(enemyHeroTotalEv * 0.5 * 0.75 + 0.5)
end

-- 技能评价 - 可叠加 - 4241  (参考: 技能评价 - 可叠加 - 2011 洛克犬 3*对应技能色块战力*75%)
-- 公式: 3*技能色块战力*100%
function root:getSkillEvaluate4241(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    return 3 * skillBase * 1
end

-- 技能评价 - 可叠加 - 3241 (参考: 3031 间谍 同列上敌方英雄战力总和+英雄落点变化收益（生成英雄落点变化收益+我方英雄落点变化收益])
-- 生成英雄落点变化收益=用完技能后的落地收益-生成英雄后用技能前的落地收益
-- 我方英雄落点变化收益= 满足数量1*普通色块基础战力+满足数量2*0.5*普通色块基础战力
-- 满足数量1 = 用完技能后落点Y轴变化≥3的我方英雄数 （与生成英雄后用技能前的Y轴对比）
-- 满足数量2 = 用完技能后落点Y轴变化 = 2 的我方英雄数（与生成英雄后用技能前的Y轴对比）
-- 公式:
function root:getSkillEvaluate3241(core, skillInfo, params)
    local xMap = skillInfo.data3241
    local totalHeroEvaluate = 0
    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList
    local baseAttack = params.baseAttack
    local yDirection = params.yDirection
    local newHeroX = params.newHeroX
    local newHeroY = params.newHeroY
    local newBlockXYMap = params.newBlockXYMap


    local xHeros = {}
    local function changeToXHeros(heroList)
        for _, hero in ipairs(heroList) do
            if xMap[hero.bindBlock.x] then
                if not xHeros[hero.bindBlock.x] then
                    xHeros[hero.bindBlock.x] = {}
                end
                table.insert(xHeros[hero.bindBlock.x], {hero = hero, point = newBlockXYMap[hero.bindBlock.id]})
            end
        end
    end
    changeToXHeros(enemyHeroList)
    changeToXHeros(selfHeroList)

    local newHeroLastY = -1
    local selfYChange3Count = 0
    local selfYChange2Count = 0
    local function calc(v, yDirection)
        local sortY, getY
        if yDirection < 0 then
            sortY = function(a, b)
                return a.point.y < b.point.y
            end
            getY = function(i)
                return i - 1
            end
        elseif yDirection > 0 then
            sortY = function(a, b)
                return a.point.y > b.point.y
            end
            getY = function(i)
                return 10 - i
            end
        end
        table.sort(v, sortY)
        for i = 1, #v do
            local y = getY(i)
            if v[i].point.x == newHeroX and v[i].point.y == newHeroY then
                newHeroLastY = y
            else
                local beforeIsSelf = self:isSelfBlock(yDirection, v[i].point.y)
                local afterIsSelf = self:isSelfBlock(yDirection, y)
                if not beforeIsSelf and afterIsSelf then
                    totalHeroEvaluate = totalHeroEvaluate + self:getHeroEvaluate(core, v[i].hero)
                elseif beforeIsSelf and afterIsSelf then
                    local change = math.abs(y - v[i].point.y)
                    if change >= 3 then
                        selfYChange3Count = selfYChange3Count + 1
                    elseif change == 2 then
                        selfYChange2Count = selfYChange2Count + 1
                    end
                end
            end
        end
    end
    for _, v in pairs(xHeros) do
        calc(v, yDirection)
    end

    local enemyHeroEv = totalHeroEvaluate
    local newHeroEv = 0
    if newHeroLastY > 0 then
        newHeroEv = self:getYEvaluate(core, newHeroLastY, baseAttack) - self:getYEvaluate(core, newHeroY, baseAttack)
    end
    local selfHeroEv = selfYChange3Count * 1 * baseAttack + selfYChange2Count * 0.5 * baseAttack
    totalHeroEvaluate = enemyHeroEv + newHeroEv + selfHeroEv

    return totalHeroEvaluate
end

-- 技能评价 - 不叠加 - 2251  (参考: 技能评价 - 不叠加 - 1051 布雷泽)
-- 公式: 生成英雄的血量*50%*75%
function root:getSkillEvaluate2251(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack

    return math.floor(newHeroAttack * 0.5 * 0.75 + 0.5)
end

-- 技能评价 - 不叠加 - 1251  (参考: -- 技能评价 - 不叠加 - 2091 露西)
-- 公式:max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*75%, 这里如果要精确的拉取血量，需要模拟战斗才行
function root:getSkillEvaluate1251(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv

    return math.floor(math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.75 + 0.5)
end

-- 技能评价 - 不叠加 - 4251  (参考: -- 技能评价 - 不叠加 - 4081 解脱者)
-- 公式: max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*50%+0.5普通色块基础战力
function root:getSkillEvaluate4251(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local baseAttack = params.baseAttack

    return math.floor(math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.5 + 0.5 * baseAttack + 0.5)
end

-- 技能评价 - 3251  (参考: -- 技能评价 - 可叠加 - 3011 特警)
-- 公式: max{(5*敌方平均技能色块战力+max{(敌方所有英雄战力总和-我方所有英雄战力总和),0} - 我方所有英雄战力总和), 0}*50%+根据我方基地血量百分比(30%、10%)增加不同个普通色块数的战力(1.5、3)
function root:getSkillEvaluate3251(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local baseAttack = params.baseAttack

    local ev =
        math.max(5 * enemyAverageBaseAttack + math.max(enemyHeroTotalEv - selfHeroTotalEv, 0) - selfHeroTotalEv, 0) *
        0.5

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.1 then
        ev = ev + baseAttack * 3
    elseif percent <= 0.3 then
        ev = ev + baseAttack * 1.5
    end

    return math.floor(ev * skillCount + 0.5)
end

-- 技能评价 - 可叠加 - 1261  (参考: 技能评价 - 可叠加 - 2071 温蒂)
-- 公式: 3*技能战力+存活单位收益+1*技能战力
function root:getSkillEvaluate1261(core, skillInfo, params)
    --[[
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    local selfCastleHp = params.selfCastleHp
    local selfCastleMaxHp = params.selfCastleMaxHp
    local enemyHasDun = params.enemyHasDun

    if enemyHasDun then
        if selfCastleHp >= selfCastleMaxHp * 0.5 then
            return skillBase * 2 * 0.3 * skillCount + skillBase * 2 * 0.2 * skillCount
        else
            return 0
        end
    end

    if selfCastleHp >= selfCastleMaxHp * 0.5 then
        return skillBase * 2 * 0.5 * skillCount + skillBase * 2 * 0.3 * skillCount + skillBase * 2 * 0.2 * skillCount
    else
        return skillBase * 2 * 0.5 * skillCount
    end
    ]]
    local skillBase = skillInfo.skillBase
    return skillBase * 3 + skillBase * 1 + 0
end

-- 技能评价 - 不叠加 - 2261  (参考: -- 技能评价 - 不叠加 - 1021 修理师)
--[[
if 我方基地当前血量 ≥ 我方基地最大血量*50% : 2*对应技能色块战力*50%+2*对应技能色块战力*30% else:2*对应技能色块战力*50%
有盾（100%）
if 我方基地当前血量 ≥ 我方基地最大血量*50% :
2*对应技能色块战力*30%
else:0
]]
function root:getSkillEvaluate2261(core, skillInfo, params)
    --[[
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local percent = selfCastleHp / selfCastleMaxHp
    local skillBase = skillInfo.skillBase
    if percent <= 0.5 then
        return skillBase
    end

    return skillBase * 2
    ]]
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase

    local selfCastleHp = params.selfCastleHp
    local selfCastleMaxHp = params.selfCastleMaxHp
    local enemyHasDun = params.enemyHasDun

    if enemyHasDun then
        if selfCastleHp >= selfCastleMaxHp * 0.5 then
            return math.floor(skillBase * 2 * 0.3 + 0.5)
        else
            return 0
        end
    end

    if selfCastleHp >= selfCastleMaxHp * 0.5 then
        return math.floor(skillBase * 2 * 0.5 + skillBase * 2 * 0.3 + 0.5)
    else
        return math.floor(skillBase * 2 * 0.5 + 0.5)
    end
    return 0
end

-- 技能评价 - 不叠加 - 3261  (参考: 技能评价 - 不叠加 - 4061 杀手)
-- 公式: 2*对应技能色块战力*生成英雄的血量参数(≥7*色块数，1.5否则1)+存活单位收益
function root:getSkillEvaluate3261(core, skillInfo, params)
    --[[
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local linkCount = params.linkCount
    local baseAttack = params.baseAttack

    local ev = 0
    if enemyHeroList[#enemyHeroList] then
        ev = ev + math.max(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) - newHeroAttack, 0) * 0.75
    end
    if linkCount >= 7 then
        ev = ev + 3 * baseAttack
    end

    return ev
    ]]
    local skillBase = skillInfo.skillBase
    local linkCount = params.linkCount
    local ev = skillBase * 2

    if linkCount >= 7 then
        ev = ev * 1.5
    end

    return math.floor(ev + 0.5)
end

-- 技能评价 - 不叠加 - 4261  (参考: 技能评价 - 可叠加 - 3121 查基)
-- 公式: max{(敌方最强英雄战力-生成英雄的血量),0}*75%+生成英雄的血量参数(≥7*色块数，+3*普通色块基础战力)
function root:getSkillEvaluate4261(core, skillInfo, params)
    --[[
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount
    local linkCount = params.linkCount

    if linkCount >= 7 then
        return 2 * skillBase * 1.5 * skillCount
    else
        return 2 * skillBase * 1 * skillCount
    end
    ]]
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local linkCount = params.linkCount
    local baseAttack = params.baseAttack

    local ev = 0
    if enemyHeroList[#enemyHeroList] then
        ev = ev + math.max(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) - newHeroAttack, 0) * 0.75
    end
    if linkCount >= 7 then
        ev = ev + 3 * baseAttack
    end

    return ev
end

-- 技能评价 - 可叠加 - 2351 (旧的技能ID:2111) 金羽/斯凯特
--[[公式:
    敌方受到的伤害总和*75%+敌方受到的伤害总和
    敌方受到的伤害总和=sum( min(hero_1_hp,1倍对应技能色块战力),…,min(hero_999_hp,1倍对应技能色块战力))
]]
function root:getSkillEvaluate2351(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 1 * skillCount
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    for _, hero in ipairs(enemyHeroList) do
        ev = ev + math.min(damage, hero:getHp())
    end

    return math.floor(ev * 0.75 + ev + 0.5)
end

-- 技能评价 - 不叠加 - 1351(旧的技能ID:1091) 海德博士/盈缺
-- 公式: 根据我方基地血量百分比（100%，50%）增加不同倍对应技能色块的战力（5,2.5）
function root:getSkillEvaluate1351(core, skillInfo, params)
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local skillBase = skillInfo.skillBase

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.5 then
        return skillBase * 2.5
    else
        return skillBase * 5
    end
end

-- 技能评价 - 可叠加 - 4351(旧的技能ID:3101) 汤米/无情
-- 公式: 2*对应技能色块战力*生成英雄的血量参数(≥7*色块数，1.5否则1)
function root:getSkillEvaluate4351(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local skillCount = skillInfo.skillCount
    local linkCount = params.linkCount

    if linkCount >= 7 then
        return 2 * skillBase * 1.5 * skillCount
    else
        return 2 * skillBase * 1 * skillCount
    end
end

-- 技能评价 - 可叠加 - 3351 (旧的技能ID:3041) 极限特工/小青
-- 公式: （敌方英雄战力总和-我方英雄战力总和）+（我敌双方复活buff差）*复活技能收益评分
function root:getSkillEvaluate3351(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv

    return (newHeroAttack + enemyHeroTotalEv) * 0.5 - selfHeroTotalEv
end

-- 技能评价 - 可叠加 - 2361 (旧的技能:4031) 乔乔/化学老师
-- 公式: 对手最弱英雄战力*75%+存活单位收益
function root:getSkillEvaluate2361(core, skillInfo, params)
    local enemyHeroList = params.enemyHeroList
    local skillCount = skillInfo.skillCount

    local ev = 0
    for i = 1, skillCount do
        if enemyHeroList[i] then
            ev = ev + self:getHeroEvaluate(core, enemyHeroList[i]) * 0.75
        end
    end

    return ev
end

-- 技能评价 - 可叠加 - 1361 (旧的技能ID:1041) 十里/医师 根据敌方英雄站位算出收益值(60%:30%:10%:0:0)
-- eg:敌方英雄战力分布：第一排:第二排:第三排:第四排:第五排=100:50:30:50:30(第一排为接近中线的那排)
-- 收益值为=100*60%+50*30%+30*10%+50*0%+30*0%=78
--
-- 叠加比例上升(30%:20%:10%:5%:5%) max为100%
-- 连接技能色块数=x；
-- 基础比例为(a,b,c,d,e)
-- 叠加比例为(f,g,h,i,j)
-- 最终比例{min(a+(x-1)f,100),min(b+(x-1)g,100),…,min(e+(x-1)j,100)}
-- 公式:
function root:getSkillEvaluate1361(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local newBlockXYMap = params.newBlockXYMap
    local enemyHeroEv = {}
    local areaH = core.areaH
    for i = 1, areaH * 2 do
        table.insert(enemyHeroEv, 0)
    end
    local enemyHeroList = params.enemyHeroList
    for _, hero in ipairs(enemyHeroList) do
        enemyHeroEv[newBlockXYMap[hero.bindBlock.id].y + 1] =
            enemyHeroEv[newBlockXYMap[hero.bindBlock.id].y + 1] + hero:getHp()
    end
    local enemyHeroParam = {0, 0, 0.1, 0.3, 0.6, 0.6, 0.3, 0.1, 0, 0}
    -- 半场行数超过5的，给补充0.6在中间
    for i = 1, areaH - 5 do
        table.insert(enemyHeroParam, 6, 0.6)
        table.insert(enemyHeroParam, 6, 0.6)
    end
    local addHeroParam = {0.05, 0.05, 0.1, 0.2, 0.3, 0.3, 0.2, 0.1, 0.05, 0.05}
    -- 半场行数超过5的，给补充0.3在中间
    for i = 1, areaH - 5 do
        table.insert(enemyHeroParam, 6, 0.3)
        table.insert(enemyHeroParam, 6, 0.3)
    end
    for i = 1, #enemyHeroParam do
        enemyHeroParam[i] = math.min(enemyHeroParam[i] + addHeroParam[i] * (skillCount - 1), 1)
    end
    local totalHeroEvaluate = 0
    for i = 1, #enemyHeroParam do
        totalHeroEvaluate = totalHeroEvaluate + enemyHeroEv[i] * enemyHeroParam[i]
    end
    return totalHeroEvaluate
end

-- 技能评价 - 不叠加 - 4361 (旧的技能ID:4071) 千两/忍者 根据敌方hero数不同的公式
-- hero=1→生成英雄的血量*75%*50%
-- hero≥2→min{敌方第二强英雄战力，生成英雄的血量*75%}*75%
-- 有盾
-- hero=1→收益值=0
-- hero≥2→min{敌方第二强英雄战力，生成英雄的血量*75%}*75%
-- 公式:
function root:getSkillEvaluate4361(core, skillInfo, params)
    local enemyHasDun = params.enemyHasDun
    local newHeroAttack = params.newHeroAttack
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    if #enemyHeroList == 1 then
        ev = ev + (not enemyHasDun and newHeroAttack * 0.75 * 0.5 or 0)
    elseif #enemyHeroList >= 2 then
        ev = ev + math.min(self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList - 1]), newHeroAttack * 0.75) * 0.75
    end

    return math.floor(ev)
end

-- 技能评价 - 可叠加 - 3361 (旧的技能ID:3021) 一叶/罗杰
-- 公式: 我方平均技能色块战力*3*65%+扰乱棋盘附加评分
function root:getSkillEvaluate3361(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local averageBaseAttack = params.averageBaseAttack

    return math.floor(averageBaseAttack * 3 * 0.65 + 0)
end

-- 技能评价 - 不叠加 - 2281  (参考: ) 团团
--[[
    对方技能色块数*敌方卡组平均卡牌基础战力+敌方受到的伤害总和*0.75
    敌方受到的伤害总和=sum( min(hero_1_hp,2倍对应技能色块战力),…,min(hero_999_hp,2倍对应技能色块战力))
    [此处hero为技能色块3*3区域的英雄]
]]
-- 公式:
function root:getSkillEvaluate2281(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 1 * skillCount
    local enemyHeroList = params.enemyHeroList

    local ev = 0
    for _, hero in ipairs(enemyHeroList) do
        ev = ev + math.min(damage, hero:getHp())
    end

    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    return ev + enemyAverageBaseAttack * skillCount
end

-- 技能评价 - 不叠加 - 1281  (参考: ) 烧麦
-- 公式:2*对应技能色块战力*50%+根据我方基地血量百分比(>30%、<30%)增加不同倍对应技能色块的战力(0.5、1)
function root:getSkillEvaluate1281(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp

    local ev = skillBase * 3 * 0.5

    local percent = selfCastleHp / selfCastleMaxHp
    if percent <= 0.3 then
        ev = ev + skillBase
    else
        ev = ev + skillBase * 0.5
    end

    return math.floor(ev + 0.5)
end

-- 技能评价 - 不叠加 - 4281  (参考: ) 猴宝
-- 公式: 敌方技能数*普通色块基础战力
function root:getSkillEvaluate4281(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local baseAttack = params.baseAttack
    return baseAttack * skillCount
end

-- 技能评价 - 不叠加 - 3281  (参考: ) 阿呆
-- 公式: 3*普通色块基础战力
function root:getSkillEvaluate3281(core, skillInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 3
end

-- 技能评价 - 不叠加 - 2291  (参考: ) 夜阑
--[[
    min{生成英雄的血量,敌方最强英雄战力}*75%（站位在左边两列时），
    else min{max{敌方所有英雄战力总和-我方所有英雄战力总和+生成英雄的血量,1*普通色块基础战力},生成英雄的血量}*75%
    #这里如果要精确的吸血血量，需要模拟战斗才行
]]
-- 公式:
function root:getSkillEvaluate2291(core, skillInfo, params)
    local newHeroX = params.newHeroX or 1
    local baseAttack = params.baseAttack
    local newHeroAttack = params.newHeroAttack

    local evaluate = 0
    if newHeroX < 3 then
        local enemyHeroList = params.enemyHeroList
        if enemyHeroList[#enemyHeroList] then
            evaluate = min(newHeroAttack, self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList])) * 0.75
        end
    else
        local enemyHeroTotalEv = params.enemyHeroTotalEv
        local selfHeroTotalEv = params.selfHeroTotalEv
        local v1 = enemyHeroTotalEv - selfHeroTotalEv + newHeroAttack
        local v2 = max(v1, baseAttack)
        evaluate = max(v2, newHeroAttack) * 0.75
    end
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 1291  (参考: ) 桃桃
-- 公式:我方棋盘英雄总战力*25%*100%
function root:getSkillEvaluate1291(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv
    return math.floor(selfHeroTotalEv * 0.25 * 1 + 0.5)
end

-- 技能评价 - 不叠加 - 4291  (参考: ) 倒倒
-- 公式: 站位参数和（1排赋值1.5、2排赋值1）*普通色块基础战力
function root:getSkillEvaluate4291(core, skillInfo, params)
    local selfHeroList = params.selfHeroList
    local newBlockXYMap = params.newBlockXYMap
    local baseAttack = params.baseAttack
    local selfHeroCount = params.selfHeroCount
    local areaH = core.areaH

    local ev = 0

    local selfHeroParam = {0, 0, 0, 1, 1.5, 1.5, 1, 0, 0, 0}
    -- 半场行数超过5的，给补充1.5在中间
    for i = 1, areaH - 5 do
        table.insert(selfHeroParam, 6, 1.5)
        table.insert(selfHeroParam, 6, 1.5)
    end
    for _, hero in ipairs(selfHeroList) do
        ev = ev + selfHeroParam[newBlockXYMap[hero.bindBlock.id].y + 1] * baseAttack * selfHeroCount
    end

    return math.floor(ev + 0.5)
end

-- 技能评价 - 不叠加 - 3291  (参考: ) 咕噜
--[[
    判断是否有技能色块，
    平均敌方技能色块收益值（需判断）*2
    avg(skill_1_benefit,…,skill_999_benefit)
]]
-- 公式:
function root:getSkillEvaluate3291(core, skillInfo, params)
    local enemyBeforeSkillBlockList = params.enemyBeforeSkillBlockList
    local skillCount = skillInfo.skillCount

    local blockList = {}
    for _, block in ipairs(enemyBeforeSkillBlockList) do
        if block.skillId ~= 3291 then
            table.insert(blockList, block)
        end
    end
    if #blockList <= 0 then
        return 0
    end

    skillCount = math.min(skillCount, #blockList)

    local skillInfoList = self:getSkillInfoList(core, blockList)
    local skillTotalEv = 0
    for _, v in ipairs(skillInfoList) do
        local skillEv = self:getSkillEvaluate(core, v, params)
        if skillEv then
            skillTotalEv = skillTotalEv + skillEv
        end
    end
    local evaluate = skillTotalEv / #blockList * skillCount

    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 2311 (参考: ) 画意:
-- 公式:（我方所有英雄战力总和-敌方所有英雄战力总和）≥2*普通色块基础战力→2*普通色块基础战力+1.5*技能战力，else0.5*普通色块基础战力+1.5*技能战力
function root:getSkillEvaluate2311(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local baseAttack = params.baseAttack
    local skillBase = skillInfo.skillBase

    local evaluate = 0
    if (selfHeroTotalEv - enemyHeroTotalEv) >= 2 * baseAttack then
        evaluate = 2 * baseAttack + 1.5 * skillBase
    else
        evaluate = 0.5 * baseAttack + 1.5 * skillBase
    end

    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 1311 (参考: ) 糯米:
-- 公式: 连线生成英雄战力*65%
function root:getSkillEvaluate1311(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.65 + 0.5)
end

-- 技能评价 - 不叠加 - 4311 (参考: ) 纤纤:
-- 公式: 4*对应技能色块战力*50%+扰乱棋盘分布附加评分
function root:getSkillEvaluate4311(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    local skillBase = skillInfo.skillBase
    return skillBase * 4 + 0
end

-- 技能评价 - 不叠加 - 3311 (参考: ) 孤梦:
-- 公式: max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}*50%
function root:getSkillEvaluate3311(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local evaluate = max(enemyHeroTotalEv - selfHeroTotalEv, 0) * 0.5
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 2321 (参考: ) 不酸:
-- 公式: 低战英雄数量*1*技能伤害战力(低战英雄定义：低于25%连线生成英雄战力)
function root:getSkillEvaluate2321(core, skillInfo, params)
    local skillBase = skillInfo.skillBase
    local enemyHeroList = params.enemyHeroList
    local newHeroAttack = params.newHeroAttack
    local lowHeroCount = self:getLowHeroCount(newHeroAttack, enemyHeroList)

    local evaluate = skillBase * lowHeroCount
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 1321 (参考: ) 绿蛛:
-- 公式: (普通色块基础战力*3*50%-我方最弱英雄战力*100%)
-- 有盾 ->我方最弱英雄战力*75%
function root:getSkillEvaluate1321(core, skillInfo, params)
    -- 最弱的自己人
    local selfHeroList = params.selfHeroList
    local selfHeroLowestEv = 0
    if #selfHeroList > 0 and selfHeroList[1] then
        selfHeroLowestEv = self:getHeroEvaluate(core, selfHeroList[1]) or 0
    end

    local enemyHasDun = params.enemyHasDun
    local valueEv = 0
    -- 敌方是否有盾
    if enemyHasDun then
        valueEv = math.floor(selfHeroLowestEv * 0.75 + 0.5)
    else
        local baseAttack = params.baseAttack
        valueEv = baseAttack * 3 * 0.5 - selfHeroLowestEv * 1
    end

    return math.floor(valueEv + 0.5)
end

-- 技能评价 - 不叠加 - 4321 (参考: ) 云中客:使双方基地生命值相等
-- 公式: 2*(双方基地总血量/2-我方基地当前血量)*50%
function root:getSkillEvaluate4321(core, skillInfo, params)
    local enemyCastleHp = params.enemyCastleHp
    local selfCastleHp = params.selfCastleHp

    local evaluate = 2 * math.abs((enemyCastleHp + selfCastleHp) / 2 - selfCastleHp) * 0.5
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 3321 (参考: ) 酿酿:
-- 生成英雄战力*50%*75%
function root:getSkillEvaluate3321(core, skillInfo, params)
    local newHeroAttack = params.newHeroAttack
    local skillBase = skillInfo.skillBase

    local evaluate = newHeroAttack * 0.5 * 0.75
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 2331 (参考: ) 阿筝   :技能发动时，交换敌方最强单位与己方最弱单位的位置
-- 公式: 敌方英雄数=0，则为0；else : (敌方最强英雄战力-我方最弱英雄战力)*125%
function root:getSkillEvaluate2331(core, skillInfo, params)
    local enemyHeroCount = params.enemyHeroCount
    if not enemyHeroCount or enemyHeroCount <= 0 then
        return 0
    end

    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList

    local enemyHeroHighestEv =
        enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0
    local selfHeroLowestEv = selfHeroList[1] and self:getHeroEvaluate(core, selfHeroList[1]) or 0

    local evaluate = (enemyHeroHighestEv - selfHeroLowestEv) * 1.25
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 1331 (参考: ) 影生   :对手主角失去2格技能战力血量，并且在接下来的1回合内无法使用技能。
-- 公式: 2*技能色块战力*50%+if(对方棋盘技能数量>0,2*普通色块基础战力,else 0)
function root:getSkillEvaluate1331(core, skillInfo, params)
    local enemyBeforeSkillBlockList = params.enemyBeforeSkillBlockList or {} -- 敌方技能色块列表：消除色块前的。

    local skillBase = skillInfo.skillBase
    local baseAttack = params.baseAttack -- 普通色块基础战力: 连线将生成的英雄的基础战力
    local evaluate = 0
    if #enemyBeforeSkillBlockList > 0 then
        evaluate = baseAttack * 2
    end
    return math.floor(skillBase * 2 * 0.5 + evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 4331 (参考: ) 江流儿 :金箍圈住对面所有英雄，减少所有敌方单位50%输出伤害1回合
-- (max{(敌方所有英雄战力总和-我方所有英雄战力总和),0}+5*敌方平均技能色块战力)*50%*50%
function root:getSkillEvaluate4331(core, skillInfo, params)
    local SkillAvgEvaluate = self:getSkillAvgEvaluate(core, skillInfo, params, params.enemyBeforeSkillBlockList, 4331)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local evaluate = max(enemyHeroTotalEv - selfHeroTotalEv, 0) + SkillAvgEvaluate * 0.5 * 0.5
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 3331 (参考: ) 烟波   :主角获得buff，被拉扯叛变的英雄转变为炮弹，造成周围3*3的范围伤害，伤害值为50%的被拉英雄战力，持续4个回合
-- 公式: sum（我方英雄战力*位置系数）*50%
function root:getSkillEvaluate3331(core, skillInfo, params)
    local selfHeroList = params.selfHeroList
    local newBlockXYMap = params.newBlockXYMap
    local baseAttack = params.baseAttack
    local areaH = core.areaH
    local evaluate = 0

    local selfHeroParam = {0, 0, 0, 1, 1.5, 1.5, 1, 0, 0, 0}
    for _, hero in ipairs(selfHeroList) do
        evaluate = evaluate + selfHeroParam[newBlockXYMap[hero.bindBlock.id].y + 1] * baseAttack
    end
    return math.floor(evaluate * 0.5 + 0.5)
end

-- 技能评价 - 不叠加 - 2341  (参考: ) 含光 主:我方全体英雄获得护盾，减少受到伤害50%，持续1回合;辅助:增加的临时护盾%s转变为装备护盾
-- 公式: if(我方英雄战力<当对面英雄战力<我方英雄战力*2),我方英雄战力总和*50%,else 我方英雄战力总和*25%
function root:getSkillEvaluate2341(core, skillInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv

    local evaluate = 0
    if (selfHeroTotalEv < enemyHeroTotalEv) and (enemyHeroTotalEv < 2 * selfHeroTotalEv) then
        evaluate = selfHeroTotalEv * 0.5
    else
        evaluate = selfHeroTotalEv * 0.25
    end

    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 1341  (参考: ) 暖阳 主:当前回合增加所有盟军50%的攻击力;辅助:增加的临时攻击力，%s转化为英雄装备武器
-- 公式:我方英雄战力总和*75%
function root:getSkillEvaluate1341(core, skillInfo, params)
    local selfHeroTotalEv = params.selfHeroTotalEv
    return math.floor(selfHeroTotalEv * 0.75 + 0.5)
end

-- 技能评价 - 不叠加 - 4341  (参考: ) 蹴鞠 主:对场上所有敌方英雄造成一次伤害，伤害值为3倍自身基础战力，但同时自己也会受到同等伤害。;辅助:使用主动技能受到的伤害的%s转化为主角血量
-- 公式: 敌方受到的伤害总和*75%-3*技能战力. 敌方受到的伤害总和=sum( min(hero_1_hp,3倍对应技能色块战力),…,min(hero_999_hp,3倍对应技能色块战力)
function root:getSkillEvaluate4341(core, skillInfo, params)
    local skillCount = skillInfo.skillCount
    local skillBase = skillInfo.skillBase
    local damage = skillBase * 1 * skillCount
    local enemyHeroList = params.enemyHeroList

    local enemyTotalDamage = 0
    for _, hero in ipairs(enemyHeroList) do
        enemyTotalDamage = enemyTotalDamage + math.min(damage, hero:getHp())
    end

    local evaluate = enemyTotalDamage * 0.75 - 3 * skillBase
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 3341  (参考: ) 璨月 主:攻击后，如果杀死对方单位，则以50%的攻击对下一个目标继续攻击，直至未完成击杀/无攻击目标;辅助:追击伤害提升%s
-- 公式: 需要判断生成的英雄攻击时是否可以杀死对面最高战力单位，如果可以，收益为：连线生成英雄战力*50%*75%，如果不是，收益为0
function root:getSkillEvaluate3341(core, skillInfo, params)
    local evaluate = 0
    local newHeroAttack = params.newHeroAttack
    local enemyHeroList = params.enemyHeroList
    local enemyHeroHighestEv =
        enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0

    if newHeroAttack >= enemyHeroHighestEv then
        evaluate = newHeroAttack * 0.75 * 0.5
    end
    return math.floor(evaluate + 0.5)
end

-- 技能评价 - 不叠加 - 8888  (参考: )
-- 公式:
function root:getSkillEvaluate__(core, skillInfo, params)
    -- local newHeroAttack = params.newHeroAttack
    local evaluate = 0
    return math.floor(evaluate + 0.5)
end

--#endregion
-- 以下为天赋技能 -----------------------------------------------------------

-- 天赋评价 - 11041 医师 死亡后，自身位置变为万能灵晶
-- 连线评价：1A
function root:getTalentEvaluate11041(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack
end

-- 天赋评价 - 11091 海德博士 普通状态下，受到致命伤害时，可保留1灵力
-- 连线评价：0.5A
function root:getTalentEvaluate11091(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 0.5
end

-- 天赋评价 - 13021 罗杰 召唤后，随机1个我方技能灵晶，其相邻2个位置变为同色灵晶
-- 连线评价：1A
function root:getTalentEvaluate13021(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack
end

-- 天赋评价 - 13041 极限特工 被击杀时，对方所有单位将分担对等灵力的一半伤害
-- 连线评价：1A
function root:getTalentEvaluate13041(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack
end

-- 天赋评价 - 14031 化学老师 死亡后，自身位置生成一个技能灵晶
-- 连线评价：0.5A
function root:getTalentEvaluate14031(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 0.5
end

-- 天赋评价 - 14071 忍者 被攻击时，会转移一半的伤害到血量最高的伙伴上
-- 连线评价
-- 基地血量[50%~100%]：1.5A
-- 基地血量[30%~50%)：0
-- 基地血量[0%~30%)：-0.5A
function root:getTalentEvaluate14071(core, talentInfo, params)
    local baseAttack = params.baseAttack
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local percent = selfCastleHp / selfCastleMaxHp
    if percent > 0.5 then
        return baseAttack * 1.5
    elseif percent > 0.3 then
        return 0
    else
        return baseAttack * -0.5
    end
end

-- function root:getTalentEvaluate14241(core, talentInfo, params)
--     local baseAttack = params.baseAttack
--     local selfCastleMaxHp = params.selfCastleMaxHp
--     local selfCastleHp = params.selfCastleHp
--     local percent = selfCastleHp / selfCastleMaxHp

--     if percent > 0.5 then
--         return baseAttack * 1.5
--     elseif percent > 0.3 then
--         return 0
--     else
--         return baseAttack * -0.5
--     end
-- end

-- 天赋评价 - 13101 汤米 非狂暴状态每回合吸取神龛2倍灵力的信仰提升自己，信仰不足则不吸取
-- 连线评价
-- 基地血量[50%~100%]：1.5A
-- 基地血量[30%~50%)：0
-- 基地血量[0%~30%)：-0.5A
function root:getTalentEvaluate13101(core, talentInfo, params)
    local baseAttack = params.baseAttack
    local selfCastleMaxHp = params.selfCastleMaxHp
    local selfCastleHp = params.selfCastleHp
    local percent = selfCastleHp / selfCastleMaxHp
    if percent > 0.5 then
        return baseAttack * 1.5
    elseif percent > 0.3 then
        return 0
    else
        return baseAttack * -0.5
    end
end

-- 天赋评价 - 12111 金羽 召唤后，复制对方1个技能到自己场上
-- 连线评价：1.2A
function root:getTalentEvaluate12111(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1.2
end

-- 天赋评价 - 12241 晴色 自身承受伤害变为80%
-- 连线评价：生成英雄战力*20%*65%
function root:getTalentEvaluate12241(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.2 * 0.65)
end

-- 天赋评价 - 11241 鸢萝 英雄生成时，随机消除周围的3格色块
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate11241(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
    --[[
    local selfHeroList = params.selfHeroList
    local newBlockXYMap = params.newBlockXYMap
    local baseAttack = params.baseAttack
    local areaH = core.areaH
    local linkCount = core.linkCount

    local ev = 0

    local selfHeroParam = {0.1, 0.3, 0.5, 0.7, 1, 1, 0.7, 0.5, 0.3, 0.1}
    -- 半场行数超过5的，给补充1.5在中间
    for i = 1, areaH - 5 do
        table.insert(selfHeroParam, 6, 1)
        table.insert(selfHeroParam, 6, 1)
    end
    for _, hero in ipairs(selfHeroList) do
        ev = ev + selfHeroParam[newBlockXYMap[hero.bindBlock.id].y + 1] * baseAttack
    end

    local newHeroAttack = params.newHeroAttack

    return math.floor(ev * newHeroAttack * linkCount * 0.1)
    ]]
end

-- 天赋评价 - 14241 阿空 该英雄不受技能效果影响，不会被秒杀、斩杀、移出战场等
-- 连线评价：上阵秒杀英雄数量*1*英雄基础战力
-- 秒杀英雄数量包括：乔乔、小青、眠眠、百戏、影生，敌我英雄分开计算，上阵秒杀英雄数量最大值为：2
function root:getTalentEvaluate14241(core, talentInfo, params)
    -- TODO: Debug 测试代码,上线前修改过来.
    local baseAttack = params.baseAttack
    return baseAttack * 1.2
end

-- 天赋评价 - 13241 象琪 英雄生成时，给主角增加一个25%减伤护盾，持续2回合
-- 连线评价：max((max{敌方所有英雄战力总和-我方所有英雄战力总和,0}+5*敌方平均技能色块战力) - 我方所有英雄战力总和, 0)*25%*50%
function root:getTalentEvaluate13241(core, talentInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    local ev = max((max((enemyHeroTotalEv - selfHeroTotalEv), 0) + 5 * enemyAverageBaseAttack - selfHeroTotalEv), 0)

    return math.floor(ev * 0.25 * 0.5)
end

-- 天赋评价 - 12251 绮罗 优先攻击对方最低英雄战力的单位
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate12251(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
end

-- 天赋评价 - 11251 风月 每回合开始时，获得一个抵挡伤害的护盾，抵挡值为1倍基础战力，不可叠加
-- 连线评价：1*对应技能色块战力*生成英雄的血量参数(≥7*色块数，2否则1)*65%
function root:getTalentEvaluate11251(core, talentInfo, params)
    local baseAttack = params.baseAttack
    local linkCount = params.linkCount
    local newHeroAttack = params.newHeroAttack

    if linkCount >= 7 then
        return math.floor(1 * baseAttack * 2 * 0.65)
    else
        return math.floor(1 * baseAttack * 1 * 0.65)
    end
end

-- 天赋评价 - 14251 凛凛 有此英雄在场时，对面英雄的复活技能将无法生效
-- 连线评价：上阵复活英雄数量*1*英雄基础战力,复活英雄：盈缺、小景，敌我英雄分开计算
function root:getTalentEvaluate14251(core, talentInfo, params)
    -- TODO: Debug 测试代码,上线前修改过来.
    local baseAttack = params.baseAttack
    return baseAttack * 1.2
end

-- 天赋评价 - 13251 常明 英雄被拉扯过去，引发潮涌爆裂，对周围3*3范围内的敌人造成25%的英雄战力值伤害
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13251(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
end

-- 天赋评价 - 12261 花椒 有此英雄在场时，己方英雄叛变的伤害伤害增加50%
-- 连线评价：己方英雄站位系数*英雄战力*50%*50%
-- 第一排:第二排:第三排:第四排:第五排=100%:70%:50%:30%:10%(第一排为接近中线的那排)
function root:getTalentEvaluate12261(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack
    local newHeroY = params.newHeroY + 1
    local selfHeroParam = {1, 0.7, 0.5, 0.3, 0.1, 0.1, 0.3, 0.5, 0.7, 1}
    newHeroY = newHeroY > #selfHeroParam and #selfHeroParam or newHeroY
    local valueEv = selfHeroParam[newHeroY]

    return math.floor(newHeroAttack * valueEv * 0.5 * 0.5)
end

-- 天赋评价 - 11261 小景 有此英雄在场时，己方英雄叛变的伤害伤害增加50%
-- 连线评价：己方英雄站位系数*英雄战力*50%*50%
-- 第一排:第二排:第三排:第四排:第五排=100%:70%:50%:30%:10%(第一排为接近中线的那排)
function root:getTalentEvaluate11261(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack
    local newHeroY = params.newHeroY + 1
    local selfHeroParam = {01, 0.3, 0.5, 0.7, 1, 1, 0.7, 0.5, 0.3, 0.1}
    newHeroY = newHeroY > #selfHeroParam and #selfHeroParam or newHeroY
    local valueEv = selfHeroParam[newHeroY]

    return math.floor(newHeroAttack * valueEv * 0.5 * 0.5)
end

-- 天赋评价 - 14261 百戏 英雄生成时，随机锁定敌方一个技能，使其无法被连接及使用
-- 连线评价：if:敌方棋盘技能色块数量=1,3*普通色块基础战力*50%；if:敌方棋盘技能色块数量=0,0;else ,1*普通色块基础战力*50%
function root:getTalentEvaluate14261(core, talentInfo, params)
    local enemySkillBlockList = params.enemySkillBlockList or {}
    local baseAttack = params.baseAttack

    local count = #enemySkillBlockList
    if count == 1 then
        return math.floor(baseAttack * 3 * 0.5)
    elseif count == 0 then
        return 0
    else
        return math.floor(baseAttack * 1 * 0.5)
    end
end

-- 天赋评价 - 13261 疏雨 自身承受的第一次伤害变为50%
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13261(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 1 * baseAttack * 1
end

-- 天赋评价 - 12281 团团 召唤时，对对方主角发起一次冰冷冲击，造成%s倍基础战力的伤害
-- 连线评价：1*英雄基础战力*50%
function root:getTalentEvaluate12281(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 0.5)
end

-- 天赋评价 - 11281 烧麦 有此英雄在场时，对面英雄叛变的伤害伤害减少50%
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate11281(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1)
    --[[
    local newHeroAttack = core.newHeroAttack
    local newHeroY = core.newHeroY + 1
    local selfHeroParam = {01, 0.3, 0.5, 0.7, 1, 1, 0.7, 0.5, 0.3, 0.1}
    newHeroY = newHeroY > #selfHeroParam and #selfHeroParam or newHeroY
    local valueEv = selfHeroParam[newHeroY]

    return math.floor(newHeroAttack * valueEv * 0.5 * 0.5)
    ]]
end

-- 天赋评价 - 14281 猴宝 猴宝操控暗影能量，对面棋盘每存在一个技能色块时，能够提升自身1倍基础战力，增强实力。
-- 连线评价：敌方棋盘技能数量*1*英雄基础战力
function root:getTalentEvaluate14281(core, talentInfo, params)
    local selfSkillBlockList = params.selfSkillBlockList or {}
    local count = #selfSkillBlockList

    local baseAttack = params.baseAttack
    return count * baseAttack * 1
end

-- 天赋评价 - 13281 阿呆 阿呆拥有自然之助的力量，在召唤时，若我方棋盘存在单位比对方少，生成的英雄攻击力将提升20%，助力战局。
-- 连线评价：if：我方棋盘英雄数量<敌方棋盘英雄数量，生成英雄战力20%，else 0
function root:getTalentEvaluate13281(core, talentInfo, params)
    local enemyHeroList = params.enemyHeroList or {}
    local selfHeroList = params.selfHeroList or {}
    local newHeroAttack = params.newHeroAttack or 0

    -- local enemyHeroHighestEv =
    --     enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0
    -- local selfHeroHighestEv =
    --     selfHeroList[#enemyHeroList] and self:getHeroEvaluate(core, selfHeroList[#enemyHeroList]) or 0

    -- if enemyHeroHighestEv > newHeroAttack and selfHeroHighestEv > newHeroAttack then
    --     return math.floor(newHeroAttack * 0.2)
    -- end

    if #selfHeroList < #enemyHeroList then
        return math.floor(newHeroAttack * 0.2)
    end

    return 0
end

-- 天赋评价 - 12291 夜阑 召唤时，我方棋盘存在单位比对方多，则生成的英雄攻击力提升20%
-- 连线评价：if：我方棋盘英雄数量>敌方棋盘英雄数量，生成英雄战力20%，else 0
function root:getTalentEvaluate12291(core, talentInfo, params)
    local selfSkillBlockList = params.selfSkillBlockList or {}
    local myCount = #selfSkillBlockList

    local enemySkillBlockList = params.enemySkillBlockList or {}
    local enemyCount = #enemySkillBlockList
    local newHeroAttack = params.newHeroAttack or 0

    if myCount >= enemyCount then
        return math.floor(newHeroAttack * 0.2)
    end

    return 0
end

-- 天赋评价 - 11291 桃桃 召唤时，我方棋盘存在单位比对方多，则生成的英雄攻击力提升20%
-- 连线评价：if：我方棋盘英雄数量>敌方棋盘英雄数量，生成英雄战力20%，else 0
function root:getTalentEvaluate11291(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack or 0

    local enemyHeroCount = params.enemyHeroCount
    local selfHeroCount = params.selfHeroCount
    if selfHeroCount >= enemyHeroCount then
        return math.floor(newHeroAttack * 0.2)
    end
    return 0
end

-- 天赋评价 - 14291 倒倒 根据攻击距离提升英雄伤害，距离每多一格，伤害增加10%
-- 连线评价：50%*生成英雄战力*75%
function root:getTalentEvaluate14291(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack or 0
    return math.floor(newHeroAttack * 0.5 * 0.75)
end

-- 天赋评价 - 13291 咕噜 咕噜化身为海妖，拥有束缚敌方的能力。英雄生成时，随机束缚对方一个单位英雄，使其在1回合内无法攻击及连线
-- 连线评价：if：我方英雄总战力>敌方英雄总战力，0，else （敌方英雄总战力-我方英雄总战力）*50%
function root:getTalentEvaluate13291(core, talentInfo, params)
    local enemyHeroTotalEv = params.enemyHeroTotalEv
    local selfHeroTotalEv = params.selfHeroTotalEv
    if selfHeroTotalEv < enemyHeroTotalEv then
        return math.floor((enemyHeroTotalEv - selfHeroTotalEv) * 0.5)
    end

    return 0
end

-- 天赋评价 - 12311 画意 英雄生成时，随机锁住对方1个色块1回合
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate12311(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
end

-- 天赋评价 - 11311 糯米 出生时，随机摧毁敌方一个技能
-- 连线评价：if：敌方棋盘技能色块数量=1，2*英雄基础战力*100%，if:敌方棋盘技能色块数量=0，0，else 1*英雄基础战力*100%
function root:getTalentEvaluate11311(core, talentInfo, params)
    local enemySkillBlockList = params.enemySkillBlockList or {}
    local count = #enemySkillBlockList
    local baseAttack = params.baseAttack

    local enemyAverageBaseAttack = params.enemyAverageBaseAttack
    if count == 1 then
        return 2 * baseAttack
    elseif count == 0 then
        return 0
    else
        return 1 * baseAttack
    end
end

-- 天赋评价 - 14311 纤纤 造成的伤害增加20%
-- 连线评价：生成英雄战力*20%*75%
function root:getTalentEvaluate14311(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.2 * 0.75)
end

-- 天赋评价 - 13311 孤梦 出生时，随机改变场上5个色块颜色
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13311(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
end

-- 天赋评价 - 12321 不酸 每击杀对面一个英雄，都会对对方主角造成一倍英雄基础战力伤害
-- 连线评价：1*英雄基础战力*50%
function root:getTalentEvaluate12321(core, talentInfo, params)
    -- local selfHeroCount = params.selfHeroCount
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 0.5)
end

-- 天赋评价 - 11321 绿蛛 英雄生成时，随机对对方棋盘2个色块进行污染，感染的色块会对周围的英雄造成%s的伤害，持续4个回合
-- 连线评价：1.5*英雄基础战力*100%
function root:getTalentEvaluate11321(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1.5)
end

-- 天赋评价 - 14321 云中客 英雄被击杀后，主角获得2倍基础战力的气血恢复
-- 连线评价：2倍英雄基础战力*50%
function root:getTalentEvaluate14321(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 2 * 0.5)
end

-- 天赋评价 - 13321 酿酿 英雄生成时，会额外召唤一个1倍基础战力英雄单位
-- 连线评价：1.2*英雄基础战力
function root:getTalentEvaluate13321(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1.2)
end

-- 天赋评价 - 12331 阿筝 阿筝造成伤害的%s转化为自己主角生命恢复
-- 连线评价：生成英雄战力*10%*50%
function root:getTalentEvaluate12331(core, talentInfo, params)
    local newHeroAttack = params.newHeroAttack
    return math.floor(newHeroAttack * 0.1 * 0.5)
end

-- 天赋评价 - 11331 影生 被击杀后，会以1倍基础战力复活，复活的英雄不会攻击，但是可以抵挡伤害跟被连线
-- 连线评价：1*英雄基础战力*50%
function root:getTalentEvaluate11331(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1 * 0.5)
end

-- 天赋评价 - 14331 江流儿 英雄在场时，对方主角怒气增涨效果减半
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate14331(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 0.1)
end

-- 天赋评价 - 13331 烟波 首次收到致命伤害的时候触发名刀效果，免疫该次致命攻击
-- 连线评价：1.2*英雄基础战力*100%
function root:getTalentEvaluate13331(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1.2)
end

-- 天赋评价 - 2341 含光 免疫受到的首次攻击伤害
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate12341(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1)
end

-- 天赋评价 - 1341 暖阳 英雄生成的时候，如果自身生成的战力不是场上最高，则战力提升20%
-- 连线评价：if：生成英雄战力不是场上战力最高，生成英雄战力20%，else 0
function root:getTalentEvaluate11341(core, talentInfo, params)
    local enemyHeroList = params.enemyHeroList
    local selfHeroList = params.selfHeroList
    local newHeroAttack = core.newHeroAttack or 0

    local enemyHeroHighestEv =
        enemyHeroList[#enemyHeroList] and self:getHeroEvaluate(core, enemyHeroList[#enemyHeroList]) or 0
    local selfHeroHighestEv =
        selfHeroList[#enemyHeroList] and self:getHeroEvaluate(core, selfHeroList[#enemyHeroList]) or 0

    if enemyHeroHighestEv > newHeroAttack and selfHeroHighestEv > newHeroAttack then
        return math.floor(newHeroAttack * 0.2)
    end

    return 0
end

-- 天赋评价 - 4341 蹴鞠 英雄死亡时，对对方主角造成一倍基础战力的技能伤害
-- 连线评价：1*英雄基础战力*50%
function root:getTalentEvaluate14341(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1 * 0.5)
end

-- 天赋评价 - 3341 璨月 攻击时无视对方护盾、伤害减免效果
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13341(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return math.floor(baseAttack * 1)
end

-- 天赋评价 - 12351 金羽 召唤后，复制对方1个技能到自己场上
-- 连线评价：1.2*英雄基础战力*100%
function root:getTalentEvaluate12351(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 1.2 * baseAttack * 1
end

-- 天赋评价 - 11351 盈缺 普通状态下，受到致命伤害时，可保留1灵力
-- 连线评价：0.5*英雄基础战力*100%
function root:getTalentEvaluate11351(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 0.5 * baseAttack * 1
end

-- 天赋评价 - 14351 无情 非狂暴状态每回合吸取神龛1.5倍灵力的信仰提升自己，信仰不足则不吸取
-- 连线评价：基地血量[50%~100%]：1.5*英雄基础战力*100%
-- 基地血量[30%~50%)：0*英雄基础战力*100%
-- 基地血量[0%~30%)：-0.5A*英雄基础战力*100%
function root:getTalentEvaluate14351(core, talentInfo, params)
    local baseAttack = params.baseAttack
    local selfCastleHp = params.selfCastleHp
    local selfCastleMaxHp = params.selfCastleMaxHp -- 我方基地最大血量

    if (selfCastleHp / selfCastleMaxHp) > 0.5 then
        return math.floor(baseAttack * 1.5)
    elseif (selfCastleHp / selfCastleMaxHp) > 0.3 then
        return 0
    else
        return -math.floor(baseAttack * 0.5)
    end
end

-- 天赋评价 - 13351 小青 被击杀时，对方所有单位将分担对等灵力的一半伤害
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13351(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 1 * baseAttack * 1
end

-- 天赋评价 - 12361 乔乔 死亡后，自身位置生成一个技能灵晶
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate12361(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 1 * baseAttack * 1
end

-- 天赋评价 - 11361 十里 死亡后，自身位置变为万能灵晶
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate11361(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return baseAttack * 1
end

-- 天赋评价 - 14361 千两 被攻击时，会转移一半的伤害到血量最高的伙伴上
-- 连线评价：基地血量[50%~100%]：1.5*英雄基础战力*100%
-- 基地血量[30%~50%)：0*英雄基础战力*100%
-- 基地血量[0%~30%)：-0.5A*英雄基础战力*100%
function root:getTalentEvaluate14361(core, talentInfo, params)
    local baseAttack = params.baseAttack
    local selfCastleHp = params.selfCastleHp
    local selfCastleMaxHp = params.selfCastleMaxHp -- 我方基地最大血量

    if (selfCastleHp / selfCastleMaxHp) > 0.5 then
        return math.floor(baseAttack * 1.5)
    elseif (selfCastleHp / selfCastleMaxHp) > 0.3 then
        return 0
    else
        return -math.floor(baseAttack * 0.5)
    end
end

-- 天赋评价 - 13361 一叶 召唤后，随机1个我方技能灵晶，其相邻2个位置变为同色灵晶
-- 连线评价：1*英雄基础战力*100%
function root:getTalentEvaluate13361(core, talentInfo, params)
    local baseAttack = params.baseAttack
    return 1 * baseAttack * 1
end

return root