local LastAttakedByMonster = "@上次被怪物攻击的变量"
local HurtTypeDefKeys = {
    YI_BAN = "YI_BAN",
    ZHUO_YUE = "ZHUO_YUE",
    XING_YUN = "XING_YUN",
    WU_SHI = "WU_SHI",
    SHUANG_BEI = "SHUANG_BEI",
    BAO_JI = "BAO_JI",
    ZHI_MING = "ZHI_MING",
    SAN_BEI = "SAN_BEI",
}

PlayerFight = {}
local this = PlayerFight

local FightLog = {}
local ComboSkills = {
    [1030001] = 1
}

function excusefightdamage(actor, paramMapList)
    -- local magicValue = this.getAttValueWithName(actor, "wandMagicAttackPowerBonus")
    -- local mountdamagebonus = this.getAttValueWithName(actor, "mountdamagebonus")

    local selfType = getbaseinfo(actor, "mapobjecttype")
    if selfType == MapObjectType.PLAYER then
        local isQuiverDestory = APIGetInt(actor, "ZC_Quiver_Durability", 1)
        if isQuiverDestory == 1 then
            return {}
        end
    end

    local fightResults = {}
    for _, paramMap in pairs(paramMapList) do
        local skillInfo = ConfigDataManager.getTable("cfg_skill_info", "skillID", paramMap.skillid, "skillLevel", paramMap.skilllevel)
        paramMap["CfgData"] = next(skillInfo) and skillInfo[1] or {}
        local fightResultList = this.ExcuseFightDamage(actor, paramMap)
        for _, fightResult in pairs(fightResultList) do
            local next_stage = fightResult.next_stage == nil and true or
                fightResult.next_stage --是否继续往下计算（触发闪避等不继续计算）
            if next_stage == true then
                fightResult["target"] = paramMap["target"]
                local canAttack, Result = PlayerFight.Damage(actor, paramMap, fightResult) --引擎伤害计算完成后重新计算
                if canAttack then
                    table.concatTable(fightResults, Result)
                end
            end
        end
    end
    if table.count(paramMapList) > 0 then
        this.AttackPassiveSkill(actor, paramMapList)
    end
    return fightResults
end

-- 兼容旧入口：FightDamageTypeCache
FightDamageTypeCache = FightDamageTypeCache or {}
function FightDamageTypeCache.Cache(...)
    return PlayerFight.Cache(...)
end

function FightDamageTypeCache.GetElementalHurtType(caster, key)
    return PlayerFight.GetElementalHurtType(caster, key)
end

function FightDamageTypeCache.GetHurtType(caster)
    return PlayerFight.GetHurtType(caster)
end

-- hurttype 伤害类型
-- 101	一般攻击
-- 102	幸运一击
-- 103	幸运一击+无视防御
-- 104	卓越一击
-- 105	卓越一击+无视防御
-- 106	无视防御
-- 107	双倍伤害
-- 108	攻击敌方MISS
-- 109	反射伤害(技能伤害反射/卓越属性伤害反射)
-- 110	掉落防护值
-- 111	幸运一击+双倍伤害
-- 112	幸运一击+无视防御+双倍伤害
-- 113	卓越一击+双倍伤害
-- 114	卓越一击+无视防御+双倍伤害
-- 115	无视防御+双倍伤害
-- 116	燃烧
-- 117	中毒
-- 118	治疗
-- 119	回蓝
-- 120	幸运一击+卓越一击
-- 121	幸运一击+卓越一击+双倍伤害
-- 122	幸运一击+卓越一击+双倍伤害+无视防御
-- 123	幸运一击+卓越一击+无视防御
-- 200	神圣伤害
-- 201	黑暗伤害
-- 202	雷电伤害
-- 203	风暴伤害
-- 204	神圣伤害+黑暗伤害
-- 205	神圣伤害+雷电伤害
-- 206	神圣伤害+风暴伤害
-- 207	黑暗伤害+雷电伤害
-- 208	黑暗伤害+风暴伤害
-- 209	雷电伤害+风暴伤害
-- 210	神圣伤害+黑暗伤害+雷电伤害
-- 211	神圣伤害+黑暗伤害+风暴伤害
-- 212	神圣伤害+雷电伤害+风暴伤害
-- 213	黑暗伤害+雷电伤害+风暴伤害
-- 214	神圣伤害+黑暗伤害+雷电伤害+风暴伤害
-- 301	连击技伤害
-- 401	卡牌变身伤害飘字


function PlayerFight.Damage(actor, paramMap, fightResult)
    -- local nowTime = os.time()
    local caster = paramMap.caster          --—— 攻击对象
    local target = paramMap.target          --—— 受击对象
    -- local mapid = paramMap.mapid            --—— 地图id
    -- local skillid = paramMap.skillid        --—— 技能id
    -- local skilllevel = paramMap.skilllevel  --—— 技能等级
    -- local monsterid = paramMap.monsterid    --—— 受击怪物id
    local castertype = paramMap.castertype --—— 攻击者类型
    local targettype = paramMap.targettype --—— 受击者类型

    local tAddHurt = {
        addHurtNum = 0,
        addHurtPct = 0,
    }

    local casthurt = fightResult.casthurt     --攻击者伤害
    local targethurt = fightResult.targethurt --受击者伤害
    local hurttype = fightResult.hurttype     --伤害类型
    local repeat1 = fightResult["repeat"]     --伤害次数
    -- local castershield = fightResult.castershield       --攻击者扣除护盾
    -- local targetshield = fightResult.targetshield       --受击者扣除护盾
    -- local targethurtshow = fightResult.targethurtshow   --飘字使用的伤害
    -- local comboskill = fightResult.comboskill           --是否是连击技能
    -- local target = fightResult.target                   --目标对象

    EquipGuard.guardHpChange(fightResult.target, targethurt)
    local extra_result = {}; --额外的飘字拆分
    -- 计算反伤
    casthurt = this.ReflexDamage(paramMap, targethurt)
    if targettype == MapObjectType.PLAYER and castertype == MapObjectType.PLAYER then
        local fightmodel = getbaseinfo(caster, "fightmodel")
        if fightmodel == 1 then
            return false, {}
        elseif fightmodel == 6 then
            local pkVal = pk.getpkvalue(target)
            if pkVal <= 0 then
                return false, {}
            end
        end

        fightResult.targethurt = targethurt --受击者伤害
        --伤害后AG和SD操作执行
        -- GameEvent.push(EventCfg.onAttackAGAndSD, paramMap, fightResult, extra_result)

        AGAndSD.onAttackAGAndSD(paramMap, fightResult, extra_result)
        if casthurt > 0 then
            casthurt = AGAndSD.onReflexDamage(paramMap, fightResult, extra_result, casthurt)
        end

        targethurt = fightResult.targethurt
        hurttype = fightResult.hurttype
    end


    --推送攻击前事件
    GameEvent.push(EventCfg.AttackDamage, paramMap, fightResult, tAddHurt)

    -- 吸血
    -- this.RecoverHP(paramMap,targethurt)

    -- fightlog(
    --     string.joinVar("目标扣血", math.floor(targethurt)) ..
    --     string.joinVar("攻击者扣血", math.floor(casthurt)) ..
    --     string.joinVar("目标扣护盾", math.floor(targetshield)) ..
    --     string.joinVar("攻击者扣护盾", math.floor(castershield)) ..
    --     string.joinVar("伤害类型", hurttype) ..
    --     string.joinVar("伤害次数", repeat1, true)
    -- )
    fightResult.casthurt       = casthurt   --攻击者伤害
    fightResult.targethurt     = targethurt --受击者伤害
    fightResult.targethurtshow = targethurt --飘字使用的伤害
    -- if castertype == MapObjectType.PLAYER then
    --     info(FightLog, "战斗日志打印")
    -- end

    -- fightResult.castershield    =       castershield    --攻击者者扣除护盾
    -- fightResult.targetshield    =       targetshield    --受击者扣除护盾
    fightResult.hurttype       = hurttype --伤害类型
    -- fightResult["repeat"]       =       repeat1         --伤害次数
    -- fightResult.comboskill      =       comboskill      --是否是连击技能
    -- fightResult.target          =       target          --目标对象

    local result               = { fightResult }
    if #extra_result > 0 then
        table.concatTable(result, extra_result)
    end
    -- info("现伤害3",fightResult)
    return true, result
end

-- 被动技能
function this.AttackPassiveSkill(actor, paramMapList)
    local selfType = getbaseinfo(actor, "mapobjecttype")
    if selfType ~= MapObjectType.PLAYER then
        return
    end
    local targetList = {}
    local skillId = paramMapList[1].skillid
    local skillLevel = paramMapList[1].skilllevel
    for _, paramMap in pairs(paramMapList) do
        table.insert(targetList, paramMap["target"])
    end
    PassiveSkill.RoleAttack(actor, targetList, skillId, skillLevel)
end

function this.IsSelfPet(actor, target)
    if actor == nil or target == nil then
        return false
    end
    local selfType = getbaseinfo(actor, "mapobjecttype")
    local targetType = getbaseinfo(target, "mapobjecttype")
    if selfType ~= MapObjectType.PLAYER then
        return false
    end
    if targetType ~= MapObjectType.PET then
        return false
    end
    local masterId = getbaseinfo(target, "master")
    local id = getbaseinfo(actor, "id")
    if masterId ~= id then
        return false
    end
    return true
end

function this.logTargetAttrInfo(targetActor)
    if targetActor == nil then
        return
    end
    local targetAttrInfo = getallattrinfo(targetActor)
    if targetAttrInfo == nil then
        return
    end
    local logText = ""
    for k, v in pairs(targetAttrInfo) do
        local attrId = tonumber(k)
        local attrValue = tonumber(v)
        if attrValue ~= 0 then
            local attrName = ConfigDataManager.getTableValue("cfg_att_info", "attribute", "id", attrId)
            if not string.isNullOrEmpty(logText) then
                logText = logText .. ","
            end
            logText = logText .. attrName .. "=" .. attrValue
        end
    end
    if not string.isNullOrEmpty(logText) then
        local name = getbaseinfo(targetActor, "rolename")
        logText = "攻击目标=" .. name .. ",目标属性【" .. logText .. "】"
    end
    fightlog(logText)
end

function this.ExcuseFightDamage(actor, paramMap)
    --fixme 异步问题，lua队列任务执行时，地图可能已经被销毁
    if not mapexists(actor) then
        info(actor:toString() .. "执行战斗脚本时，原地图已经被销毁")
        return this.BuildFightResult(0, 0, 0, 0, 108, 1)
    end
    this.initData(paramMap)
    fightlog("\n==========================================\n战斗日志\n==========================================")
    local caster = paramMap.caster
    local castType = paramMap.castertype
    local target = paramMap.target
    local skillid = paramMap.skillid
    -- local targetType = paramMap["targettype"]

    local isComboSkill = ComboSkills[skillid] ~= nil
    -- if castType == MapObjectType.PLAYER then
    --     local comboSkill = getrolefield(caster, "role.roleskill.comboskill")
    --     isComboSkill = tonumber(paramMap["skillid"]) == comboSkill.skillCfgId
    -- end

    if castType >= MapObjectType.PARTNER then
        fightlog("不存在的攻击者类型 " .. castType)
        local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
        return { result }
    end

    --检测没有副本次数 不对BOSS造成伤害 已经删除 有需求重新做

    if this.IsSelfPet(actor, target) then
        fightlog("攻击自己的召唤兽无效")
        local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
        return { result }
    end

    -- this.logTargetAttrInfo(target)

    -- 庇护判断
    if this.CheckBiHuBuff(paramMap) == true then
        fightlog("庇护生效，无法对玩家造成伤害")
        local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
        return { result }
    end

    -- PK值判断
    -- if this.CheckPKCanHurt(paramMap) == false then
    --     fightlog("pk值较高，无法对玩家造成伤害")
    --     local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
    --     return { result }
    -- end

    -- 攻城战是否可以攻击
    -- if not RolandSeige.CanAttackRolandWall(actor, target, castType, targetType) then
    --     local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
    --     return { result }
    -- end

    local resultList = {}

    -- 计算技能的重复伤害（伤害次数）
    local repeatl = this.getRepeatInfo(paramMap)

    for i = 1, repeatl, 1 do
        -- 计算伤害
        local hurtMin = 1
        local originDamage, hurtType = this.DamageCalculate(paramMap)

        -- -- 新手期锁血
        -- if this.noviceProtect(paramMap, originDamage) then
        --     local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
        --     return { result }
        -- end
        if originDamage <= 0 then
            if castType == MapObjectType.PLAYER then
                local level = tonumber(getbaseinfo(actor, "level"))
                hurtMin = math.max(1, math.floor(level / 10))
            end

            if isComboSkill ~= true then
                local result = this.BuildFightResult(0, hurtMin, 0, 0, hurtType, 1)
                return { result }
            end
        end

        local elementalDamage = 0
        local elementalType = nil
        if castType == MapObjectType.PLAYER or castType == MapObjectType.PET then
            -- 元素伤害
            elementalDamage, elementalType = this.ElementalHurt(paramMap)
        end

        -- 火龙附加伤害
        originDamage = this.handleHuolong(paramMap, originDamage)

        -- 副本修正伤害

        --如果元素伤害大于0 则基础伤害覆盖元素伤害 之前对方加的 明显是BUG
        -- if elementalDamage > 0 then
        --     elementalDamage = originDamage
        -- end

        local result = {}

        if isComboSkill then
            -- local skillHurt = APIGetInt(actor, "ZC_LianJiHurt")
            originDamage = (getattrinfo(caster, "strength") * 0.5 + getattrinfo(caster, "agility") * 0.5 + getattrinfo(caster, "intelligence") *0.5) *
                    (1 + getattrinfo(caster, "conboAdditionalRatio")) + originDamage + hurtMin
                -- originDamage = originDamage * math.randomFloat(0.9, 1)
            result = this.BuildFightResult(0, originDamage, 0, 0, 301, 1, isComboSkill)
        end

        if not next(result) then
            result = this.BuildFightResult(0, originDamage, 0, 0, hurtType, 1, isComboSkill)
        end

        -- 命中率判断
        -- if  this.CanHit(paramMap) == false then
        --     local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
        --     return { result }
        -- end
        
        if isComboSkill or this.CanHit(paramMap) then
            table.insert(resultList, result)
            if elementalDamage > 0 then
                local elementalResult = this.BuildFightResult(0, elementalDamage, 0, 0, elementalType, 1, isComboSkill)
                table.insert(resultList, elementalResult)
            end
        else
            local result = this.BuildFightResult(0, 0, 0, 0, 108, 1)
            table.insert(resultList, result)
        end
    end

    -- if  paramMap.castertype == MapObjectType.PLAYER  then
    --     local comboSkill = getrolefield(caster, "role.roleskill.comboskill")
    --     if tonumber(skillid) ~= comboSkill.skillCfgId then
    --         local skillHurt = 0
    --         for _, v in pairs(resultList) do
    --             skillHurt = skillHurt + v.targethurt
    --         end
    --         APISetInt(actor, "ZC_LianJiHurt", skillHurt)
    --     end
    -- end

    if paramMap.castertype == MapObjectType.PLAYER  then
        local skillHurt = 0
        local count = 0
        for _, v in pairs(resultList) do
            skillHurt = skillHurt + v.targethurt
            count = count + 1
        end
        -- APISetInt(actor, "ZC_DurabilityHurt", skillHurt)
        APISetInt(actor, "ZC_DurabilityHurtCount", count)
    end

    return resultList
end

-- 线上秒杀加日志
function this.LogMiaoSha(actor, target, targetType, hurt, monsterCfgId, skillId)
    if targetType == MapObjectType.MONSTER then
        local monsterType = tonumber(ConfigDataManager.getTableValue("cfg_monster", "type", "id", monsterCfgId))
        if monsterType == 2 or monsterType == 3 then
            local maxHp = getbaseinfo(target, "maxhp")
            if hurt * 2 >= maxHp then
                info(actor:toString() .. "变身对BOSS造成巨额伤害。skillId:" .. skillId .. " ;monsterCfg:" .. monsterCfgId)
            end
        end
    end
end

-- 攻击回血
function this.RecoverHP(paramMap, originDamage)
    local caster = paramMap["caster"]
    local HPAttackRecover = getattrinfo(caster, "HPAttackRecover")
    local HPAttackRecoveronus = getattrinfo(caster, "HPAttackRecoveronus")
    local attackBlood = getattrinfo(caster, "attackBlood")
    local attackRecover = originDamage * attackBlood
    local hpRecover = HPAttackRecover * (1 + HPAttackRecoveronus) + attackRecover
    local currentHp = getbaseinfo(caster, "hp")
    sethp(caster, hpRecover + currentHp)
end

--计算反伤
-- 163	PVP反射伤害固定值增加		pvpDamageReflexAdd
-- 164	PVP反射伤害固定值减少		pvpDamageReflexReduce
function this.ReflexDamage(paramMap, originDamage)
    local casterHurt = 0
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local damageReflexProbability = getattrinfo(target, "damageReflexProbability")
    local damageReflexResistanceProbability = getattrinfo(caster, "damageReflexResistanceProbability")
    local rate = damageReflexProbability - damageReflexResistanceProbability
    if this.SelectRate(rate) then
        local damageReflex = getattrinfo(target, "damageReflex")
        local pvpDamageReflexAdd = getattrinfo(target, "pvpDamageReflexAdd")
        local pvpDamageReflexReduce = getattrinfo(caster, "pvpDamageReflexReduce")
        casterHurt = originDamage * damageReflex + pvpDamageReflexAdd - pvpDamageReflexReduce
        casterHurt = math.max(0, casterHurt)
    end
    return casterHurt
end

--处理重复伤害次数
function this.getRepeatInfo(paramMap)
    local valueTimes = paramMap.CfgData.valuetimes
    local repeatl = 1
    if valueTimes ~= nil or valueTimes ~= "" then
         repeatl = RandomUtil.selectKey(valueTimes)
    end
    repeatl = math.max(repeatl, 1)
    return repeatl
end

function this.handleHuolong(paramMap, originDamage)
    local caster = paramMap["caster"]
    local castMapObjectType = getbaseinfo(caster, "mapobjecttype")
    if castMapObjectType ~= MapObjectType.MONSTER then
        return originDamage
    end
    local monsterInfo = getmonsterinfo(caster)
    local cfgId = monsterInfo["cfgid"]
    if tonumber(cfgId) ~= MonsterConfigId.HUOLONG then
        return originDamage
    end
    local target = paramMap["target"]
    local targetMaxHp = getattrinfo(target, "maxHP")
    local costHp = targetMaxHp * 0.05
    return originDamage + costHp
end

function this.noviceProtect(paramMap, originDamage)
    local target = paramMap["target"]
    local targetType = paramMap["targettype"]
    if targetType ~= MapObjectType.PLAYER then
        return false
    end
    local novice = getplaydef(target, NOVICE_PROTECT)
    if not novice then
        return false
    end
    if novice then
        local currentHp = getbaseinfo(target, "hp")
        local haveHp = currentHp - (originDamage or 0)
        local stringHp = ConfigDataManager.getTableValue("cfg_global", "value", "id", "15004")
        local hp = tonumber(stringHp)
        if haveHp < hp then
            return true
        end
    end
    return false
end

function this.initData(paramMap)
    local caster = paramMap["caster"]
    local originType = {
        [HurtTypeDefKeys.YI_BAN] = "1",
        [HurtTypeDefKeys.ZHUO_YUE] = "0",
        [HurtTypeDefKeys.XING_YUN] = "0",
        [HurtTypeDefKeys.WU_SHI] = "0",
        [HurtTypeDefKeys.SHUANG_BEI] = "0",
        [HurtTypeDefKeys.BAO_JI] = "0",
    }
    paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = originType
    table.clear(FightLog)
end

function this.GetHurtType(caster)
    -- local resultType = getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
    -- local yiBanGongJi = resultType[HurtTypeDefKeys.YI_BAN]
    -- local zhuoYueYiJi = resultType[HurtTypeDefKeys.ZHUO_YUE]
    -- local xinYunYiJi = resultType[HurtTypeDefKeys.XING_YUN]
    -- local wuShiFangYu = resultType[HurtTypeDefKeys.WU_SHI]
    -- local shuangBeiYiJi = resultType[HurtTypeDefKeys.SHUANG_BEI]
    -- -- local baoJi = resultType[HurtTypeDefKeys.BAO_JI]
    -- local typeString = yiBanGongJi .. zhuoYueYiJi .. xinYunYiJi .. wuShiFangYu .. shuangBeiYiJi --..baoJi
    -- local hurtTypeCache = getsysvar(SystemVarConst.NORMAL_DAMAGE_TYPE_CACHE, 0)
    -- local type = hurtTypeCache[typeString]
    -- if type == nil then
    --     error(caster, caster, "获取攻击类型配置失败，结果为", typeString)
    --     type = 101
    -- end
    -- return type
    return 0
end

function this.GetElementalHurtType(caster, key)
    local elementalCache = getsysvar(SystemVarConst.ELEMENTAL_DAMAGE_TYPE_CACHE, 0)
    local type = elementalCache[key]
    if type == nil then
        if string.contains(key, "1") then
            error(caster, caster, "获取元素伤害类型配置失败，结果为", key)
        end
        type = 101
    end
    return type
end

function this.BuildFightResult(casthurt, targethurt, castershield, targetshield, hurttype, repeatl, combo)
    combo = combo or false
    local result = {}
    result["comboskill"] = combo
    result["casthurt"] = casthurt
    result["targethurt"] = targethurt
    result["castershield"] = castershield
    result["targetshield"] = targetshield
    result["hurttype"] = hurttype
    result["repeat"] = repeatl
    result["targethurtshow"] = targethurt / repeatl --飘字体用的伤害：真实伤害除以次数

    local next_stage = true
    if hurttype == 108 and targethurt == 0 then
        next_stage = false
    end
    result["next_stage"] = next_stage
    result["fightLog"] = FightLog
    return result
end

--计算伤害1（六条特殊属性计算）
function this.getDamage1(actor, paramMap)
    --基础伤害
    local minDC, maxDC = this.GetDCBySkill(paramMap)
    local damage = math.randomFloat(minDC, maxDC)
    local tab = {
        { this.IsXingYunYiJi(paramMap),   damage = this.XingYunDamage(paramMap, maxDC),  qz = 100 }, --幸运一击
        { this.IsZhuoYueYiJi(paramMap),   damage = this.ZhuoYueDamage(paramMap, damage), qz = 100 }, --卓越一击
        { this.IsShuangBeiYiJi(paramMap), damage = this.ShuangBeiYiJi(paramMap, damage), qz = 100 }, --双倍一击
        { this.IsBaoJi(paramMap),         damage = this.BaoJi(paramMap, damage),         qz = 100 }, --暴击
        { this.IsZhiMingYiJi(paramMap),   damage = this.ZhiMingYiJi(paramMap, damage),   qz = 100 }, --致命一击
        { this.IsSanBeiYiJi(paramMap),    damage = this.SanBeiYiJi(paramMap, damage),    qz = 100 }, --三倍一击
    }
    local tab1 = {}
    for i = 1, #tab do
        local bool = tab[i][1]
        if bool then
            table.insert(tab1, tab[i])
        end
    end
    if next(tab1) then
        local index = API.GetQZ(tab1)
        return tab1[index].damage
    else
        return damage
    end
end

function this.PlayerCastDamage(actor, paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local armor = getattrinfo(target, "armor")
    local targetType = paramMap["targettype"]
    local delArmor = 0
    if targetType == MapObjectType.PLAYER then
        local armorPenetValue = getattrinfo(caster, "armorPenetValue")
        local armorPenetRate = getattrinfo(caster, "armorPenetRate")
        delArmor = armorPenetValue * (1 + armorPenetRate)
        fightlog("防御穿透=" .. delArmor)
    end

    local var
    if this.IsWuShiFangYu(paramMap) then
        fightlog("触发 无视防御")
        var = 0
    else
        var = 1
    end

    fightlog("伤害1=【IF（A六条特殊触发（幸运/卓越一击等），A随机攻击）-（B防御-(PVP防御穿透固定值*(1+PVP防御穿透加成))）/2*IF(A无视防御触发，0，1）】")
    local damage1 = this.getDamage1(actor, paramMap) - math.max(0, (armor - delArmor)) / 2 * var +
        getattrinfo(caster, "hushichuantoufangyu") -- + hushichuantoufangyu
    fightlog("伤害1：" .. damage1)

    --伤害2=伤害1 * A使用技能对应技能系数
    fightlog("伤害2=伤害1 * A使用技能对应技能系数")
    
    local powerRate = tonumber(paramMap.CfgData.powerrate) or 0
    powerRate = powerRate == '' and 0 or (powerRate / 10000)
    local damage2 = damage1 * powerRate
    fightlog("伤害2：" .. damage2)

    --伤害3=伤害2 *（1+A加点伤害加成）
    fightlog("伤害3=伤害2 *（1+A加点伤害加成")
    local addtion = this.GetJiaDianAddition(paramMap)
    local damage3 = damage2 * (1 + addtion)
    fightlog("伤害3：" .. damage3)

    -- 伤害4=伤害3+A使用技能伤害的固定值 fixedDamage
    fightlog("伤害4=伤害3+A使用技能伤害的固定值 fixedDamage")
    local fixedDamage = paramMap.CfgData.fixeddamage or 0
    fixedDamage = fixedDamage == '' and 0 or fixedDamage
    local damage4 = damage3 + fixedDamage
    local finalDamage = damage4

    --  处于攻城战副本时，范围伤害修改 删除 有需求重新做


    -- A打B最终伤害<保底伤害时，最终伤害=保底伤害=A最大攻击力*可配置系数
    fightlog("A打B最终伤害<保底伤害时，最终伤害=保底伤害=（A最大攻击力+最小攻击力）/2*可配置系数")
    local minDC, maxDC = this.GetDCBySkill(paramMap)
    local factor = tonumber(ConfigDataManager.getTableValue("cfg_global", "value", "id", 7000)) / 10000
    local minDamage = (minDC + maxDC) / 2 * factor
    local originFinalDamage = finalDamage
    if finalDamage < minDamage then
        finalDamage = minDamage
    end
    fightlog("最终伤害：" .. originFinalDamage .. " 保底伤害：" .. minDamage)
    return finalDamage
end

-- 元素伤害
function this.ElementalHurt(paramMap)
    local caster = paramMap.caster
    local target = paramMap.target
    local hurtTypeKey
    -- 圣光
    local shengGuangDamage = 0
    local HolyUnMissRate = getattrinfo(caster, "HolyUnMissRate")
    local HolyResistUnMissRate = getattrinfo(target, "HolyResistUnMissRate")
    local HolyAttack = getattrinfo(caster, "HolyAttack")
    if not this.SelectRate(math.max(0, HolyResistUnMissRate - HolyUnMissRate)) and HolyAttack > 0 then
        local HolyDamageIncreased = getattrinfo(caster, "HolyDamageIncreased")
        local HolyDamageIncreasedBonus = getattrinfo(caster, "HolyDamageIncreasedBonus")
        local HolyDamageReduction = getattrinfo(target, "HolyDamageReduction")
        local HolyDamageReductionBonus = getattrinfo(target, "HolyDamageReductionBonus")
        shengGuangDamage = HolyAttack * (1 + HolyDamageIncreasedBonus - HolyDamageReductionBonus) + HolyDamageIncreased -
            HolyDamageReduction
        shengGuangDamage = math.max(shengGuangDamage, 0)
        if shengGuangDamage > 0 then
            hurtTypeKey = "1"
        else
            hurtTypeKey = "0"
        end
    else
        hurtTypeKey = "0"
    end
    -- info("圣光伤害="..shengGuangDamage)
    -- 黑暗
    local heiAnDamage = 0
    local DarkUnMissRate = getattrinfo(caster, "DarkUnMissRate")
    local DarkResistUnMissRate = getattrinfo(target, "DarkResistUnMissRate")
    local DarkAttack = getattrinfo(caster, "DarkAttack")
    if not this.SelectRate(math.max(0, DarkResistUnMissRate - DarkUnMissRate)) and DarkAttack > 0 then
        local DarkDamageIncreased = getattrinfo(caster, "DarkDamageIncreased")
        local DarkDamageIncreasedBonus = getattrinfo(caster, "DarkDamageIncreasedBonus")
        local DarkDamageReduction = getattrinfo(target, "DarkDamageReduction")
        local DarkDamageReductionBonus = getattrinfo(target, "DarkDamageReductionBonus")
        heiAnDamage = DarkAttack * (1 + DarkDamageIncreasedBonus - DarkDamageReductionBonus) + DarkDamageIncreased -
            DarkDamageReduction
        heiAnDamage = math.max(heiAnDamage, 0)
        if heiAnDamage > 0 then
            hurtTypeKey = hurtTypeKey .. "1"
        else
            hurtTypeKey = hurtTypeKey .. "0"
        end
    else
        hurtTypeKey = hurtTypeKey .. "0"
    end
    -- 雷电
    local leiDianDamage = 0
    local ThunderUnMissRate = getattrinfo(caster, "ThunderUnMissRate")
    local ThunderResistUnMissRate = getattrinfo(target, "ThunderResistUnMissRate")
    local ThunderAttack = getattrinfo(caster, "ThunderAttack")
    if not this.SelectRate(math.max(0, ThunderResistUnMissRate - ThunderUnMissRate)) and ThunderAttack > 0 then
        local ThunderDamageIncreased = getattrinfo(caster, "ThunderDamageIncreased")
        local ThunderDamageIncreasedBonus = getattrinfo(caster, "ThunderDamageIncreasedBonus")
        local ThunderDamageReduction = getattrinfo(target, "ThunderDamageReduction")
        local ThunderDamageReductionBonus = getattrinfo(target, "ThunderDamageReductionBonus")
        leiDianDamage = ThunderAttack * (1 + ThunderDamageIncreasedBonus - ThunderDamageReductionBonus) +
            ThunderDamageIncreased - ThunderDamageReduction
        leiDianDamage = math.max(leiDianDamage, 0)
        if leiDianDamage > 0 then
            hurtTypeKey = hurtTypeKey .. "1"
        else
            hurtTypeKey = hurtTypeKey .. "0"
        end
    else
        hurtTypeKey = hurtTypeKey .. "0"
    end
    -- 风暴
    local fengBaoDmage = 0
    local StormUnMissRate = getattrinfo(caster, "StormUnMissRate")
    local StormResistUnMissRate = getattrinfo(target, "StormResistUnMissRate")
    local StormAttack = getattrinfo(caster, "StormAttack")
    if not this.SelectRate(math.max(0, StormResistUnMissRate - StormUnMissRate)) and StormAttack > 0 then
        local StormDamageIncreased = getattrinfo(caster, "StormDamageIncreased")
        local StormDamageIncreasedBonus = getattrinfo(caster, "StormDamageIncreasedBonus")
        local StormDamageReduction = getattrinfo(target, "StormDamageReduction")
        local StormDamageReductionBonus = getattrinfo(target, "StormDamageReductionBonus")
        fengBaoDmage = StormAttack * (1 + StormDamageIncreasedBonus - StormDamageReductionBonus) + StormDamageIncreased -
            StormDamageReduction
        fengBaoDmage = math.max(fengBaoDmage, 0)
        if fengBaoDmage > 0 then
            hurtTypeKey = hurtTypeKey .. "1"
        else
            hurtTypeKey = hurtTypeKey .. "0"
        end
    else
        hurtTypeKey = hurtTypeKey .. "0"
    end

    local totalDamage = shengGuangDamage + heiAnDamage + leiDianDamage + fengBaoDmage
    totalDamage = math.max(0, totalDamage)

    -- info("元素伤害="..totalDamage)
    --  伤害类型（飘字）
    local hurtType = PlayerFight.GetElementalHurtType(caster, hurtTypeKey)
    return totalDamage, hurtType
end

function this.IsWuShiFangYu(paramMap)
    --A无视防御概率=A无视防御率 *（1 - B无视防御抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local unMissRate = this.getAttValueWithName(caster, "unMissRate")
    local unMissResistanceRate = this.getAttValueWithName(target, "unMissResistanceRate")
    local probability = unMissRate * (1 - unMissResistanceRate)
    local result = this.SelectRate(probability)


    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE]
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.WU_SHI] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.IsXingYunYiJi(paramMap)
    --A幸运一击触发概率=A幸运一击概率 *（1 - B幸运一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local criticalDamageChance = getattrinfo(caster, "criticalDamageChance")
    local criticalDamageResistanceChance = getattrinfo(target, "criticalDamageResistanceChance")
    local probability = criticalDamageChance * (1 - criticalDamageResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] --getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.XING_YUN] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.XingYunDamage(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    fightlog("触发 幸运一击")
    --A幸运攻击=A最大攻击 *（1+A幸运一击伤害加成 - B幸运一击伤害减少）
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageReducationBonus = getattrinfo(target, "criticalDamageReducationBonus")
    return damage * (1 + criticalDamageBonus - criticalDamageReducationBonus)
end

function this.IsZhuoYueYiJi(paramMap)
    --A卓越一击触发概率=A卓越一击概率*（1-B卓越一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local excellentDamageChance = getattrinfo(caster, "excellentDamageChance")
    local excellentDamageResistanceChance = getattrinfo(target, "excellentDamageResistanceChance")
    local probability = excellentDamageChance * (1 - excellentDamageResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] -- getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.ZHUO_YUE] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.ZhuoYueDamage(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    --A卓越攻击=A随机攻击 * IF（A卓越一击触发，A卓越一击伤害系数，0）*（1+A卓越一击伤害加成 - B卓越一击伤害减少）
    local coefficient
    fightlog("触发 卓越一击")
    coefficient = (tonumber(paramMap.CfgData.excellentrate) or 0) / 10000
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageReducationBonus = getattrinfo(target, "excellentDamageReducationBonus")
    return damage * coefficient * (1 + excellentDamageBonus - excellentDamageReducationBonus)
end

function this.IsShuangBeiYiJi(paramMap)
    --A双倍一击触发概率=A双倍一击概率 *（1 - B双倍一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local doubleDamageChance = getattrinfo(caster, "doubleDamageChance")
    local doubleDamageResistanceChance = getattrinfo(target, "doubleDamageResistanceChance")
    local probability = doubleDamageChance * (1 - doubleDamageResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] --getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.SHUANG_BEI] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.ShuangBeiYiJi(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    --A双倍攻击=A随机攻击 * IF（A双倍一击触发，1，0）*（1+A双倍一击伤害加成 - B双倍一击伤害减少）
    local coefficient = 1
    local doubleDamageBonus = getattrinfo(caster, "doubleDamageBonus")
    local doubleDamageReducationBonus = getattrinfo(target, "doubleDamageReducationBonus")
    return damage * coefficient * (1 + doubleDamageBonus - doubleDamageReducationBonus)
end

function this.IsBaoJi(paramMap)
    --A双倍一击触发概率=A双倍一击概率 *（1 - B双倍一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local criticalStrikeChance = getattrinfo(caster, "criticalStrikeChance")
    local criticalStrikeResistanceChance = getattrinfo(target, "criticalStrikeResistanceChance")
    local probability = criticalStrikeChance * (1 - criticalStrikeResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] --getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.BAO_JI] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.BaoJi(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local coefficient = 1
    --A暴击=A随机攻击 * IF（A暴击触发，1，0）*（1+A暴击伤害加成 - B暴击伤害减少）
    local criticalStrikeBonus = getattrinfo(caster, "criticalStrikeBonus")
    local criticalStrikeReducationBonus = getattrinfo(target, "criticalStrikeReducationBonus")
    return damage * coefficient * (1 + criticalStrikeBonus - criticalStrikeReducationBonus)
end

function this.IsZhiMingYiJi(paramMap)
    --A致命一击触发概率=A致命一击概率 *（1 - B致命一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local doubleDamageChance = getattrinfo(caster, "deadlyStrikeChance")
    local doubleDamageResistanceChance = getattrinfo(target, "deadlyStrikeResistanceChance")
    local probability = doubleDamageChance * (1 - doubleDamageResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] -- getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.ZHI_MING] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.ZhiMingYiJi(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    --A致命一击=A随机攻击 * IF（A致命一击触发，1，0）*（1+A致命一击伤害加成 - B致命一击伤害减少）
    local coefficient = 1
    local deadlyStrikeBonus = getattrinfo(caster, "deadlyStrikeBonus")
    local deadlyStrikeReducationBonus = getattrinfo(target, "deadlyStrikeReducationBonus")
    return damage * coefficient * (1 + deadlyStrikeBonus - deadlyStrikeReducationBonus)
end

function this.IsSanBeiYiJi(paramMap)
    --A三倍一击触发概率=A三倍一击概率 *（1 - B三倍一击概率抵抗）
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local doubleDamageChance = getattrinfo(caster, "tripleDamageChance")
    local doubleDamageResistanceChance = getattrinfo(target, "tripleDamageResistanceChance")
    local probability = doubleDamageChance * (1 - doubleDamageResistanceChance)
    local result = this.SelectRate(probability)
    if result then
        local resultType = paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] -- getplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE)
        resultType[HurtTypeDefKeys.YI_BAN] = "0"
        resultType[HurtTypeDefKeys.SAN_BEI] = "1"
        paramMap[PlayerDefKey.PLAYER_FIGHT_HURT_TYPE] = resultType
        -- setplaydef(caster, PlayerDefKey.PLAYER_FIGHT_HURT_TYPE, resultType)
    end
    return result
end

function this.SanBeiYiJi(paramMap, damage)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    --A三倍攻击=A随机攻击 * IF（A三倍一击触发，1，0）*（1+A三倍一击伤害加成 - B三倍一击伤害减少）
    local coefficient = 1
    local tripleDamageReduce = getattrinfo(caster, "tripleDamageReduce")
    local tripleDamageReducationBonus = getattrinfo(target, "tripleDamageReducationBonus")
    return damage * coefficient * (1 + tripleDamageReduce - tripleDamageReducationBonus)
end

function this.IfAttackedMutipleMonster(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local castType = paramMap["castertype"]
    local targetType = paramMap["targettype"]
    if castType ~= 2 or targetType ~= 1 then
        return false
    end
    local monsterId = caster:toString()
    local lastDataList = getplaydef(target, LastAttakedByMonster)
    local nowMillis = getbaseinfo("now")
    if type(lastDataList) ~= "table" then
        setplaydef(target, LastAttakedByMonster, { monsterId, nowMillis })
        return false
    end
    local lastMonsterId = lastDataList[1]
    local lastMillis = lastDataList[2]
    local duration = nowMillis - lastMillis
    if lastMonsterId == monsterId or duration < 1000 then
        setplaydef(target, LastAttakedByMonster, { monsterId, nowMillis })
        return false
    end
    setplaydef(target, LastAttakedByMonster, { monsterId, nowMillis })
    return true
end

function this.GetJiaDianAddition(paramMap)
    local caster = paramMap["caster"]
    
    local injuryType = tonumber(paramMap.CfgData.injurytype) or 0
    if injuryType == 1 then
        local addtion = getattrinfo(caster, "PhysicalDamage")
        return addtion
    elseif injuryType == 2 then
        local addtion = getattrinfo(caster, "MagicDamage")
        return addtion
    elseif injuryType == 3 then
        local addtion = getattrinfo(caster, "freeAtt8")
        return addtion
    else
        local maxDC = getattrinfo(caster, "maxDC")
        local maxMC = getattrinfo(caster, "maxMC")
        local maxCurDC = getattrinfo(caster, "maximumCurseAttackPower")
        if maxDC >= maxMC and maxDC >= maxCurDC then
            local addtion = getattrinfo(caster, "PhysicalDamage")
            return addtion
        elseif maxMC >= maxDC and maxMC >= maxCurDC then
            local addtion = getattrinfo(caster, "MagicDamage")
            return addtion
        elseif maxCurDC >= maxDC and maxCurDC >= maxMC then
            local addtion = getattrinfo(caster, "freeAtt8")
            return addtion
        end
        error("不存在的伤害类型" .. injuryType .. "skillId:" .. skillId)
        return 0
    end
end

function this.GetDCBySkill(paramMap)
    local caster = paramMap["caster"]
    local injuryType = tonumber(paramMap.CfgData.injurytype)
    if injuryType == 1 then
        local maxDC = getattrinfo(caster, "maxDC")
        local minDC = getattrinfo(caster, "minDC")
        return minDC, maxDC
    elseif injuryType == 2 then
        local maxMC = getattrinfo(caster, "maxMC")
        local minMC = getattrinfo(caster, "minMC")
        return minMC, maxMC
    elseif injuryType == 3 then
        local maxMC = getattrinfo(caster, "maximumCurseAttackPower")
        local minMC = getattrinfo(caster, "minimumCurseAttackPower")
        return minMC, maxMC
    else
        local maxDC = getattrinfo(caster, "maxDC")
        local maxMC = getattrinfo(caster, "maxMC")
        local maxCurDC = getattrinfo(caster, "maximumCurseAttackPower")
        if maxDC >= maxMC and maxDC >= maxCurDC then
            local minDC = getattrinfo(caster, "minDC")
            return minDC, maxDC
        elseif maxMC >= maxDC and maxMC >= maxCurDC then
            local minMC = getattrinfo(caster, "minMC")
            return minMC, maxMC
        elseif maxCurDC >= maxDC and maxCurDC >= maxMC then
            local minCurDC = getattrinfo(caster, "minimumCurseAttackPower")
            return minCurDC, maxCurDC
        end
        return 0, 0
    end
end

function this.CanHit(paramMap)
    local caster = paramMap.caster
    local target = paramMap.target

    local hitRate
    local missRate
    if paramMap.castertype == MapObjectType.MONSTER or paramMap.targettype == MapObjectType.MONSTER then
        --pve
        -- 209011 攻击率
        hitRate = this.getAttValueWithName(caster, "hitRate")
        -- 101	PVE攻击率加成
        local pvehitRateBonus = this.getAttValueWithName(caster, "pvehitRateBonus")
        if pvehitRateBonus > 0 then
            hitRate = hitRate * (1 + pvehitRateBonus)
        end
        -- 211011	防御率
        missRate = this.getAttValueWithName(target, "missRate")
        -- -- 103	PVE防御率加成
        -- local missRateBonus = this.getAttValueWithName(target, "missRateBonus")
        -- if missRateBonus > 0 then
        --     missRate = missRate * (1 + missRateBonus)
        -- end
    else
        --pvp
        -- 152/210011	PVP攻击率
        hitRate = this.getAttValueWithName(caster, "pvpattackRate")
        -- 153	PVP攻击率加成
        local attackRateBonus = this.getAttValueWithName(caster, "attackRateBonus")
        if attackRateBonus > 0 then
            hitRate = hitRate * (1 + attackRateBonus)
        end
        -- 154	PVP防御率
        missRate = this.getAttValueWithName(target, "eraRate")
        -- 155	PVP防御率加成	
        local eraRateBonus = this.getAttValueWithName(target, "eraRateBonus")
        if eraRateBonus > 0 then
            missRate = missRate * (1 + eraRateBonus)
        end
    end

    local basicMiss = 0 --getattrinfo(target, "freeAtt10")
    local probability
    if hitRate == 0 then
        probability = 0
    else
        probability = 1 - missRate / hitRate
    end
    -- if missRate + hitRate == 0 then
    --     probability = 1
    -- else
    --     probability = 1 - (1 - 1 / ((missRate - hitRate) / (missRate + hitRate) * 0.8 + 1)) - basicMiss
    -- end
    local hit = this.RandomResult(probability)
    fightlog("命中概率：" .. string.numToPercent(probability) .. "  命中结果：" .. tostring(hit))
    return hit
end

function this.SelectRate(probability)
    local randomNum = math.random()
    if randomNum <= probability then
        return true
    else
        return false
    end
end

function this.CheckPKCanHurt(paramMap)
    -- local caster = paramMap["caster"]
    -- local target = paramMap["target"]
    -- local castType = paramMap["castertype"]
    -- local targetType = paramMap["targettype"]
    -- if castType == 1 and targetType == 1 then
    --     -- PK值判断是否可以造成伤害
    --     local pkValue = tonumber(pk.getpkvalue(caster))
    --     local pkCountTableInfo = ConfigDataManager.getTable("cfg_pk_count", "pvpDamage", 1)
    --     if pkCountTableInfo and #pkCountTableInfo > 0 then
    --         local maxPkValue = 0
    --         for _, v in ipairs(pkCountTableInfo) do
    --             local nameColor = tostring(v["namecolor"])
    --             local split = string.split(nameColor, "#")
    --             local minValue = tonumber(split[1])
    --             local maxValue = tonumber(split[2])
    --             if pkValue >= minValue and pkValue <= maxValue then
    --                 -- PK值在此区间内不造成伤害
    --                 tipinfo(caster, "pk值较高，无法对玩家造成伤害")
    --                 return false
    --             end
    --             maxPkValue = maxPkValue > maxValue and maxPkValue or maxValue
    --         end
    --         if pkValue and pkValue ~= 0 and pkValue > maxPkValue then
    --             tipinfo(caster, "pk值较高，无法对玩家造成伤害")
    --             return false
    --         end
    --     else
    --         error("pkCountTableInfo is null")
    --     end
    --     -- PK值判断end
    -- end
    return true
end

function this.CheckBiHuBuff(paramMap)
    local castType = paramMap.castertype
    local targetType = paramMap.targettype
    -- 受击不是玩家，不享受庇护
    if targetType ~= MapObjectType.PLAYER and targetType ~= MapObjectType.PET then
        return false
    end
    -- 攻击不是玩家，不享受庇护
    if castType ~= MapObjectType.PLAYER and castType ~= MapObjectType.PET then
        return false
    end

    -- 不享受庇护buff的地图
    -- local maps = ConfigDataManager.getTableValue("cfg_global", "value", "id", "2000004")
    -- if table.contains(string.split(maps, "#", true), paramMap.mapid) then
    --     return false
    -- end

    -- 不在0~8点，不享受庇护
    local h = TimeUtil.GetTodayHour()
    if h < 23 and h >= 8 then
        return false
    end

    local caster = paramMap.caster
    local target = paramMap.target

    -- local debuffId = ConfigDataManager.getTableValue("cfg_global", "value", "id", "2000003")
    local buffId = 104001 -- tonumber(ConfigDataManager.getTableValue("cfg_global", "value", "id", "260004")) --减少读表消耗
    -- 被击者有庇护buff，享受庇护
    if hasbuff(target, buffId) then
        messagebox(caster, "被击者有庇护buff，享受庇护")
        return true
    end

    -- local delbuff = false
    -- if hasbuff(caster, buffId) then
    --     -- delbuff = true
    --     return true
    -- end
    -- local bossType = ConfigDataManager.getTableValue("cfg_monster", "type", "id", paramMap.monsterid)  --减少消耗放前端检测BOSS
    -- if targetType == MapObjectType.MONSTER and tonumber(bossType) == 3 then -- BOSS
    --     delbuff = true
    -- end
    -- if delbuff then        
    --     tipinfo(caster, "庇护buff被移除，庇护失效")
    --     Buffer.HandleBiHu(caster, buffId, 1)
    -- end

    return false
end

function this.AfterCalcuDamage(paramMap, finalDamage)
    -- 如果攻击的怪物是秘境副本的BOSS则累加记录实时伤害
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local castType = paramMap["castertype"]
    local targetType = paramMap["targettype"]
    if castType == 1 and targetType == 2 then
        local monsterId = paramMap["monsterid"]
        -- local bossChallenge = ConfigDataManager.getTable("cfg_BOSS_challenge", "monsterType", BossType.SECRET_REALM_BOSS)
        -- for i = 1, #bossChallenge do
        --     if tonumber(monsterId) == tonumber(bossChallenge[i].monsterid) then
        --         -- 存储实时伤害
        --         SecretRealm.savePlayerHurtInfo(caster, target, finalDamage < 0 and 1 or finalDamage)
        --     end
        -- end
        if SecretRealm.isSecretRealmBoss(monsterId) then
            -- 存储实时伤害
            SecretRealm.savePlayerHurtInfo(caster, target, finalDamage < 0 and 1 or finalDamage)
        end
        -- 保存战盟boos造成伤害的玩家
        WarAlliance.savePlayerInvloveInfo(caster, target, finalDamage, monsterId)
    end
end

--计算对怪伤害加成 返回 monsterDamageValueAdd,monsterDamageRateAdd 固定值增伤 百分比曾伤
function PlayerFight.getMonsterDamageAdd(actor, paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象

    local castertype = getbaseinfo(caster, "mapobjecttype")
    local targettype = getbaseinfo(target, "mapobjecttype")

    local monsterDamageValueAdd = 0 --增伤固定值
    local monsterDamageRateAdd = 0  --增伤万分比（小数）

    if castertype ~= MapObjectType.PLAYER and castertype ~= MapObjectType.PET then
        fightlog("-----------------------攻击方对象不是玩家-----------------------")
        return monsterDamageValueAdd, monsterDamageRateAdd
    end

    if targettype ~= MapObjectType.MONSTER then
        fightlog("-----------------------受击对象不是怪物-----------------------")
        return monsterDamageValueAdd, monsterDamageRateAdd
    end

    local logText = "" --伤害日志
    local monsterInfo = getmonsterinfo(target)
    local monsterId = monsterInfo.cfgid
    --monsterType =1 小怪  2=黄金怪 3=boss 4=超级BOSS
    local monsterType = ConfigDataManager.getTableValue("cfg_monster", "type", "id", monsterId)
    if string.isNullOrEmpty(monsterType) then
        monsterType = "1"
    end
    monsterType = tonumber(monsterType)

    logText = logText .. "-----------------------攻击怪物-----------------------------"

    local pveshanghaizengjiaValue = getattrinfo(caster, "pveshanghaizengjiaValue") or 0
    if pveshanghaizengjiaValue > 0 then
        monsterDamageValueAdd = monsterDamageValueAdd + pveshanghaizengjiaValue
        logText = logText .. string.joinVar("104 pve伤害增加", math.floor(pveshanghaizengjiaValue))
    end

    local pveshanghaijiachengRate = getattrinfo(caster, "pveshanghaijiachengRate") or 0
    if pveshanghaijiachengRate > 0 then
        monsterDamageRateAdd = monsterDamageRateAdd + pveshanghaijiachengRate
        logText = logText .. string.joinVar("105 pve伤害加成", math.floor(pveshanghaijiachengRate))
    end

    if monsterType == 1 then
        local duixiaoguaishanghaizengjiaValue = getattrinfo(caster, "duixiaoguaishanghaizengjiaValue") or 0
        if duixiaoguaishanghaizengjiaValue > 0 then
            monsterDamageValueAdd = monsterDamageValueAdd + duixiaoguaishanghaizengjiaValue
            logText = logText .. string.joinVar("110 对小怪伤害增加", math.floor(duixiaoguaishanghaizengjiaValue))
        end

        local duixiaoguaishanghaijiachengRate = getattrinfo(caster, "duixiaoguaishanghaijiachengRate") or 0
        if duixiaoguaishanghaijiachengRate > 0 then
            monsterDamageRateAdd = monsterDamageRateAdd + duixiaoguaishanghaijiachengRate
            logText = logText .. string.joinVar("111 对小怪伤害加成", math.floor(duixiaoguaishanghaijiachengRate))
        end
    elseif monsterType == 2 then
        local duihuangjinguaishanghaizengjiaValue = getattrinfo(caster, "duihuangjinguaishanghaizengjiaValue") or 0
        if duihuangjinguaishanghaizengjiaValue > 0 then
            monsterDamageValueAdd = monsterDamageValueAdd + duihuangjinguaishanghaizengjiaValue
            logText = logText .. string.joinVar("114 对黄金怪伤害增加", math.floor(duihuangjinguaishanghaizengjiaValue))
        end

        local duihuangjinguaishanghaijiachengRate = getattrinfo(caster, "duihuangjinguaishanghaijiachengRate") or 0
        if duihuangjinguaishanghaijiachengRate > 0 then
            monsterDamageRateAdd = monsterDamageRateAdd + duihuangjinguaishanghaijiachengRate
            logText = logText .. string.joinVar("115 对黄金怪伤害加成", math.floor(duihuangjinguaishanghaijiachengRate))
        end
    elseif monsterType == 3 then
        local duibossshanghaizengjiaValue = getattrinfo(caster, "duibossshanghaizengjiaValue")
        if duibossshanghaizengjiaValue > 0 then
            monsterDamageValueAdd = monsterDamageValueAdd + duibossshanghaizengjiaValue
            logText = logText .. string.joinVar("118 对BOSS伤害增加", math.floor(duibossshanghaizengjiaValue))
        end

        local duibossshanghaijiachengRate = getattrinfo(caster, "duibossshanghaijiachengRate")
        if duibossshanghaijiachengRate > 0 then
            monsterDamageRateAdd = monsterDamageRateAdd + duibossshanghaijiachengRate
            logText = logText .. string.joinVar("119 对BOSS伤害加成", math.floor(duibossshanghaijiachengRate))
        end
    elseif monsterType == 4 then
        local duichaojibossshanghaizengjiaValue = getattrinfo(caster, "duichaojibossshanghaizengjiaValue")
        if duichaojibossshanghaizengjiaValue > 0 then
            monsterDamageValueAdd = monsterDamageValueAdd + duichaojibossshanghaizengjiaValue
            logText = logText .. string.joinVar("122	对超级BOSS伤害增加", math.floor(duichaojibossshanghaizengjiaValue))
        end

        local duichaojibossshanghaijiachengRate = getattrinfo(caster, "duichaojibossshanghaijiachengRate")
        if duichaojibossshanghaijiachengRate > 0 then
            monsterDamageRateAdd = monsterDamageRateAdd + duichaojibossshanghaijiachengRate
            logText = logText .. string.joinVar("123	对超级BOSS伤害加成", math.floor(duichaojibossshanghaijiachengRate))
        end
    end

    fightlog(
        logText ..
        string.joinVar("对怪伤害最终固定值", math.floor(monsterDamageValueAdd)) ..
        string.joinVar("对怪伤害最终万分比", math.floor(monsterDamageRateAdd))
    )

    return monsterDamageValueAdd, monsterDamageRateAdd
end

--计算对怪伤害减免 返回 monsterDamageValueDel,monsterDamageRateDel 固定值减伤 百分比减伤
function PlayerFight.getMonsterDamageDel(actor, paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local castertype = getbaseinfo(caster, "mapobjecttype")
    local targettype = getbaseinfo(target, "mapobjecttype")

    local monsterDamageValueDel = 0 --减伤固定值
    local monsterDamageRateDel = 0  --减伤万分比（小数）
    local logText = ""

    if castertype ~= MapObjectType.MONSTER then
        fightlog("-----------------------攻击方对象不是怪物-----------------------")
        return monsterDamageValueDel, monsterDamageRateDel
    end

    if targettype ~= MapObjectType.PLAYER and targettype ~= MapObjectType.PET then
        fightlog("-----------------------受击方对象不是玩家-----------------------")
        return monsterDamageValueDel, monsterDamageRateDel
    end

    logText = logText .. "-----------------------被怪物攻击-----------------------------"

    local monsterInfo = getmonsterinfo(caster)
    local monsterId = monsterInfo.cfgid
    --monsterType =1 小怪  2=黄金怪 3=boss 4=超级BOSS
    local monsterType = ConfigDataManager.getTableValue("cfg_monster", "type", "id", monsterId)
    if string.isNullOrEmpty(monsterType) then
        monsterType = "1"
    end
    monsterType = tonumber(monsterType)

    local pveshanghaijianshaoValue = getattrinfo(target, "pveshanghaijianshaoValue") or 0
    if pveshanghaijianshaoValue > 0 then
        monsterDamageValueDel = monsterDamageValueDel + pveshanghaijianshaoValue
        logText = logText .. string.joinVar("106	pve伤害减少", math.floor(pveshanghaijianshaoValue))
    end

    -- 107	pve伤害减免	PVE伤害减免万分比	pveshanghaijianmianRate
    local pveshanghaijianmianRate = getattrinfo(target, "pveshanghaijianmianRate") or 0
    if pveshanghaijianmianRate > 0 then
        monsterDamageRateDel = monsterDamageRateDel + pveshanghaijianmianRate
        logText = logText .. string.joinVar("107	pve伤害减免", math.floor(pveshanghaijianmianRate))
    end

    if monsterType == 1 then
        local xiaoguaishanghaijianshaoValue = getattrinfo(target, "xiaoguaishanghaijianshaoValue")
        if xiaoguaishanghaijianshaoValue > 0 then
            monsterDamageValueDel = monsterDamageValueDel + xiaoguaishanghaijianshaoValue
            logText = logText .. string.joinVar("112	小怪伤害减少", math.floor(xiaoguaishanghaijianshaoValue))
        end

        local xiaoguaishanghaijianmianRate = getattrinfo(target, "xiaoguaishanghaijianmianRate")
        if xiaoguaishanghaijianmianRate > 0 then
            monsterDamageRateDel = xiaoguaishanghaijianmianRate
            logText = logText .. string.joinVar("113	小怪伤害减免", math.floor(xiaoguaishanghaijianmianRate))
        end
    elseif monsterType == 2 then
        local huangjinguaishanghaijianshaoValue = getattrinfo(target, "huangjinguaishanghaijianshaoValue")
        if huangjinguaishanghaijianshaoValue > 0 then
            monsterDamageValueDel = monsterDamageValueDel + huangjinguaishanghaijianshaoValue
            logText = logText .. string.joinVar("116	黄金怪伤害减少", math.floor(huangjinguaishanghaijianshaoValue))
        end

        local huangjinguaishanghaijianmianRate = getattrinfo(target, "huangjinguaishanghaijianmianRate")
        if huangjinguaishanghaijianmianRate > 0 then
            monsterDamageRateDel = huangjinguaishanghaijianmianRate
            logText = logText .. string.joinVar("117	黄金怪伤害减免", math.floor(huangjinguaishanghaijianmianRate))
        end
    elseif monsterType == 3 then
        local bossshanghaijianshaoValue = getattrinfo(target, "bossshanghaijianshaoValue")
        if bossshanghaijianshaoValue > 0 then
            monsterDamageValueDel = monsterDamageValueDel + bossshanghaijianshaoValue
            logText = logText .. string.joinVar("120	BOSS伤害减少", math.floor(bossshanghaijianshaoValue))
        end

        local bossshanghaijianmianRate = getattrinfo(target, "bossshanghaijianmianRate")
        if bossshanghaijianmianRate > 0 then
            monsterDamageRateDel = bossshanghaijianmianRate
            logText = logText .. string.joinVar("121	BOSS伤害减免", math.floor(bossshanghaijianmianRate))
        end
    elseif monsterType == 4 then
        local chaojibossshanghaijianshaoValue = getattrinfo(target, "chaojibossshanghaijianshaoValue")
        if chaojibossshanghaijianshaoValue > 0 then
            monsterDamageValueDel = monsterDamageValueDel + chaojibossshanghaijianshaoValue
            logText = logText .. string.joinVar("124	超级BOSS伤害减少", math.floor(chaojibossshanghaijianshaoValue))
        end

        local chaojibossshanghaijianmianRate = getattrinfo(target, "chaojibossshanghaijianmianRate")
        if chaojibossshanghaijianmianRate > 0 then
            monsterDamageRateDel = chaojibossshanghaijianmianRate
            logText = logText .. string.joinVar("125	超级BOSS伤害减免", math.floor(chaojibossshanghaijianmianRate))
        end
    end

    fightlog(
        logText ..
        string.joinVar("受怪减免最终固定值", math.floor(monsterDamageValueDel)) ..
        string.joinVar("受怪减免最终百分比", math.floor(monsterDamageRateDel))
    )

    return monsterDamageValueDel, monsterDamageRateDel
end

--计算PVP伤害 返回 PVPDamageValue,PVPDamageRate  PVP固定值总加成-总减免 PVP百分比总加成-总减免
function PlayerFight.getPVPDamage(actor, paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local castertype = getbaseinfo(caster, "mapobjecttype")
    local targettype = getbaseinfo(target, "mapobjecttype")
    local PVPDamageValue = 0 --A PVP固定值总加成-B总减免
    local PVPDamageRate = 0  --A PVP百分比总加成-B总减免

    if castertype ~= MapObjectType.PLAYER and castertype ~= MapObjectType.PET then
        fightlog("----------------PVP-------攻击方对象不是玩家-----------------------")
        return PVPDamageValue, PVPDamageRate
    end

    if targettype ~= MapObjectType.PLAYER then
        fightlog("----------------PVP-------受击对象不是玩家-----------------------")
        return PVPDamageValue, PVPDamageRate
    end

    -- 对固定职业的加减伤
    local tab = {
        [1] = {
            add = "duijianshishanghaizengjiaValue",
            del = "duijianshishanghaijianshaoValue",
            addRate = "duijianshishanghaijiachengRate",
            delRate = "duijianshishanghaijianmianRate"
        },
        [2] = {
            add = "duifashishanghaizengjiaValue",
            del = "duifashishanghaijianshaoValue",
            addRate = "duifashishanghaijiachengRate",
            delRate = "duifashishanghaijianmianRate"
        },
        [3] = {
            add = "duigongjianshoushanghaizengjiaValue",
            del = "duigongjianshoushanghaijianshaoValue",
            addRate = "duigongjianshoushanghaijiachengRate",
            delRate = "duigongjianshoushanghaijianmianRate"
        },
        [4] = {
            add = "duimojianshishanghaizengjiaValue",
            del = "duimojianshishanghaijianshaoValue",
            addRate = "duimojianshishanghaijiachengRate",
            delRate = "duimojianshishanghaijianmianRate"
        },
        [5] = {
            add = "duishengdaoshishanghaizengjiaValue",
            del = "duishengdaoshishanghaijianshaoValue",
            addRate = "duishengdaoshishanghaijiachengRate",
            delRate = "duishengdaoshishanghaijianmianRate"
        },
        [6] = {
            add = "duizhaohuanshishanghaizengjiaValue",
            del = "duizhaohuanshishanghaijianshaoValue",
            addRate = "duizhaohuanshishanghaijiachengRate",
            delRate = "duizhaohuanshishanghaijianmianRate"
        }
    }
    local casterCareer = getbaseinfo(caster, "getbasecareer")
    local targerCareer = getbaseinfo(target, "getbasecareer")

    local del = getattrinfo(target, tab[casterCareer].del) or 0
    local delRate = getattrinfo(target, tab[casterCareer].delRate) or 0

    local add = getattrinfo(caster, tab[targerCareer].add) or 0
    local addRate = getattrinfo(caster, tab[targerCareer].addRate) or 0

    PVPDamageValue = PVPDamageValue + math.max(0, add - del)
    PVPDamageRate = PVPDamageRate + math.max(0, addRate - delRate)

    -- 156	pvp伤害增加
    -- 158	pvp伤害减少
    local pvpDamageAdd = getattrinfo(caster, "pvpDamageAdd") or 0
    local pvpDamageReduce = getattrinfo(target, "pvpDamageReduce") or 0
    PVPDamageValue = PVPDamageValue + math.max(0, pvpDamageAdd - pvpDamageReduce)

    -- 157	PVP伤害加成	计算伤害3	damageBonus
    -- 159	PVP伤害减免	计算伤害3	damageReductionBonus
    local damageBonus = getattrinfo(caster, "damageBonus") or 0
    local damageReductionBonus = getattrinfo(target, "damageReductionBonus") or 0
    PVPDamageRate = PVPDamageRate + math.max(0, damageBonus - damageReductionBonus)

    -- 161	PVP出血伤害固定值
    -- 162	PVP出血伤害抵抗固定值
    local pvpBleedDamageAdd = getattrinfo(caster, "pvpBleedDamageAdd") or 0
    local pvpBleedDamageReduce = getattrinfo(target, "pvpBleedDamageReduce") or 0
    PVPDamageValue = PVPDamageValue + math.max(0, pvpBleedDamageAdd - pvpBleedDamageReduce)

    return PVPDamageValue, PVPDamageRate
end

--计算技能伤害 返回 SkillDamageValue,SkillDamageRate 技能固定值总加成-总减免 技能百分比总加成-总减免
function PlayerFight.getSkillDamage(actor, paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local castertype = getbaseinfo(caster, "mapobjecttype")
    local targettype = getbaseinfo(target, "mapobjecttype")

    local SkillDamageValue = 0 --A 技能固定值总加成-B总减免
    local SkillDamageRate = 0  --A 技能百分比总加成-B总减免

    if castertype == MapObjectType.PLAYER and targettype == MapObjectType.PLAYER then
        --描述：
        --type 1：need无效   2：need=职业  3：need=技能名称
        --pct 1=计算百分比  0=计算固定值
        --add=增加伤害的属性英文名 del 降低伤害的属性英文名
        local tab = {
            -- 500	技能伤害增加	技能伤害绝对值	jinengshanghaizengjiaValue
            -- 502	技能伤害减少	被技能伤害减少绝对值	jinengshanghaijianshaoValue
            { add = "jinengshanghaizengjiaValue", del = "jinengshanghaijianshaoValue", type = 1, need = "", pct = 0 },
            -- 501	技能伤害加成	技能伤害万分比	jinengshanghaijiachengRate
            -- 503	技能伤害减免	被技能伤害减免万分比	jinengshanghaijianmianRate
            { add = "jinengshanghaijiachengRate", del = "jinengshanghaijianmianRate", type = 1, need = "", pct = 1 },



            -- 504	剑士技能伤害增加	剑士技能伤害绝对值	jianshijinengshanghaizengjiaValue
            -- 506	剑士技能伤害减少	被剑士技能伤害减少绝对值	jianshijinengshanghaijianshaoValue
            { add = "jianshijinengshanghaizengjiaValue", del = "jianshijinengshanghaijianshaoValue", type = 2, need = 1, pct = 0 },
            -- 508	法师技能伤害增加	法师技能伤害绝对值	fashijinengshanghaizengjiaValue
            -- 510	法师技能伤害减少	被法师技能伤害减少绝对值	fashijinengshanghaijianshaoValue
            { add = "fashijinengshanghaizengjiaValue", del = "fashijinengshanghaijianshaoValue", type = 2, need = 2, pct = 0 },
            -- 512	弓箭手技能伤害增加	弓箭手技能伤害绝对值	gongjianshoujinengshanghaizengjiaValue
            -- 514	弓箭手技能伤害减少	被弓箭手技能伤害减少绝对值	gongjianshoujinengshanghaijianshaoValue
            { add = "gongjianshoujinengshanghaizengjiaValue", del = "gongjianshoujinengshanghaijianshaoValue", type = 2, need = 3, pct = 0 },
            -- 516	魔剑士技能伤害增加	魔剑士技能伤害绝对值	mojianshijinengshanghaizengjiaValue
            -- 518	魔剑士技能伤害减少	被魔剑士技能伤害减少绝对值	mojianshijinengshanghaijianshaoValue
            { add = "mojianshijinengshanghaizengjiaValue", del = "mojianshijinengshanghaijianshaoValue", type = 2, need = 4, pct = 0 },
            -- 520	召唤师技能伤害增加	召唤师技能伤害绝对值	zhaohuanshijinengshanghaizengjiaValue
            -- 522	召唤师技能伤害减少	被召唤师技能伤害减少绝对值	zhaohuanshijinengshanghaijianshaoValue
            { add = "zhaohuanshijinengshanghaizengjiaValue", del = "zhaohuanshijinengshanghaijianshaoValue", type = 2, need = 5, pct = 0 },
            -- 524	圣导师技能伤害增加	圣导师技能伤害绝对值	shengdaoshijinengshanghaizengjiaValue
            -- 526	圣导师技能伤害减少	被圣导师技能伤害减少绝对值	shengdaoshijinengshanghaijianshaoValue
            { add = "shengdaoshijinengshanghaizengjiaValue", del = "shengdaoshijinengshanghaijianshaoValue", type = 2, need = 6, pct = 0 },
            -- 505	剑士技能伤害加成	剑士技能伤害万分比	jianshijinengshanghaijiachengRate
            -- 507	剑士技能伤害减免	被剑士技能伤害减免万分比	jianshijinengshanghaijianmianRate
            { add = "jianshijinengshanghaijiachengRate", del = "jianshijinengshanghaijianmianRate", type = 2, need = 1, pct = 1 },
            -- 509	法师技能伤害加成	法师技能伤害万分比	fashijinengshanghaijiachengRate
            -- 511	法师技能伤害减免	被法师技能伤害减免万分比	fashijinengshanghaijianmianRate
            { add = "fashijinengshanghaijiachengRate", del = "fashijinengshanghaijianmianRate", type = 2, need = 2, pct = 1 },
            -- 513	弓箭手技能伤害加成	弓箭手技能伤害万分比	gongjianshoujinengshanghaijiachengRate
            -- 515	弓箭手技能伤害减免	被弓箭手技能伤害减免万分比	gongjianshoujinengshanghaijianmianRate
            { add = "gongjianshoujinengshanghaijiachengRate", del = "gongjianshoujinengshanghaijianmianRate", type = 2, need = 3, pct = 1 },
            -- 517	魔剑士技能伤害加成	魔剑士技能伤害万分比	mojianshijinengshanghaijiachengRate
            -- 519	魔剑士技能伤害减免	被魔剑士技能伤害减免万分比	mojianshijinengshanghaijianmianRate
            { add = "mojianshijinengshanghaijiachengRate", del = "mojianshijinengshanghaijianmianRate", type = 2, need = 4, pct = 1 },
            -- 521	召唤师技能伤害加成	召唤师技能伤害万分比	zhaohuanshijinengshanghaijiachengRate
            -- 523	召唤师技能伤害减免	被召唤师技能伤害减免万分比	zhaohuanshijinengshanghaijianmianRate
            { add = "zhaohuanshijinengshanghaijiachengRate", del = "zhaohuanshijinengshanghaijianmianRate", type = 2, need = 5, pct = 1 },
            -- 525	圣导师技能伤害加成	圣导师技能伤害万分比	shengdaoshijinengshanghaijiachengRate
            -- 527	圣导师技能伤害减免	被圣导师技能伤害减免万分比	shengdaoshijinengshanghaijianmianRate
            { add = "shengdaoshijinengshanghaijiachengRate", del = "shengdaoshijinengshanghaijianmianRate", type = 2, need = 6, pct = 1 },



            -- 528	升龙击伤害增加	升龙击伤害绝对值	shenglongjishanghaizengjiaValue
            -- 530	升龙击伤害减少	被升龙击伤害减少绝对值	shenglongjishanghaijianshaoValue
            { add = "shenglongjishanghaizengjiaValue", del = "shenglongjishanghaijianshaoValue", type = 3, need = "升龙击", pct = 0 },
            -- 529	升龙击伤害加成	升龙击伤害万分比	shenglongjishanghaijiachengRate
            -- 531	升龙击伤害减免	被升龙击伤害减免万分比	shenglongjishanghaijianmianRate
            { add = "shenglongjishanghaijiachengRate", del = "shenglongjishanghaijianmianRate", type = 3, need = "升龙击", pct = 1 },

            -- 532	地裂斩伤害增加	地裂斩伤害绝对值	diliezhanshanghaizengjiaValue
            -- 534	地裂斩伤害减少	被地裂斩伤害减少绝对值	diliezhanshanghaijianshaoValue
            { add = "diliezhanshanghaizengjiaValue", del = "diliezhanshanghaijianshaoValue", type = 3, need = "地裂斩", pct = 0 },
            -- 533	地裂斩伤害加成	地裂斩伤害万分比	diliezhanshanghaijiachengRate
            -- 535	地裂斩伤害减免	被地裂斩伤害减免万分比	diliezhanshanghaijianmianRate
            { add = "diliezhanshanghaijiachengRate", del = "diliezhanshanghaijianmianRate", type = 3, need = "地裂斩", pct = 1 },

            -- 536	旋风斩伤害增加	旋风斩伤害绝对值	xuanfengzhanshanghaizengjiaValue
            -- 538	旋风斩伤害减少	被旋风斩伤害减少绝对值	xuanfengzhanshanghaijianshaoValue
            { add = "xuanfengzhanshanghaizengjiaValue", del = "xuanfengzhanshanghaijianshaoValue", type = 3, need = "旋风斩", pct = 0 },
            -- 537	旋风斩伤害加成	旋风斩伤害万分比	xuanfengzhanshanghaijiachengRate
            -- 539	旋风斩伤害减免	被旋风斩伤害减免万分比	xuanfengzhanshanghaijianmianRate
            { add = "xuanfengzhanshanghaijiachengRate", del = "xuanfengzhanshanghaijianmianRate", type = 3, need = "旋风斩", pct = 1 },

            -- 540	牙突刺伤害增加	牙突刺伤害绝对值	yatucishanghaizengjiaValue
            -- 542	牙突刺伤害减少	被牙突刺伤害减少绝对值	yatucishanghaijianshaoValue
            { add = "yatucishanghaizengjiaValue", del = "yatucishanghaijianshaoValue", type = 3, need = "牙突刺", pct = 0 },
            -- 541	牙突刺伤害加成	牙突刺伤害万分比	yatucishanghaijiachengRate
            -- 543	牙突刺伤害减免	被牙突刺伤害减免万分比	yatucishanghaijianmianRate
            { add = "yatucishanghaijiachengRate", del = "yatucishanghaijianmianRate", type = 3, need = "牙突刺", pct = 1 },

            -- 544	天地十字剑伤害增加	天地十字剑伤害绝对值	tiandishizijianshanghaizengjiaValue
            -- 546	天地十字剑伤害减少	被天地十字剑伤害减少绝对值	tiandishizijianshanghaijianshaoValue
            { add = "tiandishizijianshanghaizengjiaValue", del = "tiandishizijianshanghaijianshaoValue", type = 3, need = "天地十字剑", pct = 0 },
            -- 545	天地十字剑伤害加成	天地十字剑伤害万分比	tiandishizijianshanghaijiachengRate
            -- 547	天地十字剑伤害减免	被天地十字剑伤害减免万分比	tiandishizijianshanghaijianmianRate
            { add = "tiandishizijianshanghaijiachengRate", del = "tiandishizijianshanghaijianmianRate", type = 3, need = "天地十字剑", pct = 1 },

            -- 548	霹雳回旋斩伤害增加	霹雳回旋斩伤害绝对值	pilihuixuanzhanshanghaizengjiaValue
            -- 550	霹雳回旋斩伤害减少	被霹雳回旋斩伤害减少绝对值	pilihuixuanzhanshanghaijianshaoValue
            { add = "pilihuixuanzhanshanghaizengjiaValue", del = "pilihuixuanzhanshanghaijianshaoValue", type = 3, need = "霹雳回旋斩", pct = 0 },

            -- 549	霹雳回旋斩伤害加成	霹雳回旋斩伤害万分比	pilihuixuanzhanshanghaijiachengRate
            -- 551	霹雳回旋斩伤害减免	被霹雳回旋斩伤害减免万分比	pilihuixuanzhanshanghaijianmianRate
            { add = "pilihuixuanzhanshanghaijiachengRate", del = "pilihuixuanzhanshanghaijianmianRate", type = 3, need = "霹雳回旋斩", pct = 1 },

            -- 552	袭风刺伤害增加	袭风刺伤害绝对值	xifengcishanghaizengjiaValue
            -- 554	袭风刺伤害减少	被袭风刺伤害减少绝对值	xifengcishanghaijianshaoValue
            { add = "xifengcishanghaizengjiaValue", del = "xifengcishanghaijianshaoValue", type = 3, need = "袭风刺", pct = 0 },

            -- 553	袭风刺伤害加成	袭风刺伤害万分比	xifengcishanghaijiachengRate
            -- 555	袭风刺伤害减免	被袭风刺伤害减免万分比	xifengcishanghaijianmianRate
            { add = "xifengcishanghaijiachengRate", del = "xifengcishanghaijianmianRate", type = 3, need = "袭风刺", pct = 1 },

            -- 556	雷霆裂闪伤害增加	雷霆裂闪伤害绝对值	leitinglieshanshanghaizengjiaValue
            -- 558	雷霆裂闪伤害减少	被雷霆裂闪伤害减少绝对值	leitinglieshanshanghaijianshaoValue
            { add = "leitinglieshanshanghaizengjiaValue", del = "leitinglieshanshanghaijianshaoValue", type = 3, need = "雷霆裂闪", pct = 0 },
            -- 557	雷霆裂闪伤害加成	雷霆裂闪伤害万分比	leitinglieshanshanghaijiachengRate
            -- 559	雷霆裂闪伤害减免	被雷霆裂闪伤害减免万分比	leitinglieshanshanghaijianmianRate
            { add = "leitinglieshanshanghaijiachengRate", del = "leitinglieshanshanghaijianmianRate", type = 3, need = "雷霆裂闪", pct = 1 },

            -- 560	致命一击伤害增加	致命一击伤害绝对值	zhimingyijishanghaizengjiaValue
            -- 562	致命一击伤害减少	被致命一击伤害减少绝对值	zhimingyijishanghaijianshaoValue
            { add = "zhimingyijishanghaizengjiaValue", del = "zhimingyijishanghaijianshaoValue", type = 3, need = "致命一击", pct = 0 },
            -- 561	致命一击伤害加成	致命一击伤害万分比	zhimingyijishanghaijiachengRate
            -- 563	致命一击伤害减免	被致命一击伤害减免万分比	zhimingyijishanghaijianmianRate
            { add = "zhimingyijishanghaijiachengRate", del = "zhimingyijishanghaijianmianRate", type = 3, need = "致命一击", pct = 1 },

            -- 564	山崩地裂伤害增加	山崩地裂伤害绝对值	shanbengdilieshanghaizengjiaValue
            -- 566	山崩地裂伤害减少	被山崩地裂伤害减少绝对值	shanbengdilieshanghaijianshaoValue
            { add = "shanbengdilieshanghaizengjiaValue", del = "shanbengdilieshanghaijianshaoValue", type = 3, need = "山崩地裂", pct = 0 },

            -- 565	山崩地裂伤害加成	山崩地裂伤害万分比	shanbengdilieshanghaijiachengRate
            -- 567	山崩地裂伤害减免	被山崩地裂伤害减免万分比	shanbengdilieshanghaijianmianRate
            { add = "shanbengdilieshanghaijiachengRate", del = "shanbengdilieshanghaijianmianRate", type = 3, need = "山崩地裂", pct = 1 },

            -- 568	能量球伤害增加	能量球伤害绝对值	nengliangqiushanghaizengjiaValue
            -- 570	能量球伤害减少	被能量球伤害减少绝对值	nengliangqiushanghaijianshaoValue
            { add = "nengliangqiushanghaizengjiaValue", del = "nengliangqiushanghaijianshaoValue", type = 3, need = "能量球", pct = 0 },
            -- 569	能量球伤害加成	能量球伤害万分比	nengliangqiushanghaijiachengRate
            -- 571	能量球伤害减免	被能量球伤害减免万分比	nengliangqiushanghaijianmianRate
            { add = "nengliangqiushanghaijiachengRate", del = "nengliangqiushanghaijianmianRate", type = 3, need = "能量球", pct = 1 },


            -- 572	火球伤害增加	火球伤害绝对值	huoqiushanghaizengjiaValue
            -- 574	火球伤害减少	被火球伤害减少绝对值	huoqiushanghaijianshaoValue
            { add = "huoqiushanghaizengjiaValue", del = "huoqiushanghaijianshaoValue", type = 3, need = "火球", pct = 0 },
            -- 573	火球伤害加成	火球伤害万分比	huoqiushanghaijiachengRate
            -- 575	火球伤害减免	被火球伤害减免万分比	huoqiushanghaijianmianRate
            { add = "huoqiushanghaijiachengRate", del = "huoqiushanghaijianmianRate", type = 3, need = "火球", pct = 1 },

            -- 576	真空波伤害增加	真空波伤害绝对值	zhenkongboshanghaizengjiaValue
            -- 578	真空波伤害减少	被真空波伤害减少绝对值	zhenkongboshanghaijianshaoValue
            { add = "zhenkongboshanghaizengjiaValue", del = "zhenkongboshanghaijianshaoValue", type = 3, need = "真空波", pct = 0 },

            -- 577	真空波伤害加成	真空波伤害万分比	zhenkongboshanghaijiachengRate
            -- 579	真空波伤害减免	被真空波伤害减免万分比	zhenkongboshanghaijianmianRate
            { add = "zhenkongboshanghaijiachengRate", del = "zhenkongboshanghaijianmianRate", type = 3, need = "真空波", pct = 1 },

            -- 580	掌心雷伤害增加	掌心雷伤害绝对值	zhangxinleishanghaizengjiaValue
            -- 582	掌心雷伤害减少	被掌心雷伤害减少绝对值	zhangxinleishanghaijianshaoValue
            { add = "zhangxinleishanghaizengjiaValue", del = "zhangxinleishanghaijianshaoValue", type = 3, need = "掌心雷", pct = 0 },
            -- 581	掌心雷伤害加成	掌心雷伤害万分比	zhangxinleishanghaijiachengRate
            -- 583	掌心雷伤害减免	被掌心雷伤害减免万分比	zhangxinleishanghaijianmianRate
            { add = "zhangxinleishanghaijiachengRate", del = "zhangxinleishanghaijianmianRate", type = 3, need = "掌心雷", pct = 1 },

            -- 584	龙卷风伤害增加	龙卷风伤害绝对值	longjuanfengshanghaizengjiaValue
            -- 586	龙卷风伤害减少	被龙卷风伤害减少绝对值	longjuanfengshanghaijianshaoValue
            { add = "longjuanfengshanghaizengjiaValue", del = "longjuanfengshanghaijianshaoValue", type = 3, need = "龙卷风", pct = 0 },
            -- 585	龙卷风伤害加成	龙卷风伤害万分比	longjuanfengshanghaijiachengRate
            -- 587	龙卷风伤害减免	被龙卷风伤害减免万分比	longjuanfengshanghaijianmianRate
            { add = "longjuanfengshanghaijiachengRate", del = "longjuanfengshanghaijianmianRate", type = 3, need = "龙卷风", pct = 1 },

            -- 588	陨石伤害增加	陨石伤害绝对值	yunshishanghaizengjiaValue
            -- 590	陨石伤害减少	被陨石伤害减少绝对值	yunshishanghaijianshaoValue
            { add = "yunshishanghaizengjiaValue", del = "yunshishanghaijianshaoValue", type = 3, need = "陨石", pct = 0 },
            -- 589	陨石伤害加成	陨石伤害万分比	yunshishanghaijiachengRate
            -- 591	陨石伤害减免	被陨石伤害减免万分比	yunshishanghaijianmianRate
            { add = "yunshishanghaijiachengRate", del = "yunshishanghaijianmianRate", type = 3, need = "陨石", pct = 1 },

            -- 592	火龙伤害增加	火龙伤害绝对值	huolongshanghaizengjiaValue
            -- 594	火龙伤害减少	被火龙伤害减少绝对值	huolongshanghaijianshaoValue
            { add = "huolongshanghaizengjiaValue", del = "huolongshanghaijianshaoValue", type = 3, need = "火龙", pct = 0 },
            -- 593	火龙伤害加成	火龙伤害万分比	huolongshanghaijiachengRate
            -- 595	火龙伤害减免	被火龙伤害减免万分比	huolongshanghaijianmianRate
            { add = "huolongshanghaijiachengRate", del = "huolongshanghaijianmianRate", type = 3, need = "火龙", pct = 1 },

            -- 596	黑龙波伤害增加	黑龙波伤害绝对值	heilongboshanghaizengjiaValue
            -- 598	黑龙波伤害减少	被黑龙波伤害减少绝对值	heilongboshanghaijianshaoValue
            { add = "heilongboshanghaizengjiaValue", del = "heilongboshanghaijianshaoValue", type = 3, need = "黑龙波", pct = 0 },
            -- 597	黑龙波伤害加成	黑龙波伤害万分比	heilongboshanghaijiachengRate
            -- 599	黑龙波伤害减免	被黑龙波伤害减免万分比	heilongboshanghaijianmianRate
            { add = "heilongboshanghaijiachengRate", del = "heilongboshanghaijianmianRate", type = 3, need = "黑龙波", pct = 1 },

            -- 600	毁灭烈焰伤害增加	毁灭烈焰伤害绝对值	huimielieyanshanghaizengjiaValue
            -- 602	毁灭烈焰伤害减少	被毁灭烈焰伤害减少绝对值	huimielieyanshanghaijianshaoValue
            { add = "huimielieyanshanghaizengjiaValue", del = "huimielieyanshanghaijianshaoValue", type = 3, need = "毁灭烈焰", pct = 0 },
            -- 601	毁灭烈焰伤害加成	毁灭烈焰伤害万分比	huimielieyanshanghaijiachengRate
            -- 603	毁灭烈焰伤害减免	被毁灭烈焰伤害减免万分比	huimielieyanshanghaijianmianRate
            { add = "huimielieyanshanghaijiachengRate", del = "huimielieyanshanghaijianmianRate", type = 3, need = "毁灭烈焰", pct = 1 },

            -- 604	暴风雪术伤害增加	暴风雪术伤害绝对值	baofengxueshushanghaizengjiaValue
            -- 606	暴风雪术伤害减少	被暴风雪术伤害减少绝对值	baofengxueshushanghaijianshaoValue
            { add = "baofengxueshushanghaizengjiaValue", del = "baofengxueshushanghaijianshaoValue", type = 3, need = "暴风雪术", pct = 0 },
            -- 605	暴风雪术伤害加成	暴风雪术伤害万分比	baofengxueshushanghaijiachengRate
            -- 607	暴风雪术伤害减免	被暴风雪术伤害减免万分比	baofengxueshushanghaijianmianRate
            { add = "baofengxueshushanghaijiachengRate", del = "baofengxueshushanghaijianmianRate", type = 3, need = "暴风雪术", pct = 1 },

            -- 608	地狱火伤害增加	地狱火伤害绝对值	diyuhuoshanghaizengjiaValue
            -- 610	地狱火伤害减少	被地狱火伤害减少绝对值	diyuhuoshanghaijianshaoValue
            { add = "diyuhuoshanghaizengjiaValue", del = "diyuhuoshanghaijianshaoValue", type = 3, need = "地狱火", pct = 0 },
            -- 609	地狱火伤害加成	地狱火伤害万分比	diyuhuoshanghaijiachengRate
            -- 611	地狱火伤害减免	被地狱火伤害减免万分比	diyuhuoshanghaijianmianRate
            { add = "diyuhuoshanghaijiachengRate", del = "diyuhuoshanghaijianmianRate", type = 3, need = "地狱火", pct = 1 },

            -- 612	爆炎伤害增加	爆炎伤害绝对值	baoyanshanghaizengjiaValue
            -- 614	爆炎伤害减少	被爆炎伤害减少绝对值	baoyanshanghaijianshaoValue
            { add = "baoyanshanghaizengjiaValue", del = "baoyanshanghaijianshaoValue", type = 3, need = "爆炎", pct = 0 },
            -- 613	爆炎伤害加成	爆炎伤害万分比	baoyanshanghaijiachengRate
            -- 615	爆炎伤害减免	被爆炎伤害减免万分比	baoyanshanghaijianmianRate
            { add = "baoyanshanghaijiachengRate", del = "baoyanshanghaijianmianRate", type = 3, need = "爆炎", pct = 1 },

            -- 616	冰封伤害增加	冰封伤害绝对值	bingfengshanghaizengjiaValue
            -- 618	冰封伤害减少	被冰封伤害减少绝对值	bingfengshanghaijianshaoValue
            { add = "bingfengshanghaizengjiaValue", del = "bingfengshanghaijianshaoValue", type = 3, need = "冰封", pct = 0 },
            -- 617	冰封伤害加成	冰封伤害万分比	bingfengshanghaijiachengRate
            -- 619	冰封伤害减免	被冰封伤害减免万分比	bingfengshanghaijianmianRate
            { add = "bingfengshanghaijiachengRate", del = "bingfengshanghaijianmianRate", type = 3, need = "冰封", pct = 1 },

            -- 620	毒咒伤害增加	毒咒伤害绝对值	duzhoushanghaizengjiaValue
            -- 622	毒咒伤害减少	被毒咒伤害减少绝对值	duzhoushanghaijianshaoValue
            { add = "duzhoushanghaizengjiaValue", del = "duzhoushanghaijianshaoValue", type = 3, need = "毒咒", pct = 0 },
            -- 621	毒咒伤害加成	毒咒伤害万分比	duzhoushanghaijiachengRate
            -- 623	毒咒伤害减免	被毒咒伤害减免万分比	duzhoushanghaijianmianRate
            { add = "duzhoushanghaijiachengRate", del = "duzhoushanghaijianmianRate", type = 3, need = "毒咒", pct = 1 },

            -- 624	极光伤害增加	极光伤害绝对值	jiguangshanghaizengjiaValue
            -- 626	极光伤害减少	被极光伤害减少绝对值	jiguangshanghaijianshaoValue
            { add = "jiguangshanghaizengjiaValue", del = "jiguangshanghaizengjiaValue", type = 3, need = "极光", pct = 0 },

            -- 625	极光伤害加成	极光伤害万分比	jiguangshanghaijiachengRate
            -- 627	极光伤害减免	被极光伤害减免万分比	jiguangshanghaijianmianRate
            { add = "jiguangshanghaijiachengRate", del = "jiguangshanghaijianmianRate", type = 3, need = "极光", pct = 1 },

            -- 628	穿透箭伤害增加	穿透箭伤害绝对值	chuantoujianshanghaizengjiaValue
            -- 630	穿透箭伤害减少	被穿透箭伤害减少绝对值	chuantoujianshanghaijianshaoValue
            { add = "chuantoujianshanghaizengjiaValue", del = "chuantoujianshanghaijianshaoValue", type = 3, need = "穿透箭", pct = 0 },
            -- 629	穿透箭伤害加成	穿透箭伤害万分比	chuantoujianshanghaijiachengRate
            -- 631	穿透箭伤害减免	被穿透箭伤害减免万分比	chuantoujianshanghaijianmianRate
            { add = "chuantoujianshanghaijiachengRate", del = "chuantoujianshanghaijianmianRate", type = 3, need = "穿透箭", pct = 1 },

            -- 632	多重箭伤害增加	多重箭伤害绝对值	duochongjianshanghaizengjiaValue
            -- 634	多重箭伤害减少	被多重箭伤害减少绝对值	duochongjianshanghaijianshaoValue
            { add = "duochongjianshanghaizengjiaValue", del = "duochongjianshanghaijianshaoValue", type = 3, need = "多重箭", pct = 0 },
            -- 633	多重箭伤害加成	多重箭伤害万分比	duochongjianshanghaijiachengRate
            -- 635	多重箭伤害减免	被多重箭伤害减免万分比	duochongjianshanghaijianmianRate
            { add = "duochongjianshanghaijiachengRate", del = "duochongjianshanghaijianmianRate", type = 3, need = "多重箭", pct = 1 },

            -- 636	冰封箭伤害增加	冰封箭伤害绝对值	bingfengjianshanghaizengjiaValue
            -- 638	冰封箭伤害减少	被冰封箭伤害减少绝对值	bingfengjianshanghaijianshaoValue
            { add = "bingfengjianshanghaizengjiaValue", del = "bingfengjianshanghaijianshaoValue", type = 3, need = "冰封箭", pct = 0 },
            -- 637	冰封箭伤害加成	冰封箭伤害万分比	bingfengjianshanghaijiachengRate
            -- 639	冰封箭伤害减免	被冰封箭伤害减免万分比	bingfengjianshanghaijianmianRate
            { add = "bingfengjianshanghaijiachengRate", del = "bingfengjianshanghaijianmianRate", type = 3, need = "冰封箭", pct = 1 },

            -- 640	五重箭伤害增加	五重箭伤害绝对值	wuchongjianshanghaizengjiaValue
            -- 642	五重箭伤害减少	被五重箭伤害减少绝对值	wuchongjianshanghaijianshaoValue
            { add = "wuchongjianshanghaizengjiaValue", del = "wuchongjianshanghaijianshaoValue", type = 3, need = "五重箭", pct = 0 },
            -- 641	五重箭伤害加成	五重箭伤害万分比	wuchongjianshanghaijiachengRate
            -- 643	五重箭伤害减免	被五重箭伤害减免万分比	wuchongjianshanghaijianmianRate
            { add = "wuchongjianshanghaijiachengRate", del = "wuchongjianshanghaijianmianRate", type = 3, need = "五重箭", pct = 1 },



        }
        local casterCareer = getbaseinfo(caster, "getbasecareer")
        local targerCareer = getbaseinfo(target, "getbasecareer")

        local name = paramMap.CfgData.name


        for i = 1, #tab do
            local type = tab[i].type
            local need = tab[i].need
            local pct = tab[i].pct
            local add = 0
            local del = 0
            if type == 1 then
                add = getattrinfo(caster, tab[i].add)
                del = getattrinfo(target, tab[i].del)
            elseif type == 2 then
                if targerCareer == need then
                    add = getattrinfo(caster, tab[i].add)
                end
                if casterCareer == need then
                    del = getattrinfo(target, tab[i].del)
                end
            elseif type == 3 then
                if name ~= "" then
                    if string.find(name, need) then
                        add = getattrinfo(caster, tab[i].add)
                        del = getattrinfo(target, tab[i].del)
                    end
                end
            end


            if pct == 0 then
                SkillDamageValue = SkillDamageValue + math.max(0, add - del)
            else
                SkillDamageRate = SkillDamageRate + math.max(0, add - del)
            end
        end
        -- 160	PVP伤害吸收	计算伤害3	absorbDamageToPlayers
        local absorbDamageToPlayers = getattrinfo(target, "absorbDamageToPlayers")
        if absorbDamageToPlayers > 0 then
            SkillDamageRate = math.max(0, SkillDamageRate - absorbDamageToPlayers)
        end
    end

    return SkillDamageValue, SkillDamageRate
end

function fightlog(desc)
    table.insert(FightLog, desc .. "\n")
end

-- 服务器启动调用，缓存表数据
function this.Cache()
    local normalCache = {}
    local elementalCache = {}
    local tableList = ConfigDataManager.getList("cfg_damage_number")
    for index, valueMap in ipairs(tableList) do
        local id = valueMap["id"]
        local attributeA = valueMap["attributea"]
        local attributeB = valueMap["attributeb"]
        local attributeC = valueMap["attributec"]
        local attributeD = valueMap["attributed"]
        local attributeE = valueMap["attributee"]
        local keyString = attributeA .. attributeB .. attributeC .. attributeD .. attributeE
        if string.contains(keyString, "1") then
            if normalCache[keyString] ~= nil then
                gameDebug.assertPrint(false, "cfg_damage_number缓存战斗飘字类型重复,id:" .. id .. ";key:" .. keyString)
            end
            normalCache[keyString] = id
        end
        -- 元素伤害
        local attributeF = valueMap["attributef"]
        local attributeG = valueMap["attributeg"]
        local attributeH = valueMap["attributeh"]
        local attributeI = valueMap["attributei"]
        local elementalKey = attributeF .. attributeG .. attributeH .. attributeI
        if string.contains(elementalKey, "1") then
            if elementalCache[elementalKey] ~= nil then
                gameDebug.assertPrint(false, "cfg_damage_number缓存元素战斗飘字类型重复,id:" .. ";key:" .. elementalKey)
            end
            elementalCache[elementalKey] = id
        end
    end
    setsysvar(SystemVarConst.NORMAL_DAMAGE_TYPE_CACHE, normalCache)
    setsysvar(SystemVarConst.ELEMENTAL_DAMAGE_TYPE_CACHE, elementalCache)
end

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

function this.DamageCalculate(paramMap)
    local minAtt, maxAtt = this.getMaxAndMinDamage(paramMap) -- 最大\最小攻击力
    fightlog("-----------------------基础攻击力: " .. minAtt .. "~" .. maxAtt .. "-----------------------")

    -- 配置技能攻击力
    local peizhiSkillDamage = this.getPeiZhiSkillDamage(paramMap)
    minAtt = minAtt + peizhiSkillDamage
    maxAtt = maxAtt + peizhiSkillDamage

    -- 技能攻击力
    local skillDamage = this.getSkillDamage(paramMap)
    minAtt = minAtt + skillDamage
    maxAtt = maxAtt + skillDamage

    -- 攻击力加成
    local damageRate = this.getDamageRate(paramMap)
    minAtt = minAtt + damageRate
    maxAtt = maxAtt + damageRate

    -- 攻击力加成Buff
    local damageRate = this.getDamageBuff(paramMap)
    minAtt = minAtt + damageRate
    maxAtt = maxAtt + damageRate

    local damage = 0
    local hurtTypeTable = { 0, 0, 0, 0, 0 }
    -- 幸运一击
    if this.isLuckyAttack(paramMap) == true then
        damage = this.luckyAttackDamage(paramMap, maxAtt)
        hurtTypeTable[3] = 1
    else
        damage = math.random(math.ceil(minAtt), math.ceil(maxAtt))
    end
    fightlog("----------------------计算伤害: " .. damage .. "-----------------------")
    fightlog("----------------------计算伤害: " .. damage .. "-----------------------")
    -- 双倍伤害
    local isDouble = this.isDoubleAttack(paramMap)
    if isDouble == true then
        hurtTypeTable[5] = 1
    end

    --无视防御
    if this.isUnMissAttack(paramMap) == false then
        damage = this.unMissAttackDamage(paramMap, damage, false, isDouble)
    else
        damage = this.unMissAttackDamage(paramMap, damage, true, isDouble)
        hurtTypeTable[4] = 1
    end

    --翅膀 坐骑 buff
    damage = this.petAndMountAttackDamage(paramMap, damage)
    --减伤
    damage = this.delAttackDamage(paramMap, damage)
    --盾牌
    damage = this.shieldAttackDamage(paramMap, damage)
    --吸收
    damage = this.reductionAttackDamage(paramMap, damage)
    --真实伤害
    damage = this.realAttackDamage(paramMap, damage)

    -- 卓越一击
    if this.isExcellentAttack(paramMap) == true then
        damage = this.excellentAttackDamage(paramMap, damage)
        hurtTypeTable[2] = 1
    end

    --怪物保底伤害
    local castertype = getbaseinfo(paramMap.caster, "mapobjecttype")
    if castertype == MapObjectType.MONSTER then
        local monInfo = getmonsterinfo(paramMap.caster)
        local monsterConfig = monInfo.cfgid
        local guaranteedDamage = ConfigDataManager.getTableValue("cfg_monster", "guaranteedDamage", "id", monsterConfig)
        if string.isNullOrEmpty(guaranteedDamage) then
            guaranteedDamage = "0"
        end
        damage = math.max(tonumber(guaranteedDamage) or 0, damage)
    end

    --怪物最大伤害
    local targettype = getbaseinfo(paramMap.target, "mapobjecttype")
    if targettype == MapObjectType.MONSTER then
        local monInfo = getmonsterinfo(paramMap.target)
        local monsterConfig = monInfo.cfgid
        local MaxDamage = ConfigDataManager.getTableValue("cfg_monster", "MaxDamage", "id", monsterConfig)
        if not string.isNullOrEmpty(MaxDamage) then
            damage = math.min(tonumber(MaxDamage) or 0, damage)
        end
    end

    -- 伤害字体
    local typeString = ""
    for _, value in pairs(hurtTypeTable) do
        typeString = typeString .. value
    end
    local hurtTypeCache = getsysvar(SystemVarConst.NORMAL_DAMAGE_TYPE_CACHE, 0)
    local type = hurtTypeCache[typeString] or 101

    fightlog("-----------------------计算伤害: " .. damage .. "-----------------------")
    return damage, type
end

-- 获取最大最小攻击力
function this.getMaxAndMinDamage(paramMap)
    local skillId = paramMap.skillid
    local skillLevel = paramMap.skilllevel
    local skillInfo = ConfigDataManager.getById("cfg_skill", skillId)
    if not next(skillInfo) then
        return 0, 0
    end

    local powerSource = string.isNullOrEmpty(skillInfo.powersource) and 0 or tonumber(skillInfo.powersource)
    local caster = paramMap.caster --—— 攻击对象
    local petid = getbaseinfo(caster, "configid")
    if petid == 60000612 then
        local min = this.getAttValueWithName(caster, "skyhawksMinimumAttackPower") 
        local max = this.getAttValueWithName(caster, "skyhawksMaximumAttackPower")
        return min, max
    end
    if powerSource == 1 then
        return this.getAttValueWithName(caster, "minDC"), this.getAttValueWithName(caster, "maxDC")
    end
    if powerSource == 2 then
        return this.getAttValueWithName(caster, "minMC"), this.getAttValueWithName(caster, "maxMC")
    end
    if powerSource == 3 then
        local min = this.getAttValueWithName(caster, "minimumCurseAttackPower") +
            this.getAttValueWithName(caster, "minMC")
        local max = this.getAttValueWithName(caster, "maximumCurseAttackPower") +
            this.getAttValueWithName(caster, "maxMC")
        return min, max
    end

    local maxDC = this.getAttValueWithName(caster, "maxDC")
    local maxMC = this.getAttValueWithName(caster, "maxMC")
    local maxCurDC = this.getAttValueWithName(caster, "maximumCurseAttackPower")
    if maxDC >= maxMC and maxDC >= maxCurDC then
        return this.getAttValueWithName(caster, "minDC"), maxDC
    elseif maxMC >= maxDC and maxMC >= maxCurDC then
        return this.getAttValueWithName(caster, "minMC"), maxMC
    elseif maxCurDC >= maxDC and maxCurDC >= maxMC then
        return this.getAttValueWithName(caster, "minimumCurseAttackPower"), maxCurDC
    end

    return 0, 0
end

-- 获取配置技能的攻击力
function this.getPeiZhiSkillDamage(paramMap)
    local caster = paramMap.caster --—— 攻击对象

    local skillPower = tonumber(paramMap.CfgData.skillpower) or 0
    local skillattpower = paramMap.CfgData.skillattpower  
    
    if not string.isNullOrEmpty(skillattpower) then
        local caster = paramMap.caster --—— 攻击对象
        local attInfos = string.putIntIntMap({}, skillattpower, "#", "|")
        for key, value in pairs(attInfos) do
            local currentValue = this.getAttValueWithId(caster, key)
            skillPower = skillPower + math.ceil(currentValue / value)
        end
    end

    -- local skillDamage = this.getAttValueWithName(caster, "skillDamage")
    -- skillPower = skillPower * (1 + skillDamage)  

    fightlog("-----------------------配置技能攻击力: " .. skillPower .. "-----------------------")
    return skillPower
end

-- 获取技能的攻击力
function this.getSkillDamage(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local isPVP = this.getIsPVP(paramMap)

    local damage = this.getAttValueWithName(caster, "skillDamageAdd")
    if isPVP == true then
        damage = damage + this.getAttValueWithName(caster, "pvpskillattackadd")
    else
        damage = damage + this.getAttValueWithName(caster, "skillDamageAdd")
    end

    fightlog("-----------------------技能攻击力: " .. damage .. "-----------------------")
    return damage
end

-- 是否是PVP
function this.getIsPVP(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象

    local castertype = getbaseinfo(caster, "mapobjecttype")
    local targettype = getbaseinfo(target, "mapobjecttype")

    local isPVP = true
    if castertype == MapObjectType.MONSTER or targettype == MapObjectType.MONSTER then
        isPVP = false
    end
    return isPVP
end

-- 获取攻击力加成
function this.getDamageRate(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local isPVP = this.getIsPVP(paramMap)

    local AtkUpPercent = this.getAttValueWithName(caster, "AtkUpPercent")
    if isPVP == true then
        AtkUpPercent = AtkUpPercent + this.getAttValueWithName(caster, "pvpattackadd")
    else
        AtkUpPercent = AtkUpPercent + this.getAttValueWithName(caster, "pveattackadd")
    end
    fightlog("-----------------------攻击力加成: " .. AtkUpPercent .. "-----------------------")
    return AtkUpPercent
end

-- 获取攻击力加成Buff
function this.getDamageBuff(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local AtkUpPercent = this.getAttValueWithName(caster, "AtkUpBuff")
    return AtkUpPercent
end

-- 是否触发幸运一击
function this.isLuckyAttack(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象

    local criticalDamageChance = this.getAttValueWithName(caster, "criticalDamageChance")
    local criticalDamageResistanceChance = this.getAttValueWithName(target, "criticalDamageResistanceChance")
    local probability = criticalDamageChance * (1 - criticalDamageResistanceChance)
    local result = this.RandomResult(probability)
    fightlog("-----------------------是否触发幸运一击: " .. (result == true and 1 or 0) .. "-----------------------")
    return result
end

-- 幸运一击的攻击力
function this.luckyAttackDamage(paramMap, maxAtt)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local criticalDamageAdd = this.getAttValueWithName(caster, "criticalDamageAdd")
    local criticalDamageReduce = this.getAttValueWithName(target, "criticalDamageReduce")
    local criticalDamageBonus = this.getAttValueWithName(caster, "criticalDamageBonus")
    local criticalDamageReducationBonus = this.getAttValueWithName(target, "criticalDamageReducationBonus")
    local result = (maxAtt + criticalDamageAdd - criticalDamageReduce) *
        (1 + criticalDamageBonus - criticalDamageReducationBonus)
    fightlog("-----------------------幸运一击伤害: " .. result .. "-----------------------")
    return result
end

-- 是否触发卓越一击
function this.isExcellentAttack(paramMap)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象

    local excellentDamageChance = this.getAttValueWithName(caster, "excellentDamageChance")
    local excellentDamageResistanceChance = this.getAttValueWithName(target, "excellentDamageResistanceChance")
    local probability = excellentDamageChance * (1 - excellentDamageResistanceChance)
    local result = this.RandomResult(probability)
    fightlog("-----------------------是否触发卓越一击: " .. (result == true and 1 or 0) .. "-----------------------")
    return result
end

-- 卓越一击的攻击力
function this.excellentAttackDamage(paramMap, damage)

    local excellentRate = (tonumber(paramMap.CfgData.excellentrate) or 0) / 10000

    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local excellentDamageAdd = this.getAttValueWithName(caster, "excellentDamageAdd")
    local excellentDamageReduce = this.getAttValueWithName(target, "excellentDamageReduce")
    local excellentDamageBonus = this.getAttValueWithName(caster, "excellentDamageBonus")
    local excellentDamageReducationBonus = this.getAttValueWithName(target, "excellentDamageReducationBonus")
    local result = (damage + excellentDamageAdd - excellentDamageReduce) *
        (1 + excellentDamageBonus + excellentRate - excellentDamageReducationBonus)
    fightlog("-----------------------卓越一击伤害: " .. result .. "-----------------------")
    return result
end

-- 是否触发双倍伤害
function this.isDoubleAttack(paramMap)
    local caster = paramMap.caster
    local target = paramMap.target
    local doubleDamageChance = this.getAttValueWithName(caster, "doubleDamageChance")
    local doubleDamageResistanceChance = this.getAttValueWithName(target, "doubleDamageResistanceChance")
    local probability = doubleDamageChance * (1 - doubleDamageResistanceChance)
    local result = this.RandomResult(probability)
    fightlog("-----------------------是否触发双倍伤害: " .. (result == true and 1 or 0) .. "-----------------------")
    return result
end

-- 是否触发无视防御
function this.isUnMissAttack(paramMap)
    local caster = paramMap.caster                                                --—— 攻击对象
    local target = paramMap.target                                                --—— 受击对象

    local unMissRate = this.getAttValueWithName(caster, "unMissRate")             -- 无视防御的概率， 万分之
    local resistUnMissRate = this.getAttValueWithName(target, "resistUnMissRate") -- 抵抗无视防御几率 万分之
    local probability = unMissRate * (1 - resistUnMissRate)
    local result = this.RandomResult(probability)
    fightlog("-----------------------是否触发无视防御: " .. (result == true and 1 or 0) .. "-----------------------")
    return result
end

-- 无视防御的攻击力
function this.unMissAttackDamage(paramMap, damage, isUnMiss, isDouble)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local ignoringIncreasedDefenseDamage = this.getAttValueWithName(caster, "ignoringIncreasedDefenseDamage")
    local result = damage + ignoringIncreasedDefenseDamage

    local isPVP = this.getIsPVP(paramMap)
    if isPVP == true then
        result = result + this.getAttValueWithName(caster, "pvpdamageadda")
    else
        result = result + this.getAttValueWithName(caster, "pveDamageAdd")
    end
    fightlog("-----------------------判定PVP伤害增加后的伤害: " .. result .. "-----------------------")

    if isUnMiss == false then
        result = result - this.getAttValueWithName(target, "armor")
        if isPVP == true then
            result = result - this.getAttValueWithName(caster, "pvparmor")
        else
            result = result - this.getAttValueWithName(caster, "pvearmor")
        end
        fightlog("-----------------------判定防御后的伤害: " .. result .. "-----------------------")
    end

    if result < 0 then
        result = 0
    end

    local powerRate = tonumber(paramMap.CfgData.powerrate) or 0 -- 技能威力 万分之
    local skillDamage = this.getAttValueWithName(caster, "skillDamage")
    result = (powerRate / 10000 + skillDamage) * result
    fightlog("-----------------------判定skill后的伤害: " .. result .. "-----------------------")

    if isDouble == true then
        local doubleDamageBonus = this.getAttValueWithName(caster, "doubleDamageBonus")                     --双倍伤害加成 万分之
        local doubleDamageReducationBonus = this.getAttValueWithName(target, "doubleDamageReducationBonus") -- 双倍伤害减免 万分之
        local doubleDamageAdd = this.getAttValueWithName(caster, "doubleDamageAdd")                         -- 双倍伤害增加 固定数值
        local doubleDamageReduce = this.getAttValueWithName(target, "doubleDamageReduce")                   -- 双倍伤害减少 固定数值
        result = result * (2 + doubleDamageBonus - doubleDamageReducationBonus) + doubleDamageAdd - doubleDamageReduce
        fightlog("-----------------------判定双倍伤害后的伤害: " .. result .. "-----------------------")
    end

    return result
end

-- 翅膀 坐骑 buff
function this.petAndMountAttackDamage(paramMap, damage)
    local caster = paramMap.caster                                                --—— 攻击对象

    local mountdamagebonus = this.getAttValueWithName(caster, "mountdamagebonus") -- 坐骑伤害提升 万分比
    local wingdamagebonus = this.getAttValueWithName(caster, "wingdamagebonus")   -- 翅膀伤害提升 万分比
    local buffdamagebonus = this.getAttValueWithName(caster, "buffdamagebonus")   -- buff伤害提升 万分比
    local damageRate = this.getAttValueWithName(caster, "damageRate")             -- 伤害提升 万分比
    local result = (1 + mountdamagebonus + wingdamagebonus + buffdamagebonus + damageRate) * damage
    fightlog("----------------------判定翅膀、坐骑后的伤害: " .. result .. "-----------------------")
    return result
end

-- 减伤
function this.delAttackDamage(paramMap, damage)
    local caster = paramMap.caster                                                  --—— 攻击对象
    local target = paramMap.target                                                  --—— 受击对象

    local fixedDamageAdd = this.getAttValueWithName(caster, "fixedDamageAdd")       --- 固定伤害增加
    local fixedDamageReduce = this.getAttValueWithName(target, "fixedDamageReduce") --- 固定伤害减少

    local result = damage + fixedDamageAdd - fixedDamageReduce
    if result < 0 then result = 0 end

    local isPVP = this.getIsPVP(paramMap)
    if isPVP == true then
        result = result - this.getAttValueWithName(target, "pvpDamageReduce") --- pvp伤害减少
    else
        result = result - this.getAttValueWithName(caster, "pveDamageReduce") --- pve伤害减少
    end
    if result < 0 then result = 0 end

    local damageRateDecrement = this.getAttValueWithName(target, "damageRateDecrement") --- 伤害减免， 百分比
    result = result * (1 - damageRateDecrement)

    fightlog("----------------------判定减伤后的伤害: " .. result .. "-----------------------")
    return result
end

-- 盾牌
function this.shieldAttackDamage(paramMap, damage)
    local target = paramMap.target                                                  --—— 受击对象
    local shielddamagebonus = this.getAttValueWithName(target, "shielddamagebonus") -- 盾牌减伤 百分比
    local result = (1 - shielddamagebonus) * damage
    fightlog("----------------------判定盾牌减伤后的伤害: " .. result .. "-----------------------")
    return result
end

-- 吸收
function this.reductionAttackDamage(paramMap, damage)
    local target = paramMap.target --—— 受击对象

    local mountdamagereduction = 1 - this.getAttValueWithName(target, "mountdamagereduction")
    local wingdamagereduction = 1 - this.getAttValueWithName(target, "wingdamagereduction")
    local buffdamagereduction = 1 - this.getAttValueWithName(target, "buffdamagereduction")
    local guarddamagereduction = 1 - this.getAttValueWithName(target, "guarddamagereduction")
    local damageAbsorb = 1 - this.getAttValueWithName(target, "damageAbsorb")
    local result = mountdamagereduction * wingdamagereduction * buffdamagereduction * guarddamagereduction * damageAbsorb *
        damage
    fightlog("----------------------判定吸收后的伤害: " .. result .. "-----------------------")
    return result
end

-- 真实伤害
function this.realAttackDamage(paramMap, damage)
    local caster = paramMap.caster --—— 攻击对象
    local target = paramMap.target --—— 受击对象
    local isPVP = this.getIsPVP(paramMap)
    local result = damage

    if isPVP == true then
        local truedamagebonus = this.getAttValueWithName(caster, "truedamagebonus")
        local truedamagereductionpercentbonus = this.getAttValueWithName(target, "truedamagereductionpercentbonus")
        result = result * (1 + truedamagebonus - truedamagereductionpercentbonus)
        result = result + this.getAttValueWithName(caster, "pvptruedamage")                 -- PVP真实伤害  固定数值
        result = result - this.getAttValueWithName(target, "pvptruedamagepercent")          -- PVP真伤减免 固定数值
    else
        result = result + this.getAttValueWithName(caster, "pvetruedamagereduction")        -- PVE真实伤害 固定数值
        result = result - this.getAttValueWithName(target, "pvetruedamagereductionpercent") -- PVE真伤减免 固定数值
    end

    fightlog("----------------------判定真实伤害后的伤害: " .. result .. "-----------------------")
    return result
end

function this.getAttValueWithName(target, attName)
    return (getattrinfo(target, attName) or 0)
end

function this.getAttValueWithId(target, attId)
    local attName = attrid2name(attId) or ""
    return this.getAttValueWithName(target, attName)
end

-- [0,1)
function this.RandomResult(probability)
    local randomNum = math.random()
    return randomNum <= probability
end

---玩家战斗触发
function PlayerFight.AttackTrigger(actor, fightRet)
    this.UpdateFightTask(actor, fightRet)
end

---更新战斗相关任务
function this.UpdateFightTask(actor, fightRet)
    local taskCfgList = ConfigDataManager.getTable("cfg_task_target", "taskgoaltype", TaskTargetType.HURT_MAP_MONSTER)
    if table.isNullOrEmpty(taskCfgList) then
        return
    end
    local targetHurt = tonumber(fightRet["targethurt"])
    local mapCfgId = tonumber(fightRet["mapcfgid"])
    local targetCfgId = tonumber(fightRet["targetcfgid"])
    local flush = false
    for _, taskCfg in pairs(taskCfgList) do
        local monsterLimit = tonumber(taskCfg["taskgoalparam"])
        local mapLimit = tonumber(taskCfg["taskgoalparam2"])
        if targetCfgId == monsterLimit and mapCfgId == mapLimit then
            flush = true
            break
        end
    end
    -- 触发刷新任务
    if flush then
        local taskParam = {
            monsterid = targetCfgId,
            mapid = mapCfgId,
            hurt = targetHurt
        }
        -- 触发任务目标
        TaskHandler.TriggerTaskGoal(actor, TaskTargetType.HURT_MAP_MONSTER, taskParam)
    end
end