tszz-server/meta/userapi/lua/fight/PlayerFight.lua

--[[
    1.该脚本所有本地方法末尾均需要加PF，防止与事件接口冲突
    2.攻击者和被攻击者的类型：1-玩家；2-怪物；3-宠物
]] -- 攻击事件的入口
-- function excusefightdamage(actor, paramMapList)
--     local fightResults = {}
--     for _, paramMap in pairs(paramMapList) do
--         local fightResult = excusefightdamage0(actor, paramMap)
--         table.insert(fightResults, fightResult)
--     end
--     return fightResults
-- end
PlayerFight = {}
local this = {}

function excusefightdamage0(actor, paramMap)
    LoadGlobalDataPF(paramMap)
    local castType = paramMap["castertype"]
    local targetType = paramMap["targettype"]
    if castType == 1 and targetType == 2 then
        PlayerAtkMonsterPF(paramMap) -- 玩家攻击怪物
    elseif castType == 1 and targetType == 1 then
        PlayerAtkPlayerPF(paramMap) -- 玩家攻击玩家
    elseif castType == 2 and targetType == 1 then
        MonsterAtkPlayerPF(paramMap) -- 怪物攻击玩家
    elseif castType == 2 and targetType == 3 then
        MonsterAtkPlayerPF(paramMap) -- 怪物攻击宠物，走玩家攻击怪物
    elseif castType == 3 and targetType == 2 then
        PlayerAtkMonsterPF(paramMap) -- 宠物攻击怪物，走玩家攻击怪物
    elseif castType == 1 and targetType == 3 then
        PlayerAtkPlayerPF(paramMap) -- 玩家攻击宠物，走玩家攻击玩家
    elseif castType == 3 and targetType == 1 then
        PlayerAtkPlayerPF(paramMap) -- 宠物攻击玩家，走玩家攻击攻击玩家
    end
    local pf_globalData = getplaydef(actor, "@pf_globalData")
    local result = pf_globalData["result"]
    return result
end

-- 初始化全局数据
function LoadGlobalDataPF(paramMap)
    local skillId = paramMap["skillid"]
    local globalTable = {}
    local skillPower = tonumber(ConfigDataManager.getTableValue("cfg_skill_info", "skillPower", "skillID", skillId))
    if skillPower == nil then
        error("战斗脚本技能攻击力配置错误，skillId：" .. skillId)
        skillPower = 0
    end
    local result = {}
    result["target"] = paramMap["target"]
    result["casthurt"] = 0
    result["targethurt"] = 0
    result["castershield"] = 0
    result["targetshield"] = 0
    result["hurttype"] = 108
    result["repeat"] = 1

    globalTable["caster"] = paramMap["caster"]
    globalTable["target"] = paramMap["target"]
    globalTable["mapId"] = paramMap["mapId"]
    globalTable["castType"] = paramMap["castertype"]
    globalTable["targetType"] = paramMap["targettype"]
    globalTable["skillLevel"] = paramMap["skilllevel"]
    globalTable["skillId"] = paramMap["skillid"]
    globalTable["skillPower"] = skillPower
    globalTable["yiBanGongJi"] = "1" -- 一般攻击
    globalTable["zhuoYueYiJi"] = "0" -- 卓越一击
    globalTable["xinYunYiJi"] = "0" -- 幸运一击
    globalTable["wuShiFangYu"] = "0" -- 无视防御
    globalTable["shuangBeiYiJi"] = "0" -- 双倍一击
    globalTable["result"] = result
    setplaydef(paramMap["caster"], "@pf_globalData", globalTable)
end

-- 玩家攻击玩家
function PlayerAtkPlayerPF(paramMap)
    local caster = paramMap["caster"]
    -- 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
            end
            maxPkValue = maxPkValue > maxValue and maxPkValue or maxValue
        end
        if pkValue and pkValue ~= 0 and pkValue > maxPkValue then
            tipinfo(caster, "pk值较高，无法对玩家造成伤害")
            return
        end
    else
        error("pkCountTableInfo is null")
    end
    -- PK值判断end
    local target = paramMap["target"]
    local skillId = paramMap["skillid"]
    local playerDC = GetAtkPowerPF(caster, skillId)
    local g_minDC = playerDC[1]
    local g_maxDC = playerDC[2]
    setplaydef(caster, "@pf_g_minDC", g_minDC)
    setplaydef(caster, "@pf_g_maxDC", g_maxDC)
    local configValue = ConfigDataManager.getTableValue("cfg_global", "value", "id", 200)
    local split = string.split(configValue, "|")
    local diff = tonumber(split[1])
    local rate = tonumber(split[2])
    local hitRate = getattrinfo(caster, "hitRate")
    local missRate = getattrinfo(target, "missRate")
    local hitRand = rand(0, hitRate)
    local chaZhi = hitRand - missRate
    if chaZhi < 0 then
        chaZhi = abs(chaZhi)
        if chaZhi <= diff then
            local randomFloat = math.random()
            if rate < randomFloat then
                MissPF(paramMap)
                return
            end
        else
            MissPF(paramMap)
            return
        end
    end
    -- 获取玩家普攻技能id
    local group = ConfigDataManager.getTableValue("cfg_skill", "group", "id", skillId)
    local basicDamage
    if tonumber(group) == 4 then
        basicDamage = PlayerNormalAttackPF(paramMap)
    else
        basicDamage = SkillAttackPF(paramMap)
    end
    -- todo 最终伤害
    local damageRateDecrement = getattrinfo(target, "damageRateDecrement")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local damageIncreaseRate = getattrinfo(caster, "damageIncreaseRate")
    local pveDamageAdd = getattrinfo(caster, "pveDamageAdd")
    local finalDamage = basicDamage * (1 + damageIncreaseRate) * (1 + pveDamageAdd) * (1 - damageRateDecrement) +
                            skillDamageAdd
    HurtSetMent(finalDamage, paramMap)
end

-- 怪物攻击玩家
function MonsterAtkPlayerPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local g_minDC = getattrinfo(caster, "minDC")
    local g_maxDC = getattrinfo(caster, "maxDC")
    setplaydef(caster, "@pf_g_minDC", g_minDC)
    setplaydef(caster, "@pf_g_maxDC", g_maxDC)
    local configValue = ConfigDataManager.getTableValue("cfg_global", "value", "id", 200)
    local split = string.split(configValue, "|")
    local diff = tonumber(split[1])
    local rate = tonumber(split[2])
    local hitRate = getattrinfo(caster, "hitRate")
    local missRate = getattrinfo(target, "missRate")
    local hitRand = rand(0, hitRate)
    local chaZhi = hitRand - missRate
    if chaZhi < 0 then
        chaZhi = abs(chaZhi)
        if chaZhi <= diff then
            local randomFloat = math.random()
            if rate < randomFloat then
                MissPF(paramMap)
                return
            end
        else
            MissPF(paramMap)
            return
        end
    end
    -- 获取怪物普攻技能id
    local basicSkillId = GetMonsterBasicSkill(caster)
    local basicDamage
    if skillId == basicSkillId then
        basicDamage = MonsterNormalAttackPF(paramMap)
    else
        basicDamage = MonsterSkillAttackPF(paramMap)
    end
    -- 最终伤害
    local damageRateDecrement = getattrinfo(target, "damageRateDecrement")
    local finalDamage = basicDamage * (1 - damageRateDecrement)
    HurtSetMent(finalDamage, paramMap)
end

-- 怪物普通攻击
function MonsterNormalAttackPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local g_minDC = getplaydef(caster, "@pf_g_minDC")
    local g_maxDC = getplaydef(caster, "@pf_g_maxDC")
    -- 基础伤害=(怪物最小攻击力~怪物最大攻击力)-(人物防御力/2)
    local armor = getattrinfo(target, "armor")
    return rand(g_minDC, g_maxDC) - armor / 2
end

-- 怪物技能攻击
function MonsterSkillAttackPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local g_minDC = getplaydef(caster, "@pf_g_minDC")
    local g_maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    -- 基础伤害=(怪物最小攻击力~怪物最大攻击力)+怪物技能攻击力-(人物防御力/2)
    local armor = getattrinfo(target, "armor")
    return rand(g_minDC, g_maxDC) - armor / 2 + skillPower
end

-- 获取怪物普攻技能id
function GetMonsterBasicSkill(caster)
    local monCfgId = getbaseinfo(caster, "castermonsterid")
    return ConfigDataManager.getTableValue("cfg_monster", "monsterGeneralAttack", "id", monCfgId)
end

-- 玩家攻击怪物
function PlayerAtkMonsterPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local skillId = paramMap["skillid"]

    local playerDC = GetAtkPowerPF(caster, skillId)
    local g_minDC = playerDC[1]
    local g_maxDC = playerDC[2]
    setplaydef(caster, "@pf_g_minDC", g_minDC)
    setplaydef(caster, "@pf_g_maxDC", g_maxDC)
    local configValue = ConfigDataManager.getTableValue("cfg_global", "value", "id", 200)
    local split = string.split(configValue, "|")
    local diff = tonumber(split[1])
    local rate = tonumber(split[2])
    local hitRate = getattrinfo(caster, "hitRate")
    local missRate = getattrinfo(target, "missRate")
    local hitRand = rand(0, hitRate)
    local chaZhi = hitRand - missRate
    if chaZhi < 0 then
        chaZhi = abs(chaZhi)
        if chaZhi <= diff then
            local randomFloat = math.random()
            if rate < randomFloat then
                MissPF(paramMap)
                return
            end
        else
            MissPF(paramMap)
            return
        end
    end
    -- 获取玩家普攻技能id
    local group = ConfigDataManager.getTableValue("cfg_skill", "group", "id", skillId)
    local basicDamage
    if tonumber(group) == 4 then
        basicDamage = PlayerNormalAttackPF(paramMap)
    else
        basicDamage = SkillAttackPF(paramMap)
        print("伤害", basicDamage)
    end
    -- todo 最终伤害加成
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local damageIncreaseRate = getattrinfo(caster, "damageIncreaseRate")
    local pveDamageAdd = getattrinfo(caster, "pveDamageAdd")
    local finalDamage = basicDamage * (1 + damageIncreaseRate) * (1 + pveDamageAdd) + skillDamageAdd
    -- 如果攻击的怪物是秘境副本的BOSS则累加记录实时伤害
    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
    end
    HurtSetMent(finalDamage, paramMap)
end

-- 伤害结算
function HurtSetMent(damage, paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local hurttype = GetHurtType(paramMap)
    if damage <= 0 then
        damage = 1
    end
    -- 伤害反射
    local casterDamage, absCasterShield = HurtReflect(damage, paramMap)
    -- 韧性
    damage = CalcuResilience(damage, caster, target, paramMap)
    -- 计算受击方护盾值
    local absTargetShield = 0
    damage, absTargetShield = CalcuShield(damage, caster, target, paramMap)
    -- 设置返回值
    SetResult(casterDamage, damage, absCasterShield, absTargetShield, hurttype, 1, paramMap)
end

-- 设置返回值
function SetResult(casthurt, targethurt, castershield, targetshield, hurttype, repeatl, paramMap)
    local caster = paramMap["caster"]
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local result = pf_globalData["result"]
    result["casthurt"] = casthurt
    result["targethurt"] = targethurt
    result["castershield"] = castershield
    result["targetshield"] = targetshield
    result["hurttype"] = hurttype
    result["repeat"] = repeatl
    setplaydef(caster, "@pf_globalData", pf_globalData)
end

-- 伤害反射
function HurtReflect(damage, paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local damageReflex = getattrinfo(target, "damageReflex")
    local reflectDamageReductionAndIncrease = getattrinfo(caster, "reflectDamageReductionAndIncrease")
    local damageRateDecrement = getattrinfo(caster, "damageRateDecrement")
    damage = damage * damageReflex * (1 - reflectDamageReductionAndIncrease) * (1 - damageRateDecrement)
    damage = CalcuResilience(damage, target, caster, paramMap)
    local absCasterShield = 0
    damage, absCasterShield = CalcuShield(damage, target, caster, paramMap)
    return damage, absCasterShield
end

-- 计算韧性
function CalcuResilience(damage, caster, target, paramMap)
    local castType = paramMap["castertype"]
    local targetType = paramMap["targettype"]
    if castType ~= 1 or targetType ~= 1 then
        return damage
    end
    local casterRes = getattrinfo(caster, "equipmentResilienceIndex")
    local targetRes = getattrinfo(target, "equipmentResilienceIndex")
    if casterRes >= targetRes then
        return damage
    end
    return damage * (100 - (targetRes - casterRes)) / 100
end

-- 计算护盾值
function CalcuShield(damage, casterActor, targetActor, paramMap)
    local castType = paramMap["castertype"]
    local targetType = paramMap["targettype"]
    if castType ~= 1 or targetType ~= 1 then
        return damage, 0
    end
    local shield = getattrinfo(targetActor, "shield")
    local sdAdd = getattrinfo(targetActor, "sdAdd")
    local shieldParry = getattrinfo(targetActor, "shieldParry")
    local shieldParryfall = getattrinfo(casterActor, "shieldParryfall")
    -- 护盾抵抗百分比
    local rate = min(0, shieldParry - shieldParryfall)
    local resDamage = damage * rate
    if resDamage > shield + sdAdd then
        damage = damage * (1 - rate) + resDamage - shield - sdAdd
        return damage, shield
    end
    return damage * (1 - rate), resDamage
end

-- 获取伤害类型
function GetHurtType(paramMap)
    local caster = paramMap["caster"]
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local yiBanGongJi = pf_globalData["yiBanGongJi"]
    local zhuoYueYiJi = pf_globalData["zhuoYueYiJi"]
    local xinYunYiJi = pf_globalData["xinYunYiJi"]
    local wuShiFangYu = pf_globalData["wuShiFangYu"]
    local shuangBeiYiJi = pf_globalData["shuangBeiYiJi"]
    local typeString = yiBanGongJi .. zhuoYueYiJi .. xinYunYiJi .. wuShiFangYu .. shuangBeiYiJi
    print(typeString)
    local hurtTypeCache = getsysvar(SystemVarConst.NORMAL_DAMAGE_TYPE_CACHE)
    local type = hurtTypeCache[typeString]
    if type == nil then
        print("获取攻击概率类型失败")
        type = 101
    end
    return type
end

-- 技能攻击
-- 技能攻击的计算公式分为物理系和魔法系
function SkillAttackPF(paramMap)
    local skillId = paramMap["skillid"]
    local damage = 0
    local injury_type = tonumber(ConfigDataManager.getTableValue("cfg_skill_info", "injuryType", "skillID", skillId))
    if injury_type == 1 then
        damage = WuliXiSkillPF(paramMap)
    elseif injury_type == 2 then
        damage = MoFaXiSkillPF(paramMap)
    elseif injury_type == 3 then
        damage = ZuZhouXiSkillPF(paramMap)
    else
        error("不存在的伤害类型")
    end
    return damage
end

-- 诅咒攻击
function ZuZhouXiSkillPF(paramMap)
    local retDamage = 0
    if IsShuangBeiYiJiPF(paramMap) then
        retDamage = ShuangBeiYiJi1325(paramMap)
    elseif IsWuShiFangYuPF(paramMap) then
        retDamage = WuShiFangYu1324(paramMap)
    elseif IsZhuoYueYiJiPF(paramMap) then
        retDamage = ZhuoYueYiJi1323(paramMap)
    elseif IsXingYunYiJiPF(paramMap) then
        retDamage = XinYunYiJi1322(paramMap)
    else
        retDamage = YiBanGongJi1321(paramMap)
    end
    return retDamage
end

---------------------------获取技能属性加成---------------------------
function GetSkillAttributeDamage(paramMap)
    local caster = paramMap["caster"]
    local skillid = paramMap["skillid"]
    local skillLevel = paramMap["skilllevel"]
    local attributeDamage = ConfigDataManager.getTableValue("cfg_skill_info", "attributeDamage", "skillID", skillid, "skillLevel",
        skillLevel)
    if not attributeDamage or attributeDamage == 0 or attributeDamage == "" then
        return nil
    end
    local allAttributeDamage = string.split(attributeDamage, "|")
    local index = math.random(1, #allAttributeDamage)
    local attributeDamageString = allAttributeDamage[index]
    local attributeDamageLocal = string.split(attributeDamageString, "#")
    local attId = tonumber(attributeDamageLocal[1])
    local attName = attrid2name(caster, attId)
    local attValue = getattrinfo(caster, attName)
    local attInfo = {attValue, tonumber(attributeDamageLocal[2])}
    return attInfo
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)双倍一击(5)---------------------------
function ShuangBeiYiJi1325(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local doubleDamageBonus = getattrinfo(caster, "doubleDamageBonus")
    if IsWuShiFangYuPF(paramMap) then
        local ignore_defense_damage = WuShiFangYu1324(paramMap)
        retDamage = ignore_defense_damage * (1 + doubleDamageBonus)
    elseif IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi1323(paramMap)
        retDamage = zhuo_yue_damage * (1 + doubleDamageBonus)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi1322(paramMap)
        retDamage = lucky_damage * (1 + doubleDamageBonus)
    else
        local normal_damage = YiBanGongJi1321(paramMap)
        retDamage = normal_damage * (1 + doubleDamageBonus)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)卓越一击(3)---------------------------
function ZhuoYueYiJi1323(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)-(怪物防御力/2)]+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd - armor / 2) *
                   (1 + excellentDamageBonus) + excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) + skillDamageAdd -
               armor / 2) * (1 + excellentDamageBonus) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)卓越一击(3)---------------------------
function XinYunYiJi1322(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)-(怪物防御力/2)]+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd - armor / 2) *
                   (1 + criticalDamageBonus) + criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) + skillDamageAdd -
               armor / 2) * (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)一般攻击(1)---------------------------
function YiBanGongJi1321(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 一般攻击：基础伤害=[(人物最小诅咒攻击力~人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)-(怪物防御力/2)]+技能攻击力增加具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((rand(minDC, maxDC) + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd - armor / 2)
    end
    return ((rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) +
               skillDamageAdd - armor / 2)
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)无视防御攻击(4)---------------------------
function WuShiFangYu1324(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local ignoringIncreasedDefenseDamage = getattrinfo(caster, "ignoringIncreasedDefenseDamage")
    if IsZhuoYueYiJiPF() then
        local zhuo_yue_damage = ZhuoYueYiJi13243(paramMap)
        retDamage = zhuo_yue_damage * (1 + ignoringIncreasedDefenseDamage)
    elseif IsXingYunYiJiPF() then
        local lucky_damage = XinYunYiJi13242(paramMap)
        retDamage = lucky_damage * (1 + ignoringIncreasedDefenseDamage)
    else
        local normal_damage = YiBanGongJi13241(paramMap)
        retDamage = normal_damage * (1 + ignoringIncreasedDefenseDamage)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)无视防御(4)卓越一击(3)---------------------------
function ZhuoYueYiJi13243(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- ;基础伤害=【{[(人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)]+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值】
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd) * (1 + excellentDamageBonus) +
                   excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) + skillDamageAdd) *
               (1 + excellentDamageBonus) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)无视防御(4)幸运一击(2)---------------------------
function XinYunYiJi13242(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=【{[(人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)]+技能攻击力增加具体数值}*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值】
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd) * (1 + criticalDamageBonus) +
                   criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) + skillDamageAdd) *
               (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)诅咒系(3)技能攻击(2)一般攻击(1)---------------------------
function YiBanGongJi13241(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 一般攻击：基础伤害=[(人物最小诅咒攻击力~人物最大诅咒攻击力+技能攻击力)*(100%+召唤书诅咒攻击提升加成系数)-(怪物防御力/2)]+技能攻击力增加具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local increaseLevelMaxHp = getattrinfo(caster, "increaseLevelMaxHp")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return (rand(minDC, maxDC) + skillPower) * (increaseLevelMaxHp + 1) + skillDamageAdd - armor / 2
    end
    return (rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (increaseLevelMaxHp + 1) +
               skillDamageAdd - armor / 2
end

-- 魔法系技能攻击
function MoFaXiSkillPF(paramMap)
    local retDamage = 0
    if IsShuangBeiYiJiPF(paramMap) then
        retDamage = ShuangBeiYiJi1225(paramMap)
    elseif IsWuShiFangYuPF(paramMap) then
        retDamage = WuShiFangYu1224()
    elseif IsZhuoYueYiJiPF(paramMap) then
        retDamage = ZhuoYueYiJi1223(paramMap)
    elseif IsXingYunYiJiPF(paramMap) then
        retDamage = XinYunYiJi1222(paramMap)
    else
        retDamage = YiBanGongJi1221(paramMap)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)双倍一击(5)---------------------------
function ShuangBeiYiJi1225(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local doubleDamageBonus = getattrinfo(caster, "doubleDamageBonus")
    if IsWuShiFangYuPF(paramMap) then
        local ignore_defense_damage = WuShiFangYu1224(paramMap)
        retDamage = ignore_defense_damage * (1 + doubleDamageBonus)
    elseif IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi1223(paramMap)
        retDamage = zhuo_yue_damage * (1 + doubleDamageBonus)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi1222(paramMap)
        retDamage = lucky_damage * (1 + doubleDamageBonus)
    else
        local normal_damage = YiBanGongJi1221(paramMap)
        retDamage = normal_damage * (1 + doubleDamageBonus)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)一般攻击(1)---------------------------
function YiBanGongJi1221(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- ;基础伤害=[(人物最小魔法攻击力~人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)-(对方防御力/2)]+技能攻击力增加具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((rand(minDC, maxDC) + skillPower) * (wandMagicAttackPowerBonus + 1) + skillDamageAdd - armor / 2)
    end
    return
        ((rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (wandMagicAttackPowerBonus + 1) +
            skillDamageAdd - armor / 2)
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)幸运一击(2)---------------------------
function XinYunYiJi1222(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)-(对方防御力/2)]+技能攻击力增加具体数值}*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (wandMagicAttackPowerBonus + 1) + skillDamageAdd - armor / 2) *
                   (1 + criticalDamageBonus) + criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (wandMagicAttackPowerBonus + 1) +
               skillDamageAdd - armor / 2) * (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)卓越一击(3)---------------------------
function ZhuoYueYiJi1223(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)-(怪物防御力/2)]+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (wandMagicAttackPowerBonus + 1) + skillDamageAdd - armor / 2) *
                   (1 + excellentDamageBonus) + excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (wandMagicAttackPowerBonus + 1) +
               skillDamageAdd - armor / 2) * (1 + excellentDamageBonus) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)无视防御攻击(4)---------------------------
function WuShiFangYu1224(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local ignoringIncreasedDefenseDamage = getattrinfo(caster, "ignoringIncreasedDefenseDamage")
    if IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi12243(paramMap)
        retDamage = zhuo_yue_damage * (1 + ignoringIncreasedDefenseDamage)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi12242(paramMap)
        retDamage = lucky_damage * (1 + ignoringIncreasedDefenseDamage)
    else
        local normal_damage = YiBanGongJi12241(paramMap)
        retDamage = normal_damage * (1 + ignoringIncreasedDefenseDamage)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)无视防御(4)卓越一击(3)---------------------------
function ZhuoYueYiJi12243(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=【{[(人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)]+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值】
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (wandMagicAttackPowerBonus + 1) + skillDamageAdd) * (1 + excellentDamageBonus) +
                   excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (wandMagicAttackPowerBonus + 1) +
               skillDamageAdd) * (1 + excellentDamageBonus) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)无视防御(4)幸运一击(2)---------------------------
function XinYunYiJi12242(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=【{[(人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)]+技能攻击力增加具体数值}*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值】
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (wandMagicAttackPowerBonus + 1) + skillDamageAdd) * (1 + criticalDamageBonus) +
                   criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (wandMagicAttackPowerBonus + 1) +
               skillDamageAdd) * (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)魔法系(2)技能攻击(2)无视防御(4)一般攻击(1)---------------------------

function YiBanGongJi12241(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最小魔法攻击力~人物最大魔法攻击力+技能攻击力)*(100%+法杖魔攻加成系数)]+技能攻击力增加具体数值}
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local wandMagicAttackPowerBonus = getattrinfo(caster, "wandMagicAttackPowerBonus")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return (rand(minDC, maxDC) + skillPower) * (1 + wandMagicAttackPowerBonus) + skillDamageAdd
    end
    return (rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (1 + wandMagicAttackPowerBonus) +
               skillDamageAdd
end

-- 物理系技能攻击
function WuliXiSkillPF(paramMap)
    local retDamage = 0
    if IsShuangBeiYiJiPF(paramMap) then
        retDamage = ShuangBeiYiJi1125(paramMap)
    elseif IsWuShiFangYuPF(paramMap) then
        retDamage = WuShiFangYu1124(paramMap)
    elseif IsZhuoYueYiJiPF(paramMap) then
        retDamage = ZhuoYueYiJi1123(paramMap)
    elseif IsXingYunYiJiPF(paramMap) then
        retDamage = XinYunYiJi1122(paramMap)
    else
        retDamage = YiBanGongJi1121(paramMap)
    end
    return retDamage
end

--------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)双倍一击(5)---------------------------
function ShuangBeiYiJi1125(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local doubleDamageBonus = getattrinfo(caster, "doubleDamageBonus")
    if IsWuShiFangYuPF(paramMap) then
        local ignore_defense_damage = WuShiFangYu1124(paramMap)
        retDamage = ignore_defense_damage * (1 + doubleDamageBonus)
    elseif IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi1123(paramMap)
        retDamage = zhuo_yue_damage * (1 + doubleDamageBonus)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi1122(paramMap)
        retDamage = lucky_damage * (1 + doubleDamageBonus)
    else
        local normal_damage = YiBanGongJi1121(paramMap)
        retDamage = normal_damage * (1 + doubleDamageBonus)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)一般攻击(1)---------------------------
function YiBanGongJi1121(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=[(人物最小攻击力~人物最大攻击力)+技能攻击力-(怪物防御力/2)]*技能攻击力系数+技能攻击力增加具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local armor = getattrinfo(target, "armor")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return (rand(minDC, maxDC) + skillPower - (armor / 2)) * (1 + skillDamage) + skillDamageAdd
    end
    return (rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000) - (armor / 2)) * (1 + skillDamage) +
               skillDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)幸运一击(2)---------------------------
function XinYunYiJi1122(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大攻击力+技能攻击力)-(怪物防御力/2)]*技能攻击力系数+技能攻击力增加具体数值}*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local armor = getattrinfo(target, "armor")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower - armor / 2) * (skillDamage + 1) + skillDamageAdd) * (1 + criticalDamageBonus) +
                   criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000) - armor / 2) * (skillDamage + 1) +
               skillDamageAdd) * (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)卓越一击(3)---------------------------
function ZhuoYueYiJi1123(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大攻击力+技能攻击力)-(怪物防御力/2)]*技能攻击力系数+技能攻击力增加具体数值}*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local armor = getattrinfo(target, "armor")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower - armor / 2) * (skillDamage + 1) + skillDamageAdd) * (1 + excellentDamageBonus) +
                   excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000) - armor / 2) * (skillDamage + 1) +
               skillDamageAdd) * (1 + excellentDamageBonus) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)无视防御攻击(4)---------------------------
function WuShiFangYu1124(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local ignoringIncreasedDefenseDamage = getattrinfo(caster, "ignoringIncreasedDefenseDamage")
    if IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi11243(paramMap)
        retDamage = zhuo_yue_damage * (1 + ignoringIncreasedDefenseDamage)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi11242(paramMap)
        retDamage = lucky_damage * (1 + ignoringIncreasedDefenseDamage)
    else
        local normal_damage = YiBanGongJi11241(paramMap)
        retDamage = normal_damage * (1 + ignoringIncreasedDefenseDamage)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)无视防御(4)一般攻击(1)---------------------------

function YiBanGongJi11241(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最小攻击力~人物最大攻击力)+技能攻击力]*技能攻击力系数+技能攻击力增加具体数值}
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local armor = getattrinfo(target, "armor")
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return (rand(minDC, maxDC) + skillPower) * (1 + skillDamage) + skillDamageAdd
    end
    return (rand(minDC, maxDC) + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (1 + skillDamage) +
               skillDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)无视防御(4)幸运一击(2)---------------------------
function XinYunYiJi11242(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大攻击力+技能攻击力)*技能攻击力系数+技能攻击力增加具体数值]*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值}
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (skillDamage + 1) + skillDamageAdd) * (1 + criticalDamageBonus) +
                   criticalDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (skillDamage + 1) + skillDamageAdd) *
               (1 + criticalDamageBonus) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)技能攻击(2)无视防御(4)卓越一击(3)---------------------------
function ZhuoYueYiJi11243(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害={[(人物最大攻击力+技能攻击力)*技能攻击力系数+技能攻击力增加具体数值]*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local skillPower = pf_globalData["skillPower"]
    local skillDamage = getattrinfo(caster, "skillDamage")
    local skillDamageAdd = getattrinfo(caster, "skillDamageAdd")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    local attAdd = GetSkillAttributeDamage(paramMap)
    if not attAdd then
        return ((maxDC + skillPower) * (skillDamage + 1) + skillDamageAdd) * (1 + excellentDamageBonus) +
                   excellentDamageAdd
    end
    return ((maxDC + (skillPower + attAdd[1]) * (1 + attAdd[2] / 10000)) * (skillDamage + 1) + skillDamageAdd) *
               (1 + excellentDamageBonus) + excellentDamageAdd
end

-- 玩家普通攻击
function PlayerNormalAttackPF(paramMap)
    local retDamage = 0
    if IsShuangBeiYiJiPF(paramMap) then
        retDamage = ShuangBeiYiJi1115(paramMap)
    elseif IsWuShiFangYuPF(paramMap) then
        retDamage = WuShiFangYu11154(paramMap)
    elseif IsZhuoYueYiJiPF(paramMap) then
        retDamage = ZhuoYueYiJi1113(paramMap)
    elseif IsXingYunYiJiPF(paramMap) then
        retDamage = XinYunYiJi1112(paramMap)
    else
        retDamage = YiBanGongJi1111(paramMap)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)双倍一击(5)---------------------------
function ShuangBeiYiJi1115(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]

    local retDamage = 0
    local doubleDamageBonus = getattrinfo(caster, "doubleDamageBonus")
    if IsWuShiFangYuPF(paramMap) then
        local ignore_defense_damage = WuShiFangYu11154(paramMap)
        retDamage = ignore_defense_damage * (1 + doubleDamageBonus)
    elseif IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi1113(paramMap)
        retDamage = zhuo_yue_damage * (1 + doubleDamageBonus)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi1112(paramMap)
        retDamage = lucky_damage * (1 + doubleDamageBonus)
    else
        local normal_damage = YiBanGongJi1111(paramMap)
        retDamage = normal_damage * (1 + doubleDamageBonus)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)一般攻击(1)---------------------------
function YiBanGongJi1111(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=(人物最小攻击力~人物最大攻击力)-(怪物防御力/2)
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    local armor = getattrinfo(target, "armor")
    return rand(minDC, maxDC) - armor / 2
end

--------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)幸运一击(2)---------------------------
function XinYunYiJi1112(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=[人物最大攻击力-(怪物防御力/2)]*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local armor = getattrinfo(target, "armor")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    return (maxDC - armor / 2) * (criticalDamageBonus + 1) + criticalDamageAdd
end

--------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)卓越一击(3)---------------------------
function ZhuoYueYiJi1113(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=[人物最大攻击力-(怪物防御力/2)]*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local armor = getattrinfo(target, "armor")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    return (maxDC - armor / 2) * (excellentDamageBonus + 1) + excellentDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)双倍一击(5)无视防御攻击(4)---------------------------
function WuShiFangYu11154(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local retDamage = 0
    local ignoringIncreasedDefenseDamage = getattrinfo(caster, "ignoringIncreasedDefenseDamage")
    if IsZhuoYueYiJiPF(paramMap) then
        local zhuo_yue_damage = ZhuoYueYiJi11143(paramMap)
        retDamage = zhuo_yue_damage * (1 + ignoringIncreasedDefenseDamage)
    elseif IsXingYunYiJiPF(paramMap) then
        local lucky_damage = XinYunYiJi11142(paramMap)
        retDamage = lucky_damage * (1 + ignoringIncreasedDefenseDamage)
    else
        local normal_damage = YiBanGongJi11141(paramMap)
        retDamage = normal_damage * (1 + ignoringIncreasedDefenseDamage)
    end
    return retDamage
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)无视防御(4)一般攻击(1)---------------------------
function YiBanGongJi11141(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local minDC = getplaydef(caster, "@pf_g_minDC")
    -- 基础伤害=(人物最小攻击力~人物最大攻击力)
    return rand(minDC, maxDC)
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)无视防御(4)幸运一击(2)---------------------------
function XinYunYiJi11142(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=(人物最大攻击力*幸运一击攻击力加成系数+幸运一击攻击力加成具体数值)
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local criticalDamageBonus = getattrinfo(caster, "criticalDamageBonus")
    local criticalDamageAdd = getattrinfo(caster, "criticalDamageAdd")
    return maxDC * (criticalDamageBonus + 1) + criticalDamageAdd
end

---------------------------玩家攻击怪物(1)物理系(1)普通攻击(1)无视防御(4)卓越一击(3)---------------------------
function ZhuoYueYiJi11143(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    -- 基础伤害=(人物最大攻击力*卓越一击攻击力加成系数+卓越一击攻击力加成具体数值)
    local maxDC = getplaydef(caster, "@pf_g_maxDC")
    local excellentDamageBonus = getattrinfo(caster, "excellentDamageBonus")
    local excellentDamageAdd = getattrinfo(caster, "excellentDamageAdd")
    return maxDC * (excellentDamageBonus + 1) + excellentDamageAdd
end

-- 攻击miss
function MissPF(paramMap)
    local caster = paramMap["caster"]
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    local result = pf_globalData["result"]
    result["casthurt"] = 0
    result["targethurt"] = 0
    result["castershield"] = 0
    result["targetshield"] = 0
    result["hurttype"] = 108
    result["repeat"] = 1
    setplaydef(caster, "@pf_globalData", pf_globalData)
end

-- 获取技能攻击力
function GetAtkPowerPF(actor, skillId)
    local injuryType = tonumber(ConfigDataManager.getTableValue("cfg_skill_info", "injuryType", "skillID", skillId))
    local minDC = getattrinfo(actor, "minDC")
    local maxDC = getattrinfo(actor, "maxDC")
    local career = tonumber(getbaseinfo(actor, "getbasecareer"))
    if injuryType == 1 then
        -- 物理攻击
        if career == 1 then
            -- 战士
            local weaponList = GetWeaponListPF(actor)
            local weaponType = GetWeaponTypePF(actor, weaponList)
            if weaponType == 1 then
                return ZhanShiChuLi1BaWuQiPF(actor, weaponList)
            elseif weaponType == 2 then
                return ZhanShiChuLi2BaWuQiPF(actor, weaponList)
            end
        end
    elseif injuryType == 2 then
        -- 魔法攻击
        return MoFaDCPF(actor)
    elseif injuryType == 3 then
        -- 诅咒攻击
        return ZuZhouDCPF(actor)
    end
    local ret = {minDC, maxDC}
    return ret
end

-- 诅咒系攻击力计算
function ZuZhouDCPF(actor)
    local pf_globalData = getplaydef(actor, "@pf_globalData")
    local skillId = pf_globalData["skillId"]
    local skillLevel = pf_globalData["skillLevel"]

    local minZC = getattrinfo(actor, "minimumCurseAttackPower")
    local maxZC = getattrinfo(actor, "maximumCurseAttackPower")
    local skillPower
    if skillId > 0 and skillLevel > 0 then
        skillPower = ConfigDataManager.getTableValue('cfg_skill_info', 'skillpower', 'skillid', skillId, 'skilllevel', skillLevel)
        skillPower = tonumber(skillPower)
        skillPower = skillPower or 0
    end
    local levelMC = getattrinfo(actor, "levelmc")
    -- 计算卓越魔法攻击力
    local zhuoYueMoFaDC = getattrinfo(actor, "levelmc") + getattrinfo(actor, "attackIncreaseMc")
    local enchantmentCurseAttackPowerBonus = getattrinfo(actor, "enchantmentCurseAttackPowerBonus")
    local curseStaffAttackPowerBonus = getattrinfo(actor, "curseStaffAttackPowerBonus")
    local retMinMC = (minZC + skillPower + levelMC / 20) * (1 + zhuoYueMoFaDC * 0.02) *
                         (1 + enchantmentCurseAttackPowerBonus / 100) * (1 + curseStaffAttackPowerBonus / 100)
    local retMaxMC = (maxZC + skillPower + levelMC / 20) * (1 + zhuoYueMoFaDC * 0.02) *
                         (1 + enchantmentCurseAttackPowerBonus / 100) * (1 + curseStaffAttackPowerBonus / 100)
    local ret = {retMinMC, retMaxMC}
    return ret
end

-- 魔法系攻击力计算
function MoFaDCPF(actor)
    local pf_globalData = getplaydef(actor, "@pf_globalData")
    local skillId = pf_globalData["skillId"]
    local skillLevel = pf_globalData["skillLevel"]

    local minMC = getattrinfo(actor, "minMC")
    local maxMC = getattrinfo(actor, "maxMC")
    local skillPower
    if skillId > 0 and skillLevel > 0 then
        skillPower = ConfigDataManager.getTableValue('cfg_skill_info', 'skillpower', 'skillid', skillId, 'skilllevel', skillLevel)
        skillPower = tonumber(skillPower)
        skillPower = skillPower or 0
    end
    local magicAttackPowerValue = getattrinfo(actor, "magicattackpowervalue")
    local levelMC = getattrinfo(actor, "levelmc")
    -- 计算卓越魔法攻击力
    local zhuoYueMoFaDC = getattrinfo(actor, "levelmc") + getattrinfo(actor, "attackIncreaseMc")
    local enchantmentCurseAttackPowerBonus = getattrinfo(actor, "enchantmentCurseAttackPowerBonus")
    local wandMagicAttackPowerBonus = getattrinfo(actor, "wandMagicAttackPowerBonus")
    local retMinMC = (minMC + skillPower + magicAttackPowerValue + levelMC / 20) * (1 + zhuoYueMoFaDC * 0.02) *
                         (1 + enchantmentCurseAttackPowerBonus / 100) * (1 + wandMagicAttackPowerBonus / 100)
    local retMaxMC = (maxMC + skillPower + magicAttackPowerValue + levelMC / 20) * (1 + zhuoYueMoFaDC * 0.02) *
                         (1 + enchantmentCurseAttackPowerBonus / 100) * (1 + wandMagicAttackPowerBonus / 100)
    local ret = {retMinMC, retMaxMC}
    return ret
end

-- 战士_处理1把武器或者盾牌
function ZhanShiChuLi1BaWuQiPF(actor, weaponList)
    local weapon = weaponList[1]
    local basicAttr = weapon["basicattr"]
    local minDCId = attrname2id("minDC")
    local maxDCId = attrname2id("maxDC")
    local minDC = getattrinfo(actor, "minDC")
    local maxDC = getattrinfo(actor, "maxDC")
    local weaponMinDC = FindAttrValuePF(basicAttr, minDCId)
    local weaponMaxDC = FindAttrValuePF(basicAttr, maxDCId)
    local levelDC = getattrinfo(actor, "levelDc")
    local powerValue = getattrinfo(actor, "levelDc")
    local attackBonusDC = getattrinfo(actor, "attackBonusDc")
    local zhuoYueDC = CalcuZhuoYueDCPF(actor)
    local retMinDC = (minDC + weaponMinDC + levelDC / 20 + powerValue) * (1 + zhuoYueDC * 0.02) *
                         (1 + attackBonusDC / 100)
    local retMaxDC = (maxDC + weaponMaxDC + levelDC / 20 + powerValue) * (1 + zhuoYueDC * 0.02) *
                         (1 + attackBonusDC / 100)
    local ret = {retMinDC, retMaxDC}
    return ret
end

-- 战士_处理2把单手武器
function ZhanShiChuLi2BaWuQiPF(actor, weaponList)
    local left = weaponList[1]
    local right = weaponList[2]
    local leftBasicAttr = left["basicattr"]
    local rightBasicAttr = right["basicattr"]

    local minDCId = attrname2id("minDC")
    local maxDCId = attrname2id("maxDC")
    local minDC = getattrinfo(actor, "minDC")
    local maxDC = getattrinfo(actor, "maxDC")

    local leftMinDC = FindAttrValuePF(leftBasicAttr, minDCId)
    local leftMaxDC = FindAttrValuePF(leftBasicAttr, maxDCId)
    local rightMinDC = FindAttrValuePF(rightBasicAttr, minDCId)
    local rightMaxDC = FindAttrValuePF(rightBasicAttr, maxDC)

    local levelDC = getattrinfo(actor, "levelDc")
    local powerValue = getattrinfo(actor, "levelDc")
    local attackBonusDC = getattrinfo(actor, "attackBonusDc")
    local zhuoYueDC = CalcuZhuoYueDCPF(actor)
    local retMinDC = (minDC * 2 + leftMinDC + rightMinDC + levelDC / 20 * 2 + powerValue * 2) * (1 + zhuoYueDC * 0.02) *
                         (1 + attackBonusDC / 100) * 0.55
    local retMaxDC = (maxDC * 2 + leftMaxDC + rightMaxDC + levelDC / 20 * 2 + powerValue * 2) * (1 + zhuoYueDC * 0.02) *
                         (1 + attackBonusDC / 100) * 0.55
    local ret = {retMinDC, retMaxDC}
    return ret
end

-- 计算卓越攻击力
function CalcuZhuoYueDCPF(actor)
    local value = getattrinfo(actor, "levelDc") + getattrinfo(actor, "attackBonusDc")
end

function FindAttrValuePF(attrList, attrId)
    if #attrList <= 0 then
        return 0
    end
    for index, attrMap in ipairs(attrList) do
        local id = tonumber(attrMap["attrid"])
        local value = tonumber(attrMap["value"])
        if id == attrId then
            return value
        end
    end
    return 0
end

-- 获取武器列表
function GetWeaponListPF(actor)
    local retData = {}
    local allEquipInfo = getputonequipinfo(actor)
    for index, equipInfo in ipairs(allEquipInfo) do
        local cfgId = equipInfo["cfgid"]
        local strPart = tonumber(ConfigDataManager.getTableValue('cfg_item', 'strpart', 'id', cfgId))
        if strPart == 1 or strPart == 2 or strPart == 3 then
            table.insert(retData, equipInfo)
        end
    end
    return retData
end

function GetWeaponTypePF(actor, weaponList)
    local ret = 0
    local count = #weaponList
    if count == 1 then
        ret = 1
    elseif count == 2 then
        local weapon1 = weaponList[1]
        local weapon2 = weaponList[2]
        local weapon1CfgId = weapon1["cfgid"]
        local weapon2CfgId = weapon2["cfgid"]
        local ok1 = IsZhuFuShouWeapon(weapon1CfgId)
        local ok2 = IsZhuFuShouWeapon(weapon2CfgId)
        if ok1 == 1 or ok2 == 1 then
            return 2
        else
            return 1
        end
    end
end

-- 是否是主副手武器
function IsZhuFuShouWeapon(cfg_id)
    local type = tonumber(ConfigDataManager.getTableValue('cfg_item', 'type', 'id', cfg_id))
    local sub_type = tonumber(ConfigDataManager.getTableValue('cfg_item', 'subtype', 'id', cfg_id))
    if type == 1 and sub_type == 3 then
        return 1
    else
        return 0
    end
end

function IsShuangBeiYiJiPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local doubleDamageChance = getattrinfo(caster, "doubleDamageChance")
    local doubleDamageResistanceChance = getattrinfo(target, "doubleDamageResistanceChance")
    local chance = max(0, doubleDamageChance - doubleDamageResistanceChance)
    local randomFloat = math.random()
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    if chance > randomFloat then
        pf_globalData["shuangBeiYiJi"] = "1"
        pf_globalData["yiBanGongJi"] = "0"
        setplaydef(caster, "@pf_globalData", pf_globalData)
        return true
    else
        return false
    end
end

function IsWuShiFangYuPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local unMissRate = getattrinfo(caster, "unMissRate")
    local unMissResistanceRate = getattrinfo(target, "unMissResistanceRate")
    local chance = max(0, unMissRate - unMissResistanceRate)
    local randomFloat = math.random()
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    if chance > randomFloat then
        pf_globalData["wuShiFangYu"] = "1"
        pf_globalData["yiBanGongJi"] = "0"
        setplaydef(caster, "@pf_globalData", pf_globalData)
        return true
    else
        return false
    end
end

function IsZhuoYueYiJiPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local excellentDamageChance = getattrinfo(caster, "excellentDamageChance")
    local excellentDamageResistanceChance = getattrinfo(target, "excellentDamageResistanceChance")
    local chance = max(0, excellentDamageChance - excellentDamageResistanceChance)
    local randomFloat = math.random()
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    if chance > randomFloat then
        pf_globalData["zhuoYueYiJi"] = "1"
        pf_globalData["yiBanGongJi"] = "0"
        setplaydef(caster, "@pf_globalData", pf_globalData)
        return true
    else
        return false
    end
end

function IsXingYunYiJiPF(paramMap)
    local caster = paramMap["caster"]
    local target = paramMap["target"]
    local criticalDamageChance = getattrinfo(caster, "criticalDamageChance")
    local criticalDamageResistanceChance = getattrinfo(target, "criticalDamageResistanceChance")
    local chance = max(0, criticalDamageChance - criticalDamageResistanceChance)
    local randomFloat = math.random()
    local pf_globalData = getplaydef(caster, "@pf_globalData")
    if chance > randomFloat then
        pf_globalData["xinYunYiJi"] = "1"
        pf_globalData["yiBanGongJi"] = "0"
        setplaydef(caster, "@pf_globalData", pf_globalData)
        return true
    else
        return false
    end
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