1397 lines
50 KiB
Lua
1397 lines
50 KiB
Lua
local floor = math.floor
|
||
local max = math.max
|
||
local min = math.min
|
||
--local RoleDataName = RoleDataName
|
||
--local BattleLogic = BattleLogic
|
||
--local BattleUtil = BattleUtil
|
||
--local BattleEventName = BattleEventName
|
||
--local BuffName = BuffName
|
||
|
||
--属性编号
|
||
local propertyList = {
|
||
RoleDataName.Attack,
|
||
RoleDataName.PhysicalDefence,
|
||
RoleDataName.MagicDefence,
|
||
RoleDataName.Speed,
|
||
RoleDataName.DamageBocusFactor,
|
||
RoleDataName.DamageReduceFactor,
|
||
RoleDataName.Hit,
|
||
RoleDataName.Dodge,
|
||
RoleDataName.Crit,
|
||
RoleDataName.CritDamageFactor,
|
||
RoleDataName.TreatFacter,
|
||
RoleDataName.MaxHp,
|
||
RoleDataName.Hp,
|
||
RoleDataName.CureFacter,
|
||
RoleDataName.Tenacity,
|
||
}
|
||
|
||
--被动技能表
|
||
local passivityList = {
|
||
--发动技能时,[a]的概率将[b]*[c]算作[d]计算
|
||
--a[float],b[属性],c[float],d[属性]
|
||
[1] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local pro2 = args[4]
|
||
|
||
local OnSkillCast = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local duration = 0
|
||
for i=1, skill.effectList.size do
|
||
duration = max(duration, skill.effectList.buffer[i].duration)
|
||
end
|
||
role:AddPropertyTransfer(propertyList[pro1], f2, propertyList[pro2], 2, duration + BattleLogic.GameDeltaTime * 2)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCast, OnSkillCast)
|
||
end,
|
||
|
||
--发动技能后,[a]的概率对敌方随机1名施加攻击*[c]的[d]伤害。
|
||
--a[float],c[float],d[伤害类型]
|
||
[2] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20001)
|
||
if arr[1] then
|
||
BattleUtil.CalDamage(role, arr[1], dt, f2)
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[c]使仇恨目标受到治疗效果降低[a],持续[b]
|
||
--a[float],b[int],c[float]
|
||
[3] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f3, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 40000)
|
||
if arr[1] then
|
||
arr[1]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, RoleDataName.CureFacter, f1, 3))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[d]改变自身[a]属性[b],持续[c]秒
|
||
--a[属性],b[float],c[int],d[改变类型]
|
||
[4] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, ct))
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[a]的概率回复攻击最高的1人的[b]*[c]血量,持续[d]秒。
|
||
--a[float],b[属性],c[float],d[int]
|
||
[5] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 10321)
|
||
if arr[1] then
|
||
local val = floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro])))
|
||
arr[1]:AddBuff(Buff.Create(role, BuffName.HOT, f3, 1, val))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[a]的概率提升随机角色的[b]*[c]的[d],持续[e]秒。
|
||
--a[float],b[属性],c[float],d[属性],e[int]
|
||
[6] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local pro2 = args[4]
|
||
local f3 = args[5]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 10001)
|
||
if arr[1] then
|
||
local val = floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro1])))
|
||
arr[1]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f3, propertyList[pro2], val, 1))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--使用回复技能时,[a]的概率提高恢复效果[b]。
|
||
--a[float],b[float]
|
||
[7] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnPassiveTreating = function(treatingFunc)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
treatingFunc(f2)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveTreating, OnPassiveTreating)
|
||
end,
|
||
|
||
--受击后,[a]的概率,回复自身的[b]*[c]的血量
|
||
--a[float],b[属性],c[float]
|
||
[8] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local OnBeHit = function(treatingFunc)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local val = floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro])))
|
||
BattleUtil.CalTreat(role, role, val)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--受击后,[a]对攻击者造成的攻击*[c]的持续伤害,持续[d]秒。
|
||
--a[float],c[float],d[int]
|
||
[9] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
local triggerUid = {}
|
||
local OnBeHit = function(atkRole)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
if triggerUid[atkRole.uid] then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
atkRole:AddBuff(Buff.Create(role, BuffName.DOT, f3, 1, 0, 1, f2))
|
||
triggerUid[atkRole.uid] = atkRole.uid
|
||
BattleLogic.WaitForTrigger(f3+1, function ()
|
||
triggerUid[atkRole.uid] = nil
|
||
end)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--受击时[e],[a]的概率将[b]*[c]算作[d]计算
|
||
--a[float],b[属性],c[float],d[属性],e[伤害类型]
|
||
[10] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local pro2 = args[4]
|
||
local dt = args[5]
|
||
|
||
local OnRoleBeDamagedBefore = function(atkRole, func, damageType)
|
||
if damageType == dt then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role:AddPropertyTransfer(propertyList[pro1], f2, propertyList[pro2], 2, BattleLogic.GameDeltaTime)
|
||
end)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeDamagedBefore, OnRoleBeDamagedBefore)
|
||
end,
|
||
|
||
--受击时,有[a]的概率抵消[b]*[c]的攻击。
|
||
--a[float],b[属性],c[float]
|
||
[11] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local OnPassiveDamaging = function(damagingFunc, atkRole, damage)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
damagingFunc(floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro]))))
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveBeDamaging, OnPassiveDamaging)
|
||
end,
|
||
|
||
--受击后,有[a]的概率对敌方全体造成攻击*[c]的[d]伤害
|
||
--a[float],c[float],d[伤害类型]
|
||
[12] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
|
||
local lastTrigger = 0
|
||
local OnBeHit = function(atkRole)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20000)
|
||
for i=1, #arr do
|
||
BattleUtil.CalDamage(role, arr[i], dt, f2)
|
||
end
|
||
end)
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--受击后,有[a]的概率对随机1人造成[b]*[c]的真实伤害。
|
||
--a[float],b[属性],c[float]
|
||
[13] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local lastTrigger = 0
|
||
local OnBeHit = function(atkRole)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20001)
|
||
if arr[1] then
|
||
local val = floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro])))
|
||
BattleUtil.ApplyDamage(role, arr[1], val)
|
||
end
|
||
end)
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--受击后[f],[a]的概率将[b]*[c]算作[d]计算,持续[e]秒。
|
||
--a[float],b[属性],c[float],d[属性],e[int],f[伤害类型]
|
||
[14] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local pro2 = args[4]
|
||
local f3 = args[5]
|
||
local dt = args[6]
|
||
|
||
local OnBeHit = function(atkRole, damage, bCrit, finalDmg, damageType)
|
||
if damageType == dt then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role:AddPropertyTransfer(propertyList[pro1], f2, propertyList[pro2], 2, f3)
|
||
end)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--免疫[a]属性伤害。
|
||
--a[属性类型]
|
||
[15] = function(role, args)
|
||
local pt = args[1]
|
||
local elementDamageReduceFactor
|
||
if pt == 1 then
|
||
elementDamageReduceFactor = RoleDataName.FireDamageReduceFactor
|
||
elseif pt == 2 then
|
||
elementDamageReduceFactor = RoleDataName.WindDamageReduceFactor
|
||
elseif pt == 3 then
|
||
elementDamageReduceFactor = RoleDataName.IceDamageReduceFactor
|
||
elseif pt == 4 then
|
||
elementDamageReduceFactor = RoleDataName.LandDamageReduceFactor
|
||
elseif pt == 5 then
|
||
elementDamageReduceFactor = RoleDataName.LightDamageReduceFactor
|
||
elseif pt == 6 then
|
||
elementDamageReduceFactor = RoleDataName.DarkDamageReduceFactor
|
||
end
|
||
role.data:AddValue(elementDamageReduceFactor, 10000)
|
||
end,
|
||
|
||
--发动技能后,[a]的概率将[b]*[c]算作[d]计算,持续[e]秒。
|
||
--a[float],b[属性],c[float],d[属性],e[int]
|
||
[16] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local pro2 = args[4]
|
||
local f3 = args[5]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role:AddPropertyTransfer(propertyList[pro1], f2, propertyList[pro2], 2, f3)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[d]改变仇恨目标[a]属性[b],持续[c]秒
|
||
--a[属性],b[int],c[int],d[改变类型]
|
||
[17] = function(role, args)
|
||
local pro1 = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
local arr = BattleUtil.ChooseTarget(role, 40000)
|
||
if arr[1] then
|
||
arr[1]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro1], f1, ct))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[d]改变己方全体[a]属性[b],持续[c]秒
|
||
--a[属性],b[int],c[int],d[改变类型]
|
||
[18] = function(role, args)
|
||
local pro1 = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
local arr = BattleUtil.ChooseTarget(role, 10000)
|
||
for i=1, #arr do
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro1], f1, ct))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--受到治疗效果提高[a]。
|
||
--a[float]
|
||
[19] = function(role, args)
|
||
local f1 = args[1]
|
||
role.data:AddValue(RoleDataName.CureFacter, f1)
|
||
end,
|
||
|
||
--[b]造成的持续伤害时间延长[a]。
|
||
--a[int],b[改变类型]
|
||
[20] = function(role, args)
|
||
local f1 = args[1]
|
||
local ct = args[2]
|
||
|
||
local OnBuffCaster = function(buff)
|
||
if buff.type == BuffName.DOT then
|
||
if ct == 1 then --加算
|
||
buff.duration = buff.duration + f1
|
||
elseif ct == 2 then --乘加算(百分比属性加算)
|
||
buff.duration = buff.duration * (1 + f1)
|
||
elseif ct == 3 then --减算
|
||
buff.duration = buff.duration - f1
|
||
elseif ct == 4 then --乘减算(百分比属性减算)
|
||
buff.duration = buff.duration * (1 - f1)
|
||
end
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.BuffCaster, OnBuffCaster)
|
||
end,
|
||
|
||
--自身增益效果超过[a]时,技能伤害提升[b]。
|
||
--a[int],b[float]
|
||
[21] = function(role, args)
|
||
local i1 = args[1]
|
||
local f1 = args[2]
|
||
|
||
local count = 0
|
||
local targetBuff
|
||
local active = count > i1
|
||
local OnBuffStart = function(buff)
|
||
if buff.isBuff then
|
||
count = count + 1
|
||
if count > i1 and not active then
|
||
active = true
|
||
targetBuff = Buff.Create(role, BuffName.PropertyChange, 0, RoleDataName.DamageBocusFactor, f1, 1)
|
||
targetBuff.isBuff = false --自身不算增益
|
||
role:AddBuff(targetBuff)
|
||
end
|
||
end
|
||
end
|
||
local OnBuffEnd = function(buff)
|
||
if buff.isBuff then
|
||
count = count - 1
|
||
if count <= i1 and active then
|
||
active = false
|
||
if targetBuff then
|
||
targetBuff.disperse = true
|
||
end
|
||
end
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.BuffStart, OnBuffStart)
|
||
role.Event:AddEvent(BattleEventName.BuffEnd, OnBuffEnd)
|
||
end,
|
||
|
||
--血量低于[a]时,[b]概率触发控制免疫,持续[c]秒。每场战斗只能触发1次。
|
||
--a[float],b[float],c[int]
|
||
[22] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
local triggerCount = 0
|
||
local OnBeHit = function(atkRole)
|
||
if BattleUtil.GetHPPencent(role) < f1 then
|
||
if triggerCount < 1 then
|
||
BattleUtil.RandomAction(f2, function ()
|
||
role:AddBuff(Buff.Create(role, BuffName.Immune, f3, 1))
|
||
triggerCount = triggerCount + 1
|
||
end)
|
||
end
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--死亡时,立即回复己方全体[a]*[b]的血量。
|
||
--a[属性],b[float]
|
||
[23] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
|
||
local OnDead = function(atkRole)
|
||
local arr = BattleUtil.ChooseTarget(role, 10000)
|
||
for i=1, #arr do
|
||
local val = floor(BattleUtil.FP_Mul(f1, role:GetRoleData(propertyList[pro])))
|
||
BattleUtil.CalTreat(role, arr[i], val)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleDead, OnDead)
|
||
end,
|
||
|
||
--控制效果命中后,[a]的概率施加[c]的[d]伤害
|
||
--a[float],c[float],d[伤害类型]
|
||
[24] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
|
||
local OnBuffCaster = function(buff)
|
||
if buff.type == BuffName.Control then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
BattleUtil.CalDamage(role, buff.target, dt, f2)
|
||
end)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.BuffCaster, OnBuffCaster)
|
||
end,
|
||
|
||
--控制效果命中后,[a]对全体造成[c]的[d]伤害。
|
||
--a[float],c[float],d[伤害类型]
|
||
[25] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
|
||
local OnBuffCaster = function(buff)
|
||
if buff.type == BuffName.Control then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(buff.target, 10000)
|
||
for i=1, #arr do
|
||
BattleUtil.CalDamage(role, arr[i], dt, f2)
|
||
end
|
||
end)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.BuffCaster, OnBuffCaster)
|
||
end,
|
||
|
||
--造成的伤害暴击后,[a]施加攻击*[c]的[d]持续伤害,持续[e]秒。
|
||
--a[float],c[float],d[伤害类型],e[int]
|
||
[26] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
local f3 = args[4]
|
||
|
||
local triggerUid = {}
|
||
local OnRoleCrit = function(defRole)
|
||
if triggerUid[defRole.uid] then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
defRole:AddBuff(Buff.Create(role, BuffName.DOT, f3, 1, 0, dt, f2))
|
||
triggerUid[defRole.uid] = defRole.uid
|
||
BattleLogic.WaitForTrigger(f3+1, function ()
|
||
triggerUid[defRole.uid] = nil
|
||
end)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleCrit, OnRoleCrit)
|
||
end,
|
||
|
||
--造成的伤害暴击后,[a]的概率回复自身[b]*[c]的血量
|
||
--a[float],b[属性],c[float]
|
||
[27] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local OnRoleCrit = function(defRole)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local val = floor(BattleUtil.FP_Mul(f2, role:GetRoleData(propertyList[pro])))
|
||
BattleUtil.CalTreat(role, role, val)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleCrit, OnRoleCrit)
|
||
end,
|
||
|
||
--对血量高于[a]的敌人伤害提高[b]。
|
||
--a[float],b[float]
|
||
[28] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnPassiveDamaging = function(damagingFunc, defRole, damage)
|
||
if BattleUtil.GetHPPencent(defRole) > f1 then
|
||
damagingFunc(-floor(f2 * damage))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end,
|
||
|
||
--对血量低于[a]的敌人伤害提高[b]。
|
||
--a[float],b[float]
|
||
[29] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnPassiveDamaging = function(damagingFunc, defRole, damage)
|
||
if BattleUtil.GetHPPencent(defRole) < f1 then
|
||
damagingFunc(-floor(f2 * damage))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end,
|
||
|
||
--发动技能后,[d]改变敌方全体[a]属性[b],持续[c]秒
|
||
--a[属性],b[float],c[int],d[改变类型]
|
||
[30] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
local arr = BattleUtil.ChooseTarget(role, 20000)
|
||
for i=1, #arr do
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, ct))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,有[a]的概率眩晕敌方其中1人,持续[b]秒。
|
||
--a[float],b[int]
|
||
[31] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20001)
|
||
if arr[1] then
|
||
arr[1]:AddBuff(Buff.Create(role, BuffName.Control, f2, 1))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--持续伤害效果命中后,[d]改变自身[a]属性[b],持续[c]秒
|
||
--a[属性],b[float],c[int],d[改变类型]
|
||
[32] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnBuffCaster = function(buff)
|
||
if buff.type == BuffName.DOT then
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, ct))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.BuffCaster, OnBuffCaster)
|
||
end,
|
||
|
||
--[d]改变自身[a]属性[b],持续[c]秒
|
||
--a[属性],b[float],c[int],d[改变类型]
|
||
[33] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, ct))
|
||
end,
|
||
|
||
--造成伤害时,额外增加[a]点伤害。
|
||
--a[int]
|
||
[34] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local OnPassiveDamaging = function(damagingFunc)
|
||
damagingFunc(-f1)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end,
|
||
|
||
--进入战斗[a]秒后,造成的伤害提升[b],持续[c]秒
|
||
--a[int],b[float],c[int]
|
||
[35] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
BattleLogic.WaitForTrigger(f1, function ()
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f3, RoleDataName.DamageBocusFactor, f2, 1))
|
||
end)
|
||
end,
|
||
|
||
--进入战斗[a]秒后,[d]改变[b]属性[c],持续[e]秒
|
||
--a[int],b[属性],c[int],d[改变类型],e[int]
|
||
[36] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
local ct = args[4]
|
||
local f3 = args[5]
|
||
|
||
BattleLogic.WaitForTrigger(f1, function ()
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f3, propertyList[pro], f2, ct))
|
||
end)
|
||
end,
|
||
|
||
--进入战斗[a]秒后,免疫控制效果,持续[b]秒
|
||
--a[int],b[int]
|
||
[37] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
BattleLogic.WaitForTrigger(f1, function ()
|
||
role:AddBuff(Buff.Create(role, BuffName.Immune, f2, 1))
|
||
end)
|
||
end,
|
||
|
||
--每[a]秒,[d]改变[b]的[c],[g改变[e]的[f],最高叠加[h]层 (举例:每5秒,扣除10%的生命,提高5%的速度, 最高叠加5层)
|
||
--a[int],b[float],c[属性],d[改变类型],e[float],f[属性],g[改变类型],h[int]
|
||
[38] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local pro1 = args[3]
|
||
local ct1 = args[4]
|
||
local f3 = args[5]
|
||
local pro2 = args[6]
|
||
local ct2 = args[7]
|
||
local i1 = args[8]
|
||
|
||
local auraBuff = Buff.Create(role, BuffName.Aura, 0, function (r)
|
||
local changeBuff1 = Buff.Create(r, BuffName.PropertyChange, 0, propertyList[pro1], f2, ct1)
|
||
changeBuff1.cover = true
|
||
changeBuff1.maxLayer = i1
|
||
|
||
local changeBuff2 = Buff.Create(r, BuffName.PropertyChange, 0, propertyList[pro2], f3, ct2)
|
||
changeBuff2.cover = true
|
||
changeBuff2.maxLayer = i1
|
||
|
||
r:AddBuff(changeBuff1)
|
||
r:AddBuff(changeBuff2)
|
||
end)
|
||
auraBuff.interval = f1
|
||
role:AddBuff(auraBuff)
|
||
end,
|
||
|
||
--进入战斗后,每[a]秒回复[b]生命
|
||
--a[int],b[int]
|
||
[39] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local auraBuff = Buff.Create(role, BuffName.Aura, 0, function (r)
|
||
BattleUtil.CalTreat(r, r, f2)
|
||
end)
|
||
auraBuff.interval = f1
|
||
role:AddBuff(auraBuff)
|
||
end,
|
||
|
||
--被指定[a]造成伤害时,回复[b]生命
|
||
--a[职业],b[int]
|
||
[40] = function(role, args)
|
||
local i1 = args[1]
|
||
local f1 = args[2]
|
||
|
||
local OnBeHit = function(atkRole)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
if atkRole.roleData.professionId == i1 then
|
||
BattleUtil.CalTreat(role, role, f1)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
|
||
--造成伤害时,将伤害的[a]%转化为自身生命
|
||
--a[float]
|
||
[41] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local OnDamage = function(defRole, damage, bCrit, finalDmg)
|
||
BattleUtil.CalTreat(role, role, floor(f1 * finalDmg))
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleDamage, OnDamage)
|
||
end,
|
||
|
||
--造成暴击伤害时,有[a]的概率造成[b]的暴击伤害。
|
||
--a[float],b[float]
|
||
[42] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnPassiveCriting = function(crit)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
crit(f2)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveCriting, OnPassiveCriting)
|
||
end,
|
||
|
||
--发动技能后,[d]改变仇恨目标[a]属性[b],持续整场战斗,属性最多可改变[c]
|
||
--a[属性],b[float],c[float],d[改变类型]
|
||
[43] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local i1 = args[3]
|
||
local ct = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
local arr = BattleUtil.ChooseTarget(role, 40000)
|
||
if arr[1] then
|
||
local buff = Buff.Create(role, BuffName.PropertyChange, 0, propertyList[pro], f1, ct)
|
||
buff.cover = true
|
||
buff.maxLayer = i1
|
||
arr[1]:AddBuff(buff)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--发动技能后,[a]的概率[e]改变自身[b]属性[c],持续[d]秒。
|
||
--a[float],b[属性],c[float],d[int],e[改变类型]
|
||
[44] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
local ct = args[5]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f3, propertyList[pro], f2, ct))
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--免疫[a]次[b]控制状态。
|
||
--a[int],b[控制类型]
|
||
[45] = function(role, args)
|
||
local i1 = args[1]
|
||
local ct = args[2]
|
||
local triggerCount = 0
|
||
role.buffFilter:Add(function(buff)
|
||
local isTarget = buff.type == BuffName.Control and (ct == 0 or buff.ctrlType == ct)
|
||
if isTarget then
|
||
triggerCount = triggerCount + 1
|
||
return i1 == 0 or (i1 > 0 and triggerCount <= i1)
|
||
else
|
||
return isTarget
|
||
end
|
||
end)
|
||
end,
|
||
|
||
--免疫[a]持续伤害状态。
|
||
--a[持续伤害类型]
|
||
[46] = function(role, args)
|
||
local dt = args[1]
|
||
role.buffFilter:Add(function(buff)
|
||
return buff.type == BuffName.DOT and (dt == 0 or buff.damageType == dt)
|
||
end)
|
||
end,
|
||
|
||
--战斗中,[c]改变[a]属性[b]。
|
||
--a[属性],b[float],c[改变类型]
|
||
[47] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local ct = args[3]
|
||
|
||
if ct == 1 then --加算
|
||
role.data:AddValue(propertyList[pro], f1)
|
||
elseif ct == 2 then --乘加算(百分比属性加算)
|
||
role.data:AddPencentValue(propertyList[pro], f1)
|
||
elseif ct == 3 then --减算
|
||
role.data:SubValue(propertyList[pro], f1)
|
||
elseif ct == 4 then --乘减算(百分比属性减算)
|
||
role.data:SubPencentValue(propertyList[pro], f1)
|
||
end
|
||
end,
|
||
|
||
--战斗中,[c]改变[a]属性[b],[f]改变[d]属性[e]。
|
||
--a[属性],b[float],c[改变类型],d[属性],e[float],f[改变类型]
|
||
[48] = function(role, args)
|
||
local pro = args[1]
|
||
local f1 = args[2]
|
||
local ct = args[3]
|
||
local pro2 = args[4]
|
||
local f2 = args[5]
|
||
local ct2 = args[6]
|
||
|
||
if ct == 1 then --加算
|
||
role.data:AddValue(propertyList[pro], f1)
|
||
elseif ct == 2 then --乘加算(百分比属性加算)
|
||
role.data:AddPencentValue(propertyList[pro], f1)
|
||
elseif ct == 3 then --减算
|
||
role.data:SubValue(propertyList[pro], f1)
|
||
elseif ct == 4 then --乘减算(百分比属性减算)
|
||
role.data:SubPencentValue(propertyList[pro], f1)
|
||
end
|
||
|
||
if ct2 == 1 then --加算
|
||
role.data:AddValue(propertyList[pro2], f2)
|
||
elseif ct2 == 2 then --乘加算(百分比属性加算)
|
||
role.data:AddPencentValue(propertyList[pro2], f2)
|
||
elseif ct2 == 3 then --减算
|
||
role.data:SubValue(propertyList[pro2], f2)
|
||
elseif ct2 == 4 then --乘减算(百分比属性减算)
|
||
role.data:SubPencentValue(propertyList[pro2], f2)
|
||
end
|
||
end,
|
||
|
||
--发动技能后,[a]概率[e]改变敌方全体[b]属性[c],持续[d]秒
|
||
--a[float],b[属性],c[float],d[int],e[改变类型]
|
||
[49] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
local ct = args[5]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20000)
|
||
for i=1, #arr do
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f3, propertyList[pro], f2, ct))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
|
||
--战斗中,每[a]秒增加[b]%的异妖能量
|
||
--a[int],b[float]
|
||
[50] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local auraBuff = Buff.Create(role, BuffName.Aura, 0, function (r)
|
||
--BattleLogic.AddMP(role.camp, f2 * 100)
|
||
end)
|
||
auraBuff.interval = f1
|
||
BattleLogic.BuffMgr:AddBuff(role, auraBuff)
|
||
end,
|
||
|
||
--战斗中,初始拥有[a]%的异妖能量
|
||
--a[float]
|
||
[51] = function(role, args)
|
||
local f1 = args[1]
|
||
--BattleLogic.AddMP(role.camp, f1 * 100)
|
||
end,
|
||
|
||
--战斗中,队伍每损失[a]%的生命值,增加[b]%的异妖能量
|
||
--a[float],b[float]
|
||
[52] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local maxHp = 0
|
||
local curHp = 0
|
||
if f1 == 0 then
|
||
return
|
||
end
|
||
local curHpGears = 0
|
||
local arr = BattleUtil.ChooseTarget(role, 10000)
|
||
for i=1, #arr do
|
||
curHp = curHp + arr[i]:GetRoleData(RoleDataName.Hp)
|
||
maxHp = maxHp + arr[i]:GetRoleData(RoleDataName.MaxHp)
|
||
end
|
||
|
||
local auraBuff = Buff.Create(role, BuffName.Aura, 0, function (r)
|
||
local hp = 0
|
||
for i=1, #arr do
|
||
hp = hp + arr[i]:GetRoleData(RoleDataName.Hp)
|
||
end
|
||
|
||
if hp < curHp then
|
||
local gears = floor((maxHp - hp) / (f1 * maxHp))
|
||
if gears > curHpGears then
|
||
--BattleLogic.AddMP(role.camp, f2 * (gears - curHpGears) * 100)
|
||
curHpGears = gears
|
||
end
|
||
curHp = hp
|
||
end
|
||
end)
|
||
auraBuff.interval = 0
|
||
BattleLogic.BuffMgr:AddBuff(role, auraBuff)
|
||
end,
|
||
--战斗中,治疗技能有概率额外造成[a]%的治疗,概率等于自身暴击率。
|
||
--a[float]
|
||
[53] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local OnPassiveTreating = function(treatingFunc)
|
||
BattleUtil.RandomAction(role:GetRoleData(RoleDataName.Crit), function ()
|
||
treatingFunc(f1)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveTreating, OnPassiveTreating)
|
||
end,
|
||
--受击后,有[a]的概率对攻击者造成眩晕,持续[b]秒。
|
||
--a[float],b[int]
|
||
[54] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local OnBeHit = function(atkRole, damage, bCrit, finalDmg, damageType)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
atkRole:AddBuff(Buff.Create(role, BuffName.Control, f2, 1))
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
--造成伤害时,有[a]的概率立即造成攻击[b]%的伤害。
|
||
--a[float],b[float]
|
||
[55] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local lastTrigger = 0
|
||
local OnDamage = function(defRole, damage, bCrit, finalDmg)
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local val = floor(BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Attack), f2))
|
||
BattleUtil.ApplyDamage(role, defRole, val)
|
||
end)
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleHit, OnDamage)
|
||
end,
|
||
--造成暴击时,额外造成目标最大生命值[a]%的伤害。(目标最大生命值伤害总上限为施法者2.5倍攻击)
|
||
--a[float]
|
||
[56] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local lastTrigger = 0
|
||
local OnRoleCrit = function(defRole)
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
local ar1 = BattleUtil.FP_Mul(defRole:GetRoleData(RoleDataName.MaxHp), f1)
|
||
local ar2 = BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Attack), 2.5)
|
||
BattleUtil.ApplyDamage(role, defRole, floor(min(ar1, ar2)))
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleCrit, OnRoleCrit)
|
||
end,
|
||
--发动技能时,若技能目标与自身发动的上一个技能目标相同,则增加[a]%的伤害,最多叠加[b]层。
|
||
--a[float],b[int]
|
||
[57] = function(role, args)
|
||
local f1 = args[1]
|
||
local i2 = args[2]
|
||
|
||
local damageDic = {}
|
||
local lastDamageDic = {}
|
||
local OnSkillCastEnd = function(skill)
|
||
for k in pairs(damageDic) do
|
||
if lastDamageDic[k] then
|
||
damageDic[k] = damageDic[k] + 1
|
||
end
|
||
end
|
||
lastDamageDic = damageDic
|
||
damageDic = {}
|
||
end
|
||
local OnPassiveDamaging = function(damagingFunc, defRole, damage)
|
||
if lastDamageDic[defRole] then
|
||
local layer = i2 == 0 and lastDamageDic[defRole] or min(i2, lastDamageDic[defRole])
|
||
damagingFunc(-floor(f1 * layer * damage))
|
||
damageDic[defRole] = lastDamageDic[defRole]
|
||
else
|
||
damageDic[defRole] = 1
|
||
end
|
||
end
|
||
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
role.Event:AddEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end,
|
||
--发动技能后,每个敌方角色有[a]概率获得[b],每秒造成[c]%的[d]伤害,持续[e]秒。
|
||
--a[float],b[持续伤害类型],c[float],d[伤害类型],e[int]
|
||
[58] = function(role, args)
|
||
local f1 = args[1]
|
||
local d1 = args[2]
|
||
local f2 = args[3]
|
||
local dt = args[4]
|
||
local f3 = args[5]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
local arr = BattleUtil.ChooseTarget(role, 20000)
|
||
for i=1, #arr do
|
||
BattleUtil.RandomAction(f1, function ()
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.DOT, f3, 1, d1, dt, f2))
|
||
end)
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
--每隔[a]秒,抵挡一个负面状态。(控制 dot 减益)
|
||
--a[int]
|
||
[59] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local count = 0
|
||
role.buffFilter:Add(function(buff)
|
||
local b = buff.isDeBuff or buff.type == BuffName.DOT or buff.type == BuffName.Control
|
||
if b then
|
||
count = count + 1
|
||
end
|
||
return b and count <= 1
|
||
end)
|
||
|
||
local auraBuff = Buff.Create(role, BuffName.Aura, 0, function (r)
|
||
count = 0
|
||
end)
|
||
auraBuff.interval = f1
|
||
BattleLogic.BuffMgr:AddBuff(role, auraBuff)
|
||
end,
|
||
--我方生命最低的其他角色受到技能攻击后,自身[a]的概率对攻击者造成攻击[b]%的[c]伤害,并造成[d],持续[e]秒。若自身处于沉默或眩晕状态,则不会触发。播放攻击特效,特效时间[f]秒。
|
||
--a[float],b[float],c[伤害类型],d[控制状态],e[int],f[float]
|
||
[60] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
local ct = args[4]
|
||
local f3 = args[5]
|
||
local f4 = args[6]
|
||
|
||
local triggerUid = {}
|
||
BattleLogic.Event:AddEvent(BattleEventName.RoleBeDamaged, function (defRole, atkRole, damage, bCrit, finalDmg, damageType, isDot)
|
||
if atkRole.isTeam or role.isDead or isDot then
|
||
return
|
||
end
|
||
if triggerUid[atkRole.uid] then --加入限定避免循环触发
|
||
return
|
||
end
|
||
if not BattleLogic.BuffMgr:HasBuff(role, BuffName.Control, function (buff) return buff.ctrlType == 1 or buff.ctrlType == 2 end) then
|
||
local arr = BattleUtil.ChooseTarget(role, 10110)
|
||
local target
|
||
if arr[1] then
|
||
if arr[1] == role and arr[2] then
|
||
target = arr[2]
|
||
else
|
||
target = arr[1]
|
||
end
|
||
end
|
||
if defRole == target then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role.Event:DispatchEvent(BattleEventName.RoleViewBullet, f4, atkRole)
|
||
BattleLogic.WaitForTrigger(f4, function ()
|
||
triggerUid[atkRole.uid] = atkRole.uid
|
||
BattleUtil.CalDamage(role, atkRole, dt, f2)
|
||
atkRole:AddBuff(Buff.Create(role, BuffName.Control, f3, ct))
|
||
triggerUid[atkRole.uid] = nil
|
||
end)
|
||
end)
|
||
end
|
||
end
|
||
end)
|
||
end,
|
||
--自身受到的非暴击伤害,可以转化[a]%的伤害为自身攻击,持续[b]秒。上限自身攻击的[c]%。
|
||
--a[float],b[int],c[float]
|
||
[61] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
local OnBeHit = function(atkRole, damage, bCrit, finalDmg, damageType)
|
||
if not bCrit then
|
||
local ar1 = BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Attack), f3)
|
||
local ar2 = BattleUtil.FP_Mul(damage, f1)
|
||
role:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, RoleDataName.Attack, floor(min(ar1, ar2)), 1))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
--发动技能后,有[a]的概率为自身及相邻加持[b][c]%的护盾,持续[d]秒。
|
||
--a[float],b[属性],c[float],d[int]
|
||
[62] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
|
||
local OnSkillCastEnd = function(skill)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local list = BattleLogic.GetNeighbor(role, 1)
|
||
for i=1, #list do
|
||
local val = floor(BattleUtil.FP_Mul(role:GetRoleData(propertyList[pro]), f2))
|
||
list[i]:AddBuff(Buff.Create(role, BuffName.Shield, f3, val, 0))
|
||
end
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
end,
|
||
--自身拥有护盾时,我方角色每次释放技能后,有[a]概率回复[b]%的[c]的治疗。
|
||
--a[float],b[float],c[属性]
|
||
[63] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local pro1 = args[3]
|
||
|
||
BattleLogic.Event:AddEvent(BattleEventName.SkillCastEnd, function (skill)
|
||
if skill.owner.isTeam then
|
||
return
|
||
end
|
||
if skill.owner.camp == role.camp then
|
||
if BattleLogic.BuffMgr:HasBuff(role, BuffName.Shield, function (buff) return true end) then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local val = floor(BattleUtil.FP_Mul(role:GetRoleData(propertyList[pro1]), f2))
|
||
BattleUtil.CalTreat(role, skill.owner, val)
|
||
end)
|
||
end
|
||
end
|
||
end)
|
||
end,
|
||
--基于生命损失的百分比,受到的伤害降低[b]%。
|
||
--a[float]
|
||
[64] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local OnPassiveDamaging = function(damagingFunc, atkRole, damage)
|
||
damagingFunc(floor(BattleUtil.FP_Mul(f1, damage,1-BattleUtil.GetHPPencent(role))))
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveBeDamaging, OnPassiveDamaging)
|
||
end,
|
||
--我方角色死亡时,对击杀者造成[a]%的[b]伤害,令其眩晕,持续[c]秒。
|
||
--a[float],b[伤害类型],c[int]
|
||
[65] = function(role, args)
|
||
local f1 = args[1]
|
||
local dt = args[2]
|
||
local f2 = args[3]
|
||
|
||
BattleLogic.Event:AddEvent(BattleEventName.BattleRoleDead, function (defRole, atkRole)
|
||
if role.isDead or atkRole.isTeam then
|
||
return
|
||
end
|
||
if defRole.camp == role.camp then
|
||
BattleUtil.CalDamage(role, atkRole, dt, f1)
|
||
atkRole:AddBuff(Buff.Create(role, BuffName.Control, f2, 1))
|
||
end
|
||
end)
|
||
end,
|
||
--免疫减益状态。
|
||
--无
|
||
[66] = function(role, args)
|
||
role.buffFilter:Add(function(buff)
|
||
return buff.isDeBuff
|
||
end)
|
||
end,
|
||
--敌方累计发动[a]次技能,有[b]概率发动(发动特效),对敌方全体造成眩晕效果,持续[c]秒。然后清空累计次数。播放攻击特效,特效时间[d]秒。
|
||
--a[int],b[float],c[float]
|
||
[67] = function(role, args)
|
||
local i1 = args[1]
|
||
local f1 = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
|
||
local count = 0
|
||
BattleLogic.Event:AddEvent(BattleEventName.SkillCast, function (skill)
|
||
if skill.owner.isTeam or role.isDead then
|
||
return
|
||
end
|
||
if skill.owner.camp ~= role.camp then
|
||
count = count + 1
|
||
if count == i1 then
|
||
BattleUtil.RandomAction(f1, function ()
|
||
role.Event:DispatchEvent(BattleEventName.AOE, 1-role.camp)
|
||
BattleLogic.WaitForTrigger(f3, function ()
|
||
local arr = BattleUtil.ChooseTarget(role, 20000)
|
||
for i=1, #arr do
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.Control, f2, 1))
|
||
end
|
||
end)
|
||
end)
|
||
count = 0
|
||
end
|
||
end
|
||
end)
|
||
end,
|
||
--受到伤害后,[a]概率为自身施加[b]的[c]%的护盾。持续[d]秒。
|
||
--a[float],b[属性],c[float],d[int]
|
||
[68] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro1 = args[2]
|
||
local f2 = args[3]
|
||
local f3 = args[4]
|
||
|
||
local OnBeHit = function(atkRole, damage, bCrit, finalDmg, damageType)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
local val = floor(BattleUtil.FP_Mul(role:GetRoleData(propertyList[pro1]), f2))
|
||
role:AddBuff(Buff.Create(role, BuffName.Shield, f3, val, 0))
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
--造成暴击时,额外造成目标最大生命值[a]%的伤害。造成伤害时,有[a]的概率立即造成攻击[b]%的伤害,该伤害造成的暴击伤害不会触发额外最大生命值伤害。(效果55+效果56)(目标最大生命值伤害总上限为施法者5倍攻击)
|
||
--a[float],b[float],c[float]
|
||
[69] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local f3 = args[3]
|
||
|
||
local lastTrigger = 0
|
||
local OnDamage = function(defRole, damage, bCrit, finalDmg)
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
if bCrit then
|
||
local ar1 = BattleUtil.FP_Mul(defRole:GetRoleData(RoleDataName.MaxHp), f1)
|
||
local ar2 = BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Attack), 5)
|
||
BattleUtil.ApplyDamage(role, defRole, floor(min(ar1, ar2)))
|
||
else
|
||
BattleUtil.RandomAction(f2, function ()
|
||
local val = floor(BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Attack), f3))
|
||
BattleUtil.ApplyDamage(role, defRole, val)
|
||
end)
|
||
end
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleDamage, OnDamage)
|
||
end,
|
||
--击杀每个敌人会永久增加[a]%的[b],持续[c]秒。(0表示永久)(不可驱散)
|
||
--a[float],b[属性],c[int]
|
||
[70] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local OnKill = function(defRole)
|
||
local buff = Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, 2)
|
||
buff.cover = true
|
||
buff.clear = false
|
||
role:AddBuff(buff)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleKill, OnKill)
|
||
end,
|
||
--受击后,[a]对攻击者造成自身[c]%的[d]伤害。
|
||
--a[float],c[float],d[伤害类型]
|
||
[71] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
local dt = args[3]
|
||
|
||
local lastTrigger = 0
|
||
local OnBeHit = function(atkRole, damage, bCrit, finalDmg, damageType)
|
||
if atkRole.isTeam then
|
||
return
|
||
end
|
||
lastTrigger = lastTrigger + 1
|
||
if lastTrigger > 1 then --加入限定避免循环触发
|
||
return
|
||
end
|
||
BattleUtil.RandomAction(f1, function ()
|
||
BattleUtil.CalDamage(role, atkRole, dt, f2)
|
||
end)
|
||
lastTrigger = 0
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleBeHit, OnBeHit)
|
||
end,
|
||
--造成的伤害暴击时,有[a]概率在计算伤害时额外计算[b]的暴击伤害。
|
||
--a[float],b[float]
|
||
[72] = function(role, args)
|
||
local f1 = args[1]
|
||
local f2 = args[2]
|
||
|
||
local OnPassiveCriting = function(crit)
|
||
BattleUtil.RandomAction(f1, function ()
|
||
crit(role:GetRoleData(RoleDataName.CritDamageFactor)+f2)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.PassiveCriting, OnPassiveCriting)
|
||
end,
|
||
--释放技能时,自己损失[a]%当前生命值,为此次技能增加等量伤害。
|
||
--a[float]
|
||
[73] = function(role, args)
|
||
local f1 = args[1]
|
||
|
||
local hp=0
|
||
local OnPassiveDamaging = function(damagingFunc, defRole, damage)
|
||
damagingFunc(-hp)
|
||
end
|
||
local OnSkillCast, OnSkillCastEnd
|
||
OnSkillCast = function(skill)
|
||
hp = floor(BattleUtil.FP_Mul(role:GetRoleData(RoleDataName.Hp), f1))
|
||
role.data:SubValue(RoleDataName.Hp, hp)
|
||
|
||
role.Event:RemoveEvent(BattleEventName.SkillCast, OnSkillCast)
|
||
role.Event:AddEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
role.Event:AddEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end
|
||
OnSkillCastEnd = function(skill)
|
||
BattleLogic.WaitForTrigger(BattleLogic.GameDeltaTime, function () --延迟一帧移除事件,防止触发帧和结束帧为同一帧时,被动未移除
|
||
role.Event:RemoveEvent(BattleEventName.SkillCastEnd, OnSkillCastEnd)
|
||
role.Event:RemoveEvent(BattleEventName.PassiveDamaging, OnPassiveDamaging)
|
||
end)
|
||
end
|
||
role.Event:AddEvent(BattleEventName.SkillCast, OnSkillCast)
|
||
end,
|
||
--死亡时,为所有我方角色增加[a]%的[b]属性,持续[c]秒。
|
||
--a[float],b[属性],c[int]
|
||
[74] = function(role, args)
|
||
local f1 = args[1]
|
||
local pro = args[2]
|
||
local f2 = args[3]
|
||
|
||
local OnDead = function(atkRole)
|
||
local arr = BattleUtil.ChooseTarget(role, 10000)
|
||
for i=1, #arr do
|
||
arr[i]:AddBuff(Buff.Create(role, BuffName.PropertyChange, f2, propertyList[pro], f1, 2))
|
||
end
|
||
end
|
||
role.Event:AddEvent(BattleEventName.RoleDead, OnDead)
|
||
end,
|
||
}
|
||
return passivityList |