Triggers

//TESH.scrollpos=3
//TESH.alwaysfold=0
scope Firestorm initializer OnInit

//=====================================================================//
//                       CONFIGURATION                                 //
//=====================================================================//

globals
    private constant integer ABILID = 'ABFS' // raw code of ability "Firestorm"
    private constant integer DUMMYID = 'h002' // raw code of unit "Firestorm Dummy"
    private constant real AOE = 500.0 // area of effect
    private constant real MAXHEIGHT = 500.0 // maximum height of fireballs
    private constant real SPEED = 1000.0 // knockback speed (per second)
    private constant real HRATE = 250.0 // rate of change in height (per second)
    private constant real OFFRATE = 500.0 // rate of change in distance (per second)
    private constant real KNOCKBACK = 300.00 // knockback distance
endglobals

private function GetFireCount takes integer level returns integer
    return level * 3 // number of fireballs
endfunction

private function GetDamage takes integer level returns real
    return level * 50.0 // damage per fireball
endfunction

//=====================================================================//
//                       END CONFIGURATION                             //
//=====================================================================//

globals
    private hashtable HASH = InitHashtable()
    private group GROUP = CreateGroup()
    private unit FILTER
    private unit CASTER
    private unit FIRE
endglobals

native UnitAlive takes unit id returns boolean

private struct Firestorm
    real damage
    real interval
    integer count
    group firegroup
    unit caster
endstruct

private struct Knockback
    real damage
    real height
    real speed
    real interval
    real x
    real y
    real angle
    real dist
    boolean check
    unit caster
    unit fire
    unit target
endstruct

private function GroupFilter takes nothing returns boolean
    local unit u = GetFilterUnit()
    if IsUnitEnemy(u, GetOwningPlayer(CASTER)) and UnitAlive(u) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not LoadBoolean(HASH, GetHandleId(u), 0) then
        set FILTER = u
    endif
    set u = null
    return false
endfunction

private function GroupFunc takes nothing returns nothing
    local real x = GetUnitX(FILTER)
    local real y = GetUnitY(FILTER)
    local real mindist = 99999.0
    local unit u = GetEnumUnit()
    local real dx = GetUnitX(u) - x
    local real dy = GetUnitY(u) - y
    local real dist = SquareRoot(dx * dx + dy * dy)
    if dist < mindist then
        set FIRE = u
        set mindist = dist
    endif
    set u = null
endfunction

private function DamageKnock takes nothing returns boolean
    local Knockback k = KT_GetData()
    local real dx
    local real dy
    local real x
    local real y
    local real a
    local effect e
    if k.dist <= 0 and k.check then
        call k.destroy()
        call SaveBoolean(HASH, GetHandleId(k.target), 0, false)
        call FlushChildHashtable(HASH, GetHandleId(k.target))
        set e = null
        return true
    endif
    if k.check then
        set x = GetUnitX(k.target)
        set y = GetUnitY(k.target)
        set a = Atan2(y - k.y, x - k.x)
        set x = x + k.speed * Cos(k.angle)
        set y = y + k.speed * Sin(k.angle)
        call SetUnitPosition(k.target, x, y)
        set k.dist = k.dist - k.speed
    else
        set dx = GetUnitX(k.fire)
        set dy = GetUnitY(k.fire)
        set x = GetUnitX(k.target) - dx
        set y = GetUnitY(k.target) - dy
        if SquareRoot(x * x + y * y) <= 50 then
            call UnitDamageTarget(k.caster, k.target, k.damage, true, false, ATTACK_TYPE_NORMAL, DAMAGE_TYPE_NORMAL, WEAPON_TYPE_WHOKNOWS)
            set e = AddSpecialEffect("Abilities\\Weapons\\RedDragonBreath\\RedDragonMissile.mdl", dx, dy)
            call DestroyEffect(e)
            set e = AddSpecialEffect("Objects\\Spawnmodels\\Other\\NeutralBuildingExplosion\\NeutralBuildingExplosion.mdl", dx, dy)
            call DestroyEffect(e)
            set k.x = GetUnitX(k.caster)
            set k.y = GetUnitY(k.caster)
            set k.dist = KNOCKBACK
            set k.angle = Atan2(GetUnitY(k.target) - dy, GetUnitX(k.target) - dx)
            call RemoveUnit(k.fire)
            set k.check = true
        else
            set k.height = (GetUnitFlyHeight(k.fire) - 50) / ((SquareRoot(x * x + y * y) / SPEED) / k.interval)
            call SetUnitFlyHeight(k.fire, GetUnitFlyHeight(k.fire) - k.height, 0)
            set x = x + dx
            set y = y + dy
            set a = Atan2(y - dy, x - dx)
            set x = dx + k.speed * Cos(a)
            set y = dy + k.speed * Sin(a)
            call SetUnitPosition(k.fire, x, y)
            call SetUnitFacing(k.fire, a * bj_RADTODEG)
        endif
    endif
    set e = null
    return false
endfunction

globals
    private group Periodic_group
endglobals
private function Periodic takes nothing returns boolean
    local Firestorm d = KT_GetData()
    local Knockback k
    local real a
    local real x
    local real y
    local real dx = GetUnitX(d.caster)
    local real dy = GetUnitY(d.caster)
    local real r
    local real min
    local real max
    local unit u
    if d.count == 0 then
        call Group.release(d.firegroup)
        call d.destroy()
        return true
    endif
    set CASTER = d.caster
    set FILTER = null
    call GroupEnumUnitsInRange(GROUP, GetUnitX(d.caster), GetUnitY(d.caster), AOE, Filter(function GroupFilter))
    if FILTER != null then
        set k = Knockback.create()
        call ForGroup(d.firegroup, function GroupFunc)
        set k.damage = d.damage
        set k.speed = d.interval * SPEED
        set k.interval = 0.04
        set k.check = false
        set k.caster = d.caster
        set k.fire = FIRE
        set k.target = FILTER
        call SaveBoolean(HASH, GetHandleId(k.target), 0, true)
        call KT_Add(function DamageKnock, k, k.interval)
        call FlushChildHashtable(HASH, GetHandleId(k.fire))
        call GroupRemoveUnit(d.firegroup, FIRE)
        set d.count = d.count - 1
    endif
    set Periodic_group = Group.get()
    call GroupAddGroup(d.firegroup, Periodic_group)
    loop
        set u = FirstOfGroup(Periodic_group)
        exitwhen u == null
        set x = GetUnitX(u) - dx
        set y = GetUnitY(u) - dy
        set a = GetUnitFacing(u)
        if SquareRoot(x * x + y * y) >= AOE then
            set a = a + GetRandomReal(0, 90.0)
            call SaveBoolean(HASH, GetHandleId(u), 0, true)
        elseif SquareRoot(x * x + y * y) <= 150.0 then
            set a = a + GetRandomReal(-90.0, 0)
            call SaveBoolean(HASH, GetHandleId(u), 0, false)
        else
            if LoadBoolean(HASH, GetHandleId(u), 0) then
                set a = a + GetRandomReal(-15.0, 45.0)
            else
                set a = a + GetRandomReal(-45.0, 15.0)
            endif
        endif
        set x = GetUnitX(u) + GetRandomReal(0, (d.interval * OFFRATE)) * Cos(a * bj_DEGTORAD)
        set y = GetUnitY(u) + GetRandomReal(0, (d.interval * OFFRATE)) * Sin(a * bj_DEGTORAD)
        set a = 90.0 + (Atan2(y - dy, x - dx) * bj_RADTODEG)
        call SetUnitPosition(u, x, y)
        call SetUnitFacing(u, a)
        set r = GetUnitFlyHeight(u)
        if not LoadBoolean(HASH, GetHandleId(u), 1) then
            if r >= MAXHEIGHT then
                call SaveBoolean(HASH, GetHandleId(u), 1, true)
                set r = 0
            else
                set r = GetRandomReal(0.0, d.interval * HRATE)
            endif
        else
            if r <= 50 then
                call SaveBoolean(HASH, GetHandleId(u), 1, false)
                set r = 0
            else
                set r = GetRandomReal(-d.interval * HRATE, 0)
            endif
        endif
        set r = GetUnitFlyHeight(u) + r
        call SetUnitFlyHeight(u, r, 0)
        call GroupRemoveUnit(Periodic_group, u)
    endloop
    call Group.release(Periodic_group)
    return false
endfunction

private function Actions takes nothing returns nothing
    local Firestorm d = Firestorm.create()
    local real a
    local real x
    local real y
    local integer i
    local integer loopmax
    local integer level
    local unit u
    set d.caster = GetTriggerUnit()
    set d.firegroup = Group.get()
    set level = GetUnitAbilityLevel(d.caster, ABILID)
    set d.damage = GetDamage(level)
    set d.interval = 0.04
    set d.count = 0
    set loopmax = GetFireCount(level)
    set i = 0
    loop
        exitwhen i == loopmax
        set x = GetUnitX(d.caster) + GetRandomReal(100.0, AOE) * Cos(GetRandomReal(0.0, 360.0) * bj_DEGTORAD)
        set y = GetUnitY(d.caster) + GetRandomReal(100.0, AOE) * Sin(GetRandomReal(0.0, 360.0) * bj_DEGTORAD)
        set a = 90.0 + Atan2(y - GetUnitY(d.caster), x - GetUnitX(d.caster)) * bj_RADTODEG
        set u = CreateUnit(GetOwningPlayer(d.caster), DUMMYID, x, y, a)
        call SetUnitFlyHeight(u, GetRandomReal(50.0, MAXHEIGHT), 0)
        call SaveBoolean(HASH, GetHandleId(u), 0, false)
        call SaveBoolean(HASH, GetHandleId(u), 1, false)
        call GroupAddUnit(d.firegroup, u)
        set d.count = d.count + 1
        set i = i + 1
    endloop
    call KT_Add(function Periodic, d, d.interval)
    set u = null
endfunction

private function Conditions takes nothing returns boolean
    return GetSpellAbilityId() == ABILID
endfunction

private function OnInit takes nothing returns nothing
    local trigger t = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function Conditions))
    call TriggerAddAction(t, function Actions)
endfunction

endscope

//TESH.scrollpos=24
//TESH.alwaysfold=0
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~ KT ~~ Key Timers 2 ~~ By Jesus4Lyf ~~ Version 1.7.3 ~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//  What is Key Timers?
//         - Key Timers attaches structs to timers, or more to the point timed
//           effects.
//         - You can specify different periods.
//         - Key Timers only uses one timer with one trigger per low period
//           to keep things efficient, especially within the looping.
//         - Key Timers alternatively uses one trigger per instance for all higher
//           periods to allow accurate expirations in a stable and efficient fashion.
//
//    =Pros=
//         - Easy to use.
//         - Fastest attachment loading system (storing in parallel arrays).
//         - Fastest execution system for low periods (all functions on one trigger).
//         - Allows multiple periods to be used.
//         - No H2I. Backwards compatability through patch 1.23 and 1.24.
//
//    =Cons=
//         - The code passed into KT2 must call KT_GetData exactly once.
//         - Periods must be a multiple of 0.00125 seconds. Not 0.007, for example.
//
//    Functions:
//         - KT_Add(userFunc, struct, period)
//         - KT_GetData returns the struct
//
//         - userFunc is to be a user function that takes nothing and returns boolean.
//           It will be executed by the system every period until it returns true.
//
//         - KT_GetData is to be used inside func, it will return the struct passed to
//           to the Add function. It must be called exactly once within the func.
//
//  Details:
//         - KT2 treats low periods and high periods differently, optimizing each
//           with appropriate speed and accuracy, although this effect is invisible
//           to you, the mapper.
//
//         - While func returns false the timer will continue to call it each period.
//           Once func returns true the instance will be detached from system.
//
//  Thanks:
//         - Daxtreme: For encouraging me to return to Key Timers 2, rather than
//           leave it to rot. His interest in the system restored it, and helped
//           it to become what it is now. :)
//
//         - Captain Griffen: For his work on Rapid Timers, demonstrating that it
//           is possible to attach all functions to one trigger, and that it is
//           indeed faster.
//
//         - Cohadar: Told me to make Key Timers without a textmacro.
//           Thanks to him for helping me with the original Key Timers system too.
//           Also, I'd like to thank him for his work on Timer Ticker (TT) which
//           demonstrated how to use triggers/conditions in this sort of system,
//           which has been used in Key Timers 2.
//
//  How to import:
//         - Create a trigger named KT.
//         - Convert it to custom text and replace the whole trigger text with this.
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
library KT
    ///////////////
    // Constants //
    ////////////////////////////////////////////////////////////////////////////
    // That bit that users may play with if they know what they're doing.
    // Not touching these at all is recommended.
    globals
        // Period Threshold is the point at which Key Timers 2 will switch from
        // using the single timer per period mechanism to using TAZO, which is
        // better for higher periods due to the first tick being accurate.
        private constant real PERIODTHRESHOLD=0.3 // MUST be below 10.24 seconds.
        
        // Tazo's number of precached instances. You can go over this during
        // your map at runtime, but it will probably do some small background
        // processing. Precaching just speeds things up a bit.
        private constant integer TAZO_PRECACHE=64
        
        // Tazo uses the low period part of Key Timers 2 to construct triggers
        // over time when precached ones run out. Here you can set the period used.
        private constant real TAZO_CONSTRUCT_PERIOD=0.03125
    endglobals
    
    //////////////////////////
    // Previous KT2 Globals //
    ////////////////////////////////////////////////////////////////////////////
    // These needed to be moved here for TAZO to hook GetData.
    globals
        private timer array KeyTimer
        private trigger array TimerTrigger
        private integer array KeyTimerListPointer
        private integer array KeyTimerListEndPointer
        private triggercondition array TriggerCond
        private boolexpr array Boolexpr
        private integer array Data
        private integer array Next
        private integer array Prev
        private integer TrigMax=0
        private integer array NextMem
        private integer NextMemMaxPlusOne=1
        private integer array ToAddMem
        private triggercondition array ToRemove
        private boolexpr array ToDestroy
        private boolean array IsAdd
        private integer AddRemoveMax=0
        
        // Locals
        private integer t_id=-1
        private integer t_mem
        private integer t_lastmem
        private integer a_id
        private integer a_mem
        
        // Code Chunks
        private conditionfunc RemoveInstanceCond
    endglobals
    
    //////////////////
    // Previous KT2 //
    ////////////////////////////////////////////////////////////////////////////
    // The KT2 implementation
    private function KeyTimerLoop takes nothing returns nothing
        set t_id=R2I(TimerGetTimeout(GetExpiredTimer())*800)
        set t_mem=KeyTimerListEndPointer[t_id]
        call TriggerEvaluate(TimerTrigger[t_id])
        set t_mem=0
        loop
            exitwhen t_mem==AddRemoveMax
            set t_mem=t_mem+1
            if IsAdd[t_mem] then
                set TriggerCond[ToAddMem[t_mem]]=TriggerAddCondition(TimerTrigger[t_id],Boolexpr[ToAddMem[t_mem]])
            else
                call TriggerRemoveCondition(TimerTrigger[t_id],ToRemove[t_mem])
                call DestroyBoolExpr(ToDestroy[t_mem])
            endif
        endloop
        set AddRemoveMax=0
        set t_id=-1
    endfunction
    
    private function RemoveInstance takes nothing returns boolean
        // Will only fire if code returns true.
        set AddRemoveMax=AddRemoveMax+1
        set IsAdd[AddRemoveMax]=false
        set ToRemove[AddRemoveMax]=TriggerCond[t_lastmem]
        set ToDestroy[AddRemoveMax]=Boolexpr[t_lastmem]
        if Next[t_lastmem]==0 then
            set KeyTimerListEndPointer[t_id]=Prev[t_lastmem]
        endif
        set Prev[Next[t_lastmem]]=Prev[t_lastmem]
        if Prev[t_lastmem]==0 then
            set KeyTimerListPointer[t_id]=Next[t_lastmem]
            if KeyTimerListPointer[t_id]<1 then
                call PauseTimer(KeyTimer[t_id])
            endif
        else
            set Next[Prev[t_lastmem]]=Next[t_lastmem]
        endif
        set NextMem[NextMemMaxPlusOne]=t_lastmem
        set NextMemMaxPlusOne=NextMemMaxPlusOne+1
        return false
    endfunction
    
    private function KTadd takes code func, integer data, real period returns nothing
        set a_id=R2I(period*800)
        
        if KeyTimer[a_id]==null then
            set KeyTimer[a_id]=CreateTimer()
            set TimerTrigger[a_id]=CreateTrigger()
        endif
        
        if NextMemMaxPlusOne==1 then
            set TrigMax=TrigMax+1
            set a_mem=TrigMax
        else
            set NextMemMaxPlusOne=NextMemMaxPlusOne-1
            set a_mem=NextMem[NextMemMaxPlusOne]
        endif
        
        set Boolexpr[a_mem]=And(Condition(func),RemoveInstanceCond)
        if t_id==a_id then
            set AddRemoveMax=AddRemoveMax+1
            set IsAdd[AddRemoveMax]=true
            set ToAddMem[AddRemoveMax]=a_mem
        else
            if KeyTimerListPointer[a_id]<1 then
                call TimerStart(KeyTimer[a_id],a_id/800.0,true,function KeyTimerLoop)
                set KeyTimerListEndPointer[a_id]=a_mem
            endif
            
            set TriggerCond[a_mem]=TriggerAddCondition(TimerTrigger[a_id],Boolexpr[a_mem])
        endif
        set Data[a_mem]=data
        
        set Prev[a_mem]=0
        set Next[a_mem]=KeyTimerListPointer[a_id]
        set Prev[KeyTimerListPointer[a_id]]=a_mem
        set KeyTimerListPointer[a_id]=a_mem
    endfunction
    
    public function GetData takes nothing returns integer // Gets hooked by TAZO.
        set t_lastmem=t_mem
        set t_mem=Prev[t_mem]
        return Data[t_lastmem]
    endfunction
    
    private function KTinit takes nothing returns nothing
        set RemoveInstanceCond=Condition(function RemoveInstance)
    endfunction
    
    //////////
    // TAZO //
    ////////////////////////////////////////////////////////////////////////////
    // KT2 implementation for higher periods (low frequency).
    globals
        private constant integer TAZO_DATAMEM=8190 // Added for KT2 hook. Don't change.
    endglobals
    
    globals
        private conditionfunc TAZO_LoadDataCond
        private conditionfunc TAZO_RemoveInstanceCond
        
        private timer   array TAZO_TrigTimer
        private integer array TAZO_Data
        private boolexpr array TAZO_Boolexpr
        
        private trigger array TAZO_AvailableTrig
        private integer       TAZO_Max=0
        
        private integer       TAZO_ConstructNext=0
        private trigger array TAZO_ConstructTrig
        private integer array TAZO_ConstructCount
    endglobals
    
    globals//locals
        private integer TAZO_ConKey
    endglobals
    private function TAZO_Constructer takes nothing returns boolean
        set TAZO_ConKey=GetData()
        call TriggerExecute(TAZO_ConstructTrig[TAZO_ConKey])
        set TAZO_ConstructCount[TAZO_ConKey]=TAZO_ConstructCount[TAZO_ConKey]-1
        if TAZO_ConstructCount[TAZO_ConKey]==0 then
            set TAZO_Max=TAZO_Max+1
            set TAZO_AvailableTrig[TAZO_Max]=TAZO_ConstructTrig[TAZO_ConKey]
            set TAZO_TrigTimer[TAZO_ConKey]=CreateTimer()
            call TriggerRegisterTimerExpireEvent(TAZO_AvailableTrig[TAZO_Max],TAZO_TrigTimer[TAZO_ConKey])
            return true
        endif
        return false
    endfunction
    
    globals//locals
        private trigger TAZO_DeadTrig
        private integer TAZO_DeadCount
    endglobals
    private function TAZO_Recycle takes nothing returns boolean
        set TAZO_DeadTrig=GetTriggeringTrigger()
        set TAZO_DeadCount=GetTriggerExecCount(TAZO_DeadTrig)
        call TriggerClearConditions(TAZO_DeadTrig)
        call DestroyBoolExpr(TAZO_Boolexpr[TAZO_DeadCount])
        call PauseTimer(TAZO_TrigTimer[TAZO_DeadCount])
        set TAZO_Max=TAZO_Max+1
        set TAZO_AvailableTrig[TAZO_Max]=TAZO_DeadTrig
        return false
    endfunction
    
    private function TAZO_LoadData takes nothing returns boolean
        // KT2 Data Hook
        set t_mem=TAZO_DATAMEM
        set Data[TAZO_DATAMEM]=TAZO_Data[GetTriggerExecCount(GetTriggeringTrigger())]
        // End KT2 Data Hook
        return false
    endfunction
    
    private function InitTrigExecCount takes trigger t, integer d returns nothing
        if d>128 then
            call InitTrigExecCount.execute(t,d-128)
            set d=128
        endif
        loop
            exitwhen d==0
            set d=d-1
            call TriggerExecute(t)
        endloop
    endfunction
    
    globals//locals
        private integer TAZO_AddKey
        private trigger TAZO_AddTrigger
    endglobals
    public function TAZOadd takes code func, integer data, real period returns nothing
        if TAZO_Max==0 then
            // Failsafe.
            set TAZO_ConstructNext=TAZO_ConstructNext+1
            set TAZO_AddTrigger=CreateTrigger()
            set TAZO_AddKey=TAZO_ConstructNext
            call InitTrigExecCount.execute(TAZO_AddTrigger,TAZO_AddKey)
            set TAZO_TrigTimer[TAZO_AddKey]=CreateTimer()
            call TriggerRegisterTimerExpireEvent(TAZO_AddTrigger,TAZO_TrigTimer[TAZO_AddKey])
        else
            set TAZO_AddTrigger=TAZO_AvailableTrig[TAZO_Max]
            set TAZO_AddKey=GetTriggerExecCount(TAZO_AddTrigger)
            set TAZO_Max=TAZO_Max-1
        endif
        set TAZO_Data[TAZO_AddKey]=data
        set TAZO_Boolexpr[TAZO_AddKey]=And(Condition(func),TAZO_RemoveInstanceCond)
        call TriggerAddCondition(TAZO_AddTrigger,TAZO_LoadDataCond)
        call TriggerAddCondition(TAZO_AddTrigger,TAZO_Boolexpr[TAZO_AddKey])
        call TimerStart(TAZO_TrigTimer[TAZO_AddKey],period,true,null)
        if TAZO_Max<10 then
            set TAZO_ConstructNext=TAZO_ConstructNext+1
            set TAZO_ConstructTrig[TAZO_ConstructNext]=CreateTrigger()
            set TAZO_ConstructCount[TAZO_ConstructNext]=TAZO_ConstructNext
            call KTadd(function TAZO_Constructer,TAZO_ConstructNext,TAZO_CONSTRUCT_PERIOD)
        endif
    endfunction
    
    private function TAZOinit takes nothing returns nothing
        set TAZO_LoadDataCond=Condition(function TAZO_LoadData)
        set TAZO_RemoveInstanceCond=Condition(function TAZO_Recycle)
        // Allow for GetData
        set Next[TAZO_DATAMEM]=TAZO_DATAMEM
        set Prev[TAZO_DATAMEM]=TAZO_DATAMEM
        // End allow for GetData
        loop
            exitwhen TAZO_Max==TAZO_PRECACHE
            set TAZO_ConstructNext=TAZO_ConstructNext+1 // The index.
            set TAZO_Max=TAZO_Max+1 // Will be the same in the initialiser as ConstructNext.
            set TAZO_AvailableTrig[TAZO_Max]=CreateTrigger()
            call InitTrigExecCount.execute(TAZO_AvailableTrig[TAZO_Max],TAZO_ConstructNext)
            set TAZO_TrigTimer[TAZO_ConstructNext]=CreateTimer()
            call TriggerRegisterTimerExpireEvent(TAZO_AvailableTrig[TAZO_Max],TAZO_TrigTimer[TAZO_ConstructNext])
        endloop
    endfunction
    
    ///////////////
    // Interface //
    ////////////////////////////////////////////////////////////////////////////
    // Stitches it all together neatly.
    public function Add takes code func, integer data, real period returns nothing
        if period<PERIODTHRESHOLD then
            call KTadd(func,data,period)
        else
            call TAZOadd(func,data,period)
        endif
    endfunction
    
    private module InitModule
        private static method onInit takes nothing returns nothing
            call KTinit()
            call TAZOinit()
        endmethod
    endmodule
    
    private struct InitStruct extends array
        implement InitModule
    endstruct
endlibrary

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//    End of Key Timers 2
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//TESH.scrollpos=0
//TESH.alwaysfold=0
library Recycle
//settings
globals
    public constant boolean AUTO_CLEAR = true
endglobals
/*Utility Information
//===================================================================
Name: Recycle
Version: 6.0
Author: Nestharus
-Help from Jesus4Lyf for initial designs

Description:
    What does it do-
        Recycles handles so that when getting new handles of the same type,
        a recycled handle can be returned instead of creating a new handle. This
        increases map performance.
        
Requirements: NA

Installation: NA

Variables:
------------------------------------------------------------------
AUTO_CLEAN-
    If true, will automatically clear out recycled handles (GroupClear,
    PauseTimer) at a slight performance hit.

Functions:
------------------------------------------------------------------
-get returns type
    will return the type
    
    Timer.get()
    Group.get()
    
    ex-
    timer t = Timer.get()

-release(type h)
    Will release the type and stop it.
    
    Timer.release(h)
    Group.release(h)
    
    ex-
    timer t = Timer.get()
    Timer.release(t)
------------------------------------------------------------------*/
    //! textmacro CREATE_STACK takes name, type, clean, create
        struct $name$ extends array
            public $type$ handles
            public static integer index = 0
            
            public static method release takes $type$ h returns nothing
                static if DEBUG_MODE then
                    if h == null then
                        call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "ERROR - Recycle: Freed null handle.")
                    endif
                    if $name$.index > 8190 then
                        call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "ERROR - Recycle: Overfilled recycle stack (8191 released objects)!")
                    endif
                endif
                static if AUTO_CLEAR then
                    $clean$
                endif
                set $name$[$name$.index].handles = h
                set $name$.index = $name$.index + 1
            endmethod

            public static method get takes nothing returns $type$
                if $name$.index == 0 then
                    return $create$
                endif
                set $name$.index = $name$.index - 1
                return $name$[$name$.index].handles
            endmethod
        endstruct
    //! endtextmacro
    
    //! runtextmacro CREATE_STACK("Timer", "timer", "call PauseTimer(h)", "CreateTimer()")
    //! runtextmacro CREATE_STACK("Group", "group", "call GroupClear(h)", "CreateGroup()")
endlibrary