achmad
342 lines
13 KiB
Lua
342 lines
13 KiB
Lua
local ____lualib = require("lualib_bundle")
|
|
local __TS__Class = ____lualib.__TS__Class
|
|
local __TS__ClassExtends = ____lualib.__TS__ClassExtends
|
|
local __TS__Decorate = ____lualib.__TS__Decorate
|
|
local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
|
|
local __TS__ArrayFindIndex = ____lualib.__TS__ArrayFindIndex
|
|
local __TS__ArraySort = ____lualib.__TS__ArraySort
|
|
local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
|
|
local ____exports = {}
|
|
local ____dota_ts_adapter = require("lib.dota_ts_adapter")
|
|
local BaseAbility = ____dota_ts_adapter.BaseAbility
|
|
local BaseModifier = ____dota_ts_adapter.BaseModifier
|
|
local registerAbility = ____dota_ts_adapter.registerAbility
|
|
local registerModifier = ____dota_ts_adapter.registerModifier
|
|
local ____crit_mult = require("utils.crit_mult")
|
|
local getFinalStackingCritMultiplier = ____crit_mult.getFinalStackingCritMultiplier
|
|
local CRIT_LUCK_ADDITIVE_PERCENT_PER_POINT = 1
|
|
____exports.ability_stacking_crit = __TS__Class()
|
|
local ability_stacking_crit = ____exports.ability_stacking_crit
|
|
ability_stacking_crit.name = "ability_stacking_crit"
|
|
ability_stacking_crit.____file_path = "scripts/vscripts/abilities/modifiers/ability_stacking_crit.lua"
|
|
__TS__ClassExtends(ability_stacking_crit, BaseAbility)
|
|
function ability_stacking_crit.prototype.GetIntrinsicModifierName(self)
|
|
return "modifier_stacking_crit"
|
|
end
|
|
ability_stacking_crit = __TS__Decorate(
|
|
ability_stacking_crit,
|
|
ability_stacking_crit,
|
|
{registerAbility(nil)},
|
|
{kind = "class", name = "ability_stacking_crit"}
|
|
)
|
|
____exports.ability_stacking_crit = ability_stacking_crit
|
|
____exports.modifier_stacking_crit = __TS__Class()
|
|
local modifier_stacking_crit = ____exports.modifier_stacking_crit
|
|
modifier_stacking_crit.name = "modifier_stacking_crit"
|
|
modifier_stacking_crit.____file_path = "scripts/vscripts/abilities/modifiers/ability_stacking_crit.lua"
|
|
__TS__ClassExtends(modifier_stacking_crit, BaseModifier)
|
|
function modifier_stacking_crit.prototype.____constructor(self, ...)
|
|
BaseModifier.prototype.____constructor(self, ...)
|
|
self.critModifiers = {}
|
|
self.guaranteedCritCount = 0
|
|
self.guaranteedCritUntilDestroy = false
|
|
self.wasCrit = false
|
|
self.pendingGuaranteedCritConsume = false
|
|
self.forcedTargetCritEntityIndex = nil
|
|
self.lastCritChance = 0
|
|
self.lastCritMult = 1
|
|
end
|
|
function modifier_stacking_crit.GetForUnit(self, unit)
|
|
local mod = unit:FindModifierByName("modifier_stacking_crit")
|
|
return mod and mod or nil
|
|
end
|
|
function modifier_stacking_crit.prototype.RemoveOnDeath(self)
|
|
return false
|
|
end
|
|
function modifier_stacking_crit.prototype.IsPurgable(self)
|
|
return false
|
|
end
|
|
function modifier_stacking_crit.prototype.IsHidden(self)
|
|
return true
|
|
end
|
|
function modifier_stacking_crit.prototype.DeclareFunctions(self)
|
|
return {MODIFIER_PROPERTY_PREATTACK_CRITICALSTRIKE, MODIFIER_EVENT_ON_ATTACK_LANDED, MODIFIER_PROPERTY_MAGICAL_RESISTANCE_DIRECT_MODIFICATION}
|
|
end
|
|
function modifier_stacking_crit.prototype.GetModifierMagicalResistanceDirectModification(self)
|
|
return self:GetParent():GetIntellect(true) * -0.1
|
|
end
|
|
function modifier_stacking_crit.prototype.GetModifierPreAttack_CriticalStrike(self, params)
|
|
if not IsServer() then
|
|
return 0
|
|
end
|
|
self.wasCrit = false
|
|
self.lastCritChance = 0
|
|
self.lastCritMult = 1
|
|
local totalBonus = 0
|
|
local parent = self:GetParent()
|
|
local target = params and params.target
|
|
if self.forcedTargetCritEntityIndex ~= nil and target and IsValidEntity(target) and target:GetEntityIndex() == self.forcedTargetCritEntityIndex then
|
|
self.forcedTargetCritEntityIndex = nil
|
|
if #self.critModifiers > 0 then
|
|
local baseCritMult = 0
|
|
__TS__ArrayForEach(
|
|
self.critModifiers,
|
|
function(____, critData)
|
|
baseCritMult = baseCritMult + critData.mult / 100
|
|
end
|
|
)
|
|
local finalMult = getFinalStackingCritMultiplier(nil, parent, baseCritMult)
|
|
self.wasCrit = true
|
|
self.lastCritMult = finalMult
|
|
self.lastCritChance = 100
|
|
return finalMult * 100
|
|
end
|
|
end
|
|
if self.guaranteedCritUntilDestroy and #self.critModifiers > 0 then
|
|
print((("[STACKING_CRIT] guaranteedCritUntilDestroy=TRUE, unit=" .. parent:GetUnitName()) .. ", crits=") .. tostring(#self.critModifiers))
|
|
local baseCritMult = 0
|
|
__TS__ArrayForEach(
|
|
self.critModifiers,
|
|
function(____, critData)
|
|
print((((((("[STACKING_CRIT] source=" .. critData.source) .. " chance=") .. tostring(critData.chance)) .. " mult=") .. tostring(critData.mult)) .. " entityIndex=") .. tostring(critData.entityIndex or -1))
|
|
baseCritMult = baseCritMult + critData.mult / 100
|
|
end
|
|
)
|
|
local finalMult = getFinalStackingCritMultiplier(nil, parent, baseCritMult)
|
|
print((("[STACKING_CRIT] baseCritMult_sum=" .. tostring(baseCritMult)) .. " finalMult=") .. tostring(finalMult))
|
|
self.wasCrit = true
|
|
self.lastCritMult = finalMult
|
|
self.lastCritChance = 100
|
|
return finalMult * 100
|
|
end
|
|
if self.guaranteedCritCount > 0 and #self.critModifiers > 0 then
|
|
local baseCritMult = 0
|
|
__TS__ArrayForEach(
|
|
self.critModifiers,
|
|
function(____, critData)
|
|
baseCritMult = baseCritMult + critData.mult / 100
|
|
end
|
|
)
|
|
local finalMult = getFinalStackingCritMultiplier(nil, parent, baseCritMult)
|
|
self.pendingGuaranteedCritConsume = true
|
|
self.wasCrit = true
|
|
self.lastCritMult = finalMult
|
|
self.lastCritChance = 100
|
|
return finalMult * 100
|
|
end
|
|
local hadAnyCrit = false
|
|
local bestProcChance = 0
|
|
__TS__ArrayForEach(
|
|
self.critModifiers,
|
|
function(____, critData)
|
|
local luck = parent and parent:IsHero() and getLuck(nil, parent) or 0
|
|
local effectiveChance = parent and parent:IsHero() and luck > 0 and math.min(
|
|
100,
|
|
math.max(0, critData.chance + luck * CRIT_LUCK_ADDITIVE_PERCENT_PER_POINT)
|
|
) or critData.chance
|
|
if parent and parent:IsHero() and luck > 0 then
|
|
end
|
|
if RollPseudoRandomPercentage(
|
|
effectiveChance,
|
|
1,
|
|
self:GetParent()
|
|
) then
|
|
totalBonus = totalBonus + critData.mult / 100
|
|
hadAnyCrit = true
|
|
if effectiveChance > bestProcChance then
|
|
bestProcChance = effectiveChance
|
|
end
|
|
end
|
|
end
|
|
)
|
|
if hadAnyCrit then
|
|
local baseCritMult = totalBonus
|
|
local finalMult = getFinalStackingCritMultiplier(nil, parent, baseCritMult)
|
|
self.wasCrit = true
|
|
self.lastCritChance = bestProcChance
|
|
self.lastCritMult = finalMult
|
|
return finalMult * 100
|
|
end
|
|
return 0
|
|
end
|
|
function modifier_stacking_crit.prototype.ForceNextCritOnTarget(self, target)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
if not target or not IsValidEntity(target) or target:IsNull() then
|
|
self.forcedTargetCritEntityIndex = nil
|
|
return
|
|
end
|
|
self.forcedTargetCritEntityIndex = target:GetEntityIndex()
|
|
end
|
|
function modifier_stacking_crit.prototype.OnCreated(self)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
self:ClearCritModifiers()
|
|
end
|
|
function modifier_stacking_crit.prototype.ClearCritModifiers(self)
|
|
self.critModifiers = {}
|
|
end
|
|
function modifier_stacking_crit.prototype.UpdateCrit(self, oldChance, oldMult, newChance, newMult, source)
|
|
if source == nil then
|
|
source = "ability"
|
|
end
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
if newChance < 0 and newMult <= 0 then
|
|
self:RemoveCrit(source)
|
|
return
|
|
end
|
|
self:UpdateExistingCrit(newChance, newMult, source)
|
|
end
|
|
function modifier_stacking_crit.prototype.UpdateExistingCrit(self, chance, mult, source, entity)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
if chance < 0 and mult <= 0 then
|
|
self:RemoveCrit(source, entity)
|
|
return
|
|
end
|
|
local entityIndex = entity and entity:GetEntityIndex()
|
|
local existingIndex = __TS__ArrayFindIndex(
|
|
self.critModifiers,
|
|
function(____, crit)
|
|
if crit.source ~= source then
|
|
return false
|
|
end
|
|
if entityIndex ~= nil then
|
|
return crit.entityIndex == entityIndex
|
|
end
|
|
return true
|
|
end
|
|
)
|
|
if existingIndex ~= -1 then
|
|
self.critModifiers[existingIndex + 1].chance = chance
|
|
self.critModifiers[existingIndex + 1].mult = mult
|
|
if entityIndex ~= nil then
|
|
self.critModifiers[existingIndex + 1].entityIndex = entityIndex
|
|
end
|
|
else
|
|
local ____self_critModifiers_4 = self.critModifiers
|
|
____self_critModifiers_4[#____self_critModifiers_4 + 1] = {chance = chance, mult = mult, source = source, entityIndex = entityIndex}
|
|
end
|
|
__TS__ArraySort(
|
|
self.critModifiers,
|
|
function(____, a, b) return b.chance - a.chance end
|
|
)
|
|
end
|
|
function modifier_stacking_crit.prototype.AddCustomCrit(self, chance, mult, source, entity)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
if chance < 0 and mult <= 0 then
|
|
return
|
|
end
|
|
local entityIndex = entity and entity:GetEntityIndex()
|
|
local existingIndex = __TS__ArrayFindIndex(
|
|
self.critModifiers,
|
|
function(____, crit) return crit.source == source and crit.entityIndex == entityIndex end
|
|
)
|
|
if existingIndex ~= -1 then
|
|
self.critModifiers[existingIndex + 1] = {chance = chance, mult = mult, source = source, entityIndex = entityIndex}
|
|
else
|
|
local ____self_critModifiers_7 = self.critModifiers
|
|
____self_critModifiers_7[#____self_critModifiers_7 + 1] = {chance = chance, mult = mult, source = source, entityIndex = entityIndex}
|
|
end
|
|
__TS__ArraySort(
|
|
self.critModifiers,
|
|
function(____, a, b) return b.chance - a.chance end
|
|
)
|
|
end
|
|
function modifier_stacking_crit.prototype.GuaranteeNextCrit(self, count)
|
|
if count == nil then
|
|
count = 1
|
|
end
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
self.guaranteedCritCount = math.max(0, self.guaranteedCritCount + count)
|
|
end
|
|
function modifier_stacking_crit.prototype.GuaranteeCritUntilDestroy(self, enable)
|
|
if enable == nil then
|
|
enable = true
|
|
end
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
self.guaranteedCritUntilDestroy = enable
|
|
end
|
|
function modifier_stacking_crit.prototype.OnAttackLanded(self, event)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
if event.attacker ~= self:GetParent() then
|
|
return
|
|
end
|
|
if self.pendingGuaranteedCritConsume then
|
|
self.guaranteedCritCount = math.max(0, self.guaranteedCritCount - 1)
|
|
self.pendingGuaranteedCritConsume = false
|
|
end
|
|
local parent = self:GetParent()
|
|
local target = event.target
|
|
if not parent or not target then
|
|
return
|
|
end
|
|
if self.wasCrit then
|
|
local avgTrue = parent:GetAverageTrueAttackDamage(target)
|
|
local approxDamage = math.floor((avgTrue or 0) * (self.lastCritMult or 1))
|
|
if self:GetParent():GetUnitName() == "npc_dota_hero_phantom_assassin" then
|
|
EmitSoundOn("Hero_PhantomAssassin.CoupDeGrace", target)
|
|
local effect_cast = ParticleManager:CreateParticle("particles/units/heroes/hero_phantom_assassin/phantom_assassin_crit_impact.vpcf", PATTACH_POINT_FOLLOW, target)
|
|
ParticleManager:SetParticleControlEnt(
|
|
effect_cast,
|
|
0,
|
|
target,
|
|
PATTACH_POINT_FOLLOW,
|
|
"attach_hitloc",
|
|
target:GetOrigin(),
|
|
true
|
|
)
|
|
ParticleManager:SetParticleControl(
|
|
effect_cast,
|
|
1,
|
|
target:GetAbsOrigin()
|
|
)
|
|
ParticleManager:SetParticleControlForward(
|
|
effect_cast,
|
|
1,
|
|
(parent:GetOrigin() - target:GetOrigin()):Normalized()
|
|
)
|
|
ParticleManager:ReleaseParticleIndex(effect_cast)
|
|
end
|
|
self.wasCrit = false
|
|
end
|
|
end
|
|
function modifier_stacking_crit.prototype.RemoveCrit(self, source, entity)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
local entityIndex = entity and entity:GetEntityIndex()
|
|
self.critModifiers = __TS__ArrayFilter(
|
|
self.critModifiers,
|
|
function(____, crit) return not (crit.source == source and crit.entityIndex == entityIndex) end
|
|
)
|
|
end
|
|
function modifier_stacking_crit.prototype.OnDestroy(self)
|
|
if not IsServer() then
|
|
return
|
|
end
|
|
self.critModifiers = {}
|
|
self.guaranteedCritUntilDestroy = false
|
|
end
|
|
modifier_stacking_crit = __TS__Decorate(
|
|
modifier_stacking_crit,
|
|
modifier_stacking_crit,
|
|
{registerModifier(nil)},
|
|
{kind = "class", name = "modifier_stacking_crit"}
|
|
)
|
|
____exports.modifier_stacking_crit = modifier_stacking_crit
|
|
return ____exports
|