Dota-Zombie-Invasion/scripts/vscripts/abilities/heroes/bloodhunter/ability_illusion_of_blood.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 ____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 ____ability_bloodrage = require("abilities.heroes.bloodhunter.ability_bloodrage")
local modifier_bloodrage_buff = ____ability_bloodrage.modifier_bloodrage_buff
local modifier_bloodrage_count = ____ability_bloodrage.modifier_bloodrage_count
____exports.ability_illusion_of_blood = __TS__Class()
local ability_illusion_of_blood = ____exports.ability_illusion_of_blood
ability_illusion_of_blood.name = "ability_illusion_of_blood"
ability_illusion_of_blood.____file_path = "scripts/vscripts/abilities/heroes/bloodhunter/ability_illusion_of_blood.lua"
__TS__ClassExtends(ability_illusion_of_blood, BaseAbility)
function ability_illusion_of_blood.prototype.____constructor(self, ...)
    BaseAbility.prototype.____constructor(self, ...)
    self.illusions = {}
end
function ability_illusion_of_blood.prototype.GetHealthCost(self, level)
    return 0
end
function ability_illusion_of_blood.prototype.CastFilterResult(self)
    local caster = self:GetCaster()
    if not caster:HasModifier(modifier_bloodrage_buff.name) then
        return UF_FAIL_CUSTOM
    end
    local modif = caster:FindModifierByName(modifier_bloodrage_buff.name)
    if not modif then
        return UF_FAIL_CUSTOM
    end
    local healthCost = self:GetHealthCost(self:GetLevel())
    if modif:GetStackCount() < healthCost then
        return UF_FAIL_CUSTOM
    end
    return UF_SUCCESS
end
function ability_illusion_of_blood.prototype.GetCustomCastError(self)
    local caster = self:GetCaster()
    if not caster:HasModifier(modifier_bloodrage_buff.name) then
        return "#dota_hud_error_havent_charges"
    end
    local modif = caster:FindModifierByName(modifier_bloodrage_buff.name)
    if not modif then
        return "#dota_hud_error_havent_charges"
    end
    local healthCost = self:GetHealthCost(self:GetLevel())
    if modif:GetStackCount() < healthCost then
        return "#dota_hud_error_havent_charges"
    end
    return ""
end
function ability_illusion_of_blood.prototype.OnSpellStart(self)
    if not IsServer() then
        return
    end
    local caster = self:GetCaster()
    local healthCost = self:GetHealthCost(self:GetLevel())
    local modif = caster:FindModifierByName(modifier_bloodrage_buff.name)
    if modif then
        modif:SetStackCount(modif:GetStackCount() - healthCost)
    end
    local invDuration = self:GetSpecialValueFor("invuln_duration")
    caster:AddNewModifier(caster, self, ____exports.modifier_illusion_of_blood.name, {duration = 0.5})
end
ability_illusion_of_blood = __TS__Decorate(
    ability_illusion_of_blood,
    ability_illusion_of_blood,
    {registerAbility(nil)},
    {kind = "class", name = "ability_illusion_of_blood"}
)
____exports.ability_illusion_of_blood = ability_illusion_of_blood
____exports.modifier_illusion_of_blood = __TS__Class()
local modifier_illusion_of_blood = ____exports.modifier_illusion_of_blood
modifier_illusion_of_blood.name = "modifier_illusion_of_blood"
modifier_illusion_of_blood.____file_path = "scripts/vscripts/abilities/heroes/bloodhunter/ability_illusion_of_blood.lua"
__TS__ClassExtends(modifier_illusion_of_blood, BaseModifier)
function modifier_illusion_of_blood.prototype.____constructor(self, ...)
    BaseModifier.prototype.____constructor(self, ...)
    self.imageCount = 0
    self.imageDuration = 0
    self.incomingDamage = 0
    self.outgoingDamage = 0
    self.magicResistance = 0
    self.illusions = {}
    self.spawnLoc = {}
    self.spawnedUnits = 0
end
function modifier_illusion_of_blood.prototype.IsHidden(self)
    return true
end
function modifier_illusion_of_blood.prototype.IsPurgable(self)
    return true
end
function modifier_illusion_of_blood.prototype.IsDebuff(self)
    return false
end
function modifier_illusion_of_blood.prototype.IsBuff(self)
    return true
end
function modifier_illusion_of_blood.prototype.RemoveOnDeath(self)
    return true
end
function modifier_illusion_of_blood.prototype.AllowIllusionDuplicate(self)
    return false
end
function modifier_illusion_of_blood.prototype.CheckState(self)
    return {
        [MODIFIER_STATE_INVULNERABLE] = true,
        [MODIFIER_STATE_NO_HEALTH_BAR] = true,
        [MODIFIER_STATE_UNSELECTABLE] = true,
        [MODIFIER_STATE_OUT_OF_GAME] = true,
        [MODIFIER_STATE_ROOTED] = true,
        [MODIFIER_STATE_UNTARGETABLE] = true
    }
end
function modifier_illusion_of_blood.prototype.OnCreated(self)
    if not IsServer() then
        return
    end
    local ability = self:GetAbility()
    if not ability then
        return
    end
    self.imageCount = ability:GetSpecialValueFor("images_count")
    self.imageDuration = ability:GetSpecialValueFor("illusion_duration")
    self.incomingDamage = ability:GetSpecialValueFor("incoming_damage")
    self.outgoingDamage = ability:GetSpecialValueFor("outgoing_damage")
    self.magicResistance = ability:GetSpecialValueFor("magic_resistance")
    local caster = self:GetParent()
    self.illusions = {}
    caster:Purge(
        false,
        true,
        false,
        false,
        false
    )
    caster:Stop()
    local abilityInstance = ability
    if abilityInstance ~= nil and abilityInstance ~= nil and abilityInstance.illusions ~= nil and abilityInstance.illusions ~= nil then
        for ____, illusion in ipairs(abilityInstance.illusions) do
            if IsValidEntity(illusion) and illusion:IsAlive() then
                illusion:ForceKill(false)
            end
        end
        abilityInstance.illusions = {}
    end
    local distance = 135
    local spawn = {}
    spawn[1] = caster:GetAbsOrigin()
    local rightVector = caster:GetRightVector():Normalized()
    local forwardVector = caster:GetForwardVector():Normalized()
    spawn[2] = spawn[1] + rightVector * distance
    spawn[3] = spawn[1] + rightVector * -distance
    spawn[4] = spawn[1] + forwardVector * -distance
    spawn[5] = spawn[1] + forwardVector * distance
    local realPos = RandomInt(0, #spawn - 1)
    self.spawnSelf = spawn[realPos + 1]
    self.spawnLoc = {}
    do
        local i = 0
        while i < self.imageCount do
            local sp = i
            if sp == realPos then
                sp = self.imageCount + 1
            end
            self.spawnLoc[i + 1] = spawn[sp + 1]
            i = i + 1
        end
    end
    self.spawnedUnits = 0
    self.effectCast = ParticleManager:CreateParticle("particles/units/heroes/hero_chaos_knight/chaos_knight_phantasm.vpcf", PATTACH_ABSORIGIN, caster)
    ParticleManager:SetParticleControl(self.effectCast, 0, spawn[1])
    self:AddParticle(
        self.effectCast,
        false,
        false,
        -1,
        false,
        false
    )
    EmitSoundOn("Hero_ChaosKnight.Phantasm", caster)
end
function modifier_illusion_of_blood.prototype.CreateIllusionAndAdd(self, caster, location)
    if not IsServer() then
        return
    end
    local ability = self:GetAbility()
    if not ability then
        return
    end
    local function modifyIllusion(____, illusion)
        if not illusion:IsRealHero() then
            return
        end
        local heroIllusion = illusion
        local heroCaster = caster
        heroIllusion:SetForwardVector(heroCaster:GetForwardVector())
        while heroIllusion:GetLevel() < heroCaster:GetLevel() do
            heroIllusion:HeroLevelUp(false)
        end
        heroIllusion:SetAbilityPoints(0)
        do
            local i = 0
            while i < 24 do
                local casterAbility = heroCaster:GetAbilityByIndex(i)
                local illusionAbility = heroIllusion:GetAbilityByIndex(i)
                if casterAbility and illusionAbility then
                    illusionAbility:SetLevel(casterAbility:GetLevel())
                end
                i = i + 1
            end
        end
        do
            local slot = 0
            while slot <= 5 do
                local item = heroCaster:GetItemInSlot(slot)
                if item then
                    heroIllusion:AddItemByName(item:GetName())
                end
                slot = slot + 1
            end
        end
        heroIllusion:MakeIllusion()
        heroIllusion:SetControllableByPlayer(
            heroCaster:GetPlayerID(),
            false
        )
        heroIllusion:SetOwner(heroCaster)
        illusion:AddNewModifier(caster, ability, "modifier_illusion", {duration = self.imageDuration, outgoing_damage = self.outgoingDamage, incoming_damage = self.incomingDamage})
        illusion:AddNewModifier(caster, ability, modifier_bloodrage_buff.name, {duration = 100})
        illusion:AddNewModifier(caster, ability, modifier_bloodrage_count.name, {duration = 100})
        illusion:SetBaseMagicalResistanceValue(self.magicResistance)
        local abilityInstance = ability
        if abilityInstance ~= nil and abilityInstance ~= nil then
            if abilityInstance.illusions == nil or abilityInstance.illusions == nil then
                abilityInstance.illusions = {}
            end
            local ____abilityInstance_illusions_0 = abilityInstance.illusions
            ____abilityInstance_illusions_0[#____abilityInstance_illusions_0 + 1] = illusion
        end
    end
    CreateUnitByNameAsync(
        caster:GetUnitName(),
        location,
        false,
        caster,
        caster,
        caster:GetTeamNumber(),
        function(illusion) return modifyIllusion(nil, illusion) end
    )
end
function modifier_illusion_of_blood.prototype.OnDestroy(self)
    if not IsServer() then
        return
    end
    if self.spawnSelf then
        FindClearSpaceForUnit(
            self:GetParent(),
            self.spawnSelf,
            true
        )
    end
    local loop = true
    while loop do
        if self.spawnedUnits < #self.spawnLoc then
            self:CreateIllusionAndAdd(
                self:GetParent(),
                self.spawnLoc[self.spawnedUnits + 1]
            )
            self.spawnedUnits = self.spawnedUnits + 1
            if self.spawnedUnits >= self.imageCount then
                loop = false
            end
        else
            loop = false
        end
    end
end
modifier_illusion_of_blood = __TS__Decorate(
    modifier_illusion_of_blood,
    modifier_illusion_of_blood,
    {registerModifier(nil)},
    {kind = "class", name = "modifier_illusion_of_blood"}
)
____exports.modifier_illusion_of_blood = modifier_illusion_of_blood
return ____exports