Thoughts on KillUnit

[Dirac]

Hello again, i realized i had a major leak issue in one of my triggers because i was Killing the dummy of a projectile instead of Removing it. But removing it causes the effect to dissapear instantly and i don't want that either, how and when is a unit removed after killed? Am i supposed to remove also all the other low frequency dummys instead of killing them?

 

[DarkNovaKing]

How do you make a dummy projectile?

 

[Ayanami]

2 solutions. One, play the death effect via triggers. Two, on the dummy's death, use a timer to remove it after a few seconds.

 

[Dirac]

Timers kill unit, it dosnt remove it

 

[vypur85]

I believe he meant this:

Event
 A unit dies
Condition
 Your Unit Type
Actions
 Wait 1.00 seconds
 Unit - Remove (Triggering unit)

Alternatively, you can set the decay time in Gameplay Constant to be lower. But it affects all units throughout. So it's up to your preference.

 

[Ayanami]

Timers kill unit, it dosnt remove it

Timer as in using a the "timer", not "expiration timer".

 

[Dirac]

well basically yes, i would have to create a system that provides me the following function lol
call TimedRemoveUnit(unit,wait)
and removes the unit when the specified "wait" is over

 

[Ayanami]

Perhaps something like this?

library TimedRemoveUnit

globals
    private constant real PERIOD = 0.1 // timer update frequency
endglobals

struct Timed
    thistype next
    thistype prev
    unit u
    real r
    static timer linkTimer = CreateTimer()
    static integer linkCount = 0
    
    private static method iterate takes nothing returns nothing
        local thistype this = thistype(0)
        
        loop
            set this = this.next
            exitwhen this == 0
            
            if this.dur <= 0 then
                set this.next.prev = this.prev
                set this.prev.next = this.next
                
                set linkCount = linkCount - 1
                if linkCount == 0 then
                    call PauseTimer(linkTimer)
                endif
                
                call RemoveUnit(this.u)
                call this.deallocate()
            else
                set this.dur = this.dur - PERIOD
            endif
    endmethod
    
    public static method removeUnit takes unit u, real r returns nothing
        local thistype this = thistype.allocate()
        set thistype(0).next.prev = this
        set this.next = thistype(0).next
        set thistype(0).next = this
        set this.prev = thistype(0)
        
        if linkCount == 0 then
            call TimerStart(linkTimer, PERIOD, true, function thistype.iterate)
        endif
        set linkCount = linkCount + 1
        
        set this.u = u
        set this.r = r
    endmethod
endstruct

endlibrary

Then you would do something like:

call Timed.removeUnit(DummyUnit, 5.)

 

[Mindless]

I don't know Ayanami, I believe iteration is best avoided as I heard it uses a lot of memory. Sorry for not coming up with any other solution, but I was just pointing out a possible issue with Ayanami's solution. I may be wrong, but I just heard iteration is really slow, especially if you have a lot of "dummy unit projectiles".

 

[Dirac]

Mindless is right, and wrong. There's a way to recode Ayanami's system but it would mean using lots of timers, one per dummy, instead of one static timer. So i woudnt really know what's slower or faster

 

[Ayanami]

I don't know Ayanami, I believe iteration is best avoided as I heard it uses a lot of memory. Sorry for not coming up with any other solution, but I was just pointing out a possible issue with Ayanami's solution. I may be wrong, but I just heard iteration is really slow, especially if you have a lot of "dummy unit projectiles".

I believe it's better to have one static timer running all instances rather than multiple timers running one instance each.

 

[Solmyr]

Mindless is right, and wrong. There's a way to recode Ayanami's system but it would mean using lots of timers, one per dummy, instead of one static timer. So i woudnt really know what's slower or faster

Just use TimerUtils.

 

[MasterOfRa]

Or Strilanc's Decal (delayed call) Library

 

[Dirac]

I made this recently, i think it's a great solution.

library RemoveDummy uses TimerUtils
    globals
        private integer DUMMY = 'h000'
        private real WAIT = 1.
    endglobals

    private struct Removal
        timer t
        unit u
    endstruct
    
    private function removeUnit takes nothing returns nothing
        local Removal s = GetTimerData(GetExpiredTimer())
        call RemoveUnit(s.u)
        call ReleaseTimer(GetExpiredTimer())
        call s.destroy()
    endfunction
    
    private function detect takes unit u returns nothing
        local Removal s
        if GetUnitTypeId(u) == DUMMY then
            set s = Removal.create()
            set s.u = u
            set s.t = NewTimer()
            call SetTimerData(s.t,s)
            call TimerStart(s.t,WAIT,false,function removeUnit)
        endif
    endfunction
    
    hook KillUnit detect
endlibrary

How does it work? Everytime you kill a dummy with KillUnit() it creates a 1 second timer and then removes it from the game, modify the WAIT value to change the delay

 

[Jedi]

Aren't Dead units already removed from game after a while?Or have you tried UnitApplyTimedLife with other life types?

 

[Dirac]

It's not the same being removed after 40 secs as being removed after 1 second, if a spell creates a huge amount of units it causes lag