Triggers

function IsObjectEditorTarget takes unit u, integer flags returns boolean
	local integer filter = 0xFFFE07FE//Strip out the flags that are different depending on context e.g. enemy
	local integer inputflags = BlzBitAnd(flags,filter)
	local integer unitflags = BlzBitAnd(BlzGetUnitIntegerField(u,UNIT_IF_TARGETED_AS),filter)
	return BlzBitAnd(unitflags,inputflags) > 0
endfunction

//TESH.scrollpos=0
//TESH.alwaysfold=0
/*****************************************************************************
*
*    Get Closest Widget
*        by Spinnaker v2.0.0.0
*
*      Special thanks to Troll-Brain
*
******************************************************************************
*
*    This snippet contains several functions which returns closest
*       widget to given coordinates and passed filter.
*
******************************************************************************
*
*    Requirements:
*       Snippet optionaly requires IsDestructableTree,
*       enabling user to choose if enumerated should be all destructables
*       or only tree-type ones, therefore gives option to get closest tree.
*
******************************************************************************
*
*    Important:
*       Performance drop depends on amount of objects currently on the map
*       Snippet functions are designed to reduce the search time as much as
*       posible, although it's recommended to use non specific functions
*       wisely, especialy if your map contains large numbers of widgets.
*
******************************************************************************
*
*    Functions:
*       function  GetClosestItem takes real x, real y, boolexpr filter returns item
*          - Gets single item, nearest passed coordinates
*       function GetClosestItemInRange takes real x, real y, real radius, boolexpr filter returns item
*          - Returns single item, closest to coordinates in given range
*
*       function GetClosestDestructable takes real x, real y, boolean treeOnly, boolexpr filter returns destructable
*          - Gets single destructable, nearest passed coordinates
*       function GetClosestDestructableInRange takes real x, real y, real radius, boolean treeOnly, boolexpr filter returns destructable
*          - Retrieves single destructable, closest to coordinates in given range
*
*       function GetClosestUnit takes real x, real y, boolexpr filter returns unit
*          - Returns closest unit matching specific filter
*       function GetClosestUnitInRange takes real x, real y, real radius, boolexpr filter returns unit
*          - Gets nearest unit in range matching specific filter
*       function GetClosestUnitInGroup takes real x, real y, group g returns unit
*          - Retrieves closest unit in given group
*
*       function GetClosestNUnitsInRange takes real x, real y, real radius, integer n, group g, boolexpr filter returns nothing
*          - Returns up to N nearest units in range of passed coordinates
*       function GetClosestNUnitsInGroup takes real x, real y, integer n, group sourceGroup, group destGroup returns nothing
*          - Retrieves up to N closest units in passed group
*
*****************************************************************************/
library GetClosestWidget uses optional IsDestructableTree

    private keyword Init
    globals
        private unit array Q
        private real array V
        private integer C=0
    endglobals
    
    struct ClosestWidget extends array
        readonly static destructable cDest=null
        readonly static item  cItem=null
        readonly static real distance=0
        readonly static real cX=0
        readonly static real cY=0
        readonly static unit cUnit=null
        static boolean cTree=false
        static rect initRect=null
        static method resetData takes real x, real y returns nothing
            set cDest=null
            set distance=100000
            set cItem=null
            set cUnit=null
            set cX=x
            set cY=y
        endmethod
        static method enumItems takes nothing returns nothing
            local item i=GetEnumItem()
            local real dx=GetWidgetX(i)-cX
            local real dy=GetWidgetY(i)-cY
            set dx = (dx*dx+dy*dy)/10000.
            if dx<distance then
                set cItem=i
                set distance=dx
            endif
            set i =null
        endmethod
        static method enumDestructables takes nothing returns nothing
            local destructable d=GetEnumDestructable()
            local real dx
            local real dy
            static if LIBRARY_IsDestructableTree then
                if cTree and not IsDestructableTree(d) then
                    return
                endif
            endif
            set dx=GetWidgetX(d)-cX
            set dy=GetWidgetY(d)-cY
            set dx=(dx*dx+dy*dy)/10000.
            if dx<distance then
                set cDest=d
                set distance=dx
            endif
            set d=null
        endmethod
        static method enumUnits takes nothing returns nothing
            local unit u=GetEnumUnit()
            local real dx=GetUnitX(u)-cX
            local real dy=GetUnitY(u)-cY
            set dx=(dx*dx+dy*dy)/10000.
            if dx<distance then
                set cUnit=u
                set distance=dx
            endif
            set u=null
        endmethod
        static method sortUnits takes integer l, integer r returns nothing
            local integer i=l
            local integer j=r
            local real v=V[(l+r)/2]
            loop
                loop
                    exitwhen V[i]>=v
                    set i=i+1
                endloop
                loop
                    exitwhen V[j]<=v
                    set j=j-1
                endloop
                if i<=j then
                    set V[0]=V[i]
                    set V[i]=V[j]
                    set V[j]=V[0]
                    set Q[0]=Q[i]
                    set Q[i]=Q[j]
                    set Q[j]=Q[0]
                    set i=i+1
                    set j=j-1
                endif
                exitwhen i>j
            endloop
            if l<j then
                call sortUnits(l,j)
            endif
            if r>i then
                call sortUnits(i,r)
            endif
        endmethod
        static method saveGroup takes nothing returns nothing
            local real dx
            local real dy
            set C=C+1
            set Q[C]=GetEnumUnit()
            set dx=GetUnitX(Q[C])-cX
            set dy=GetUnitY(Q[C])-cY
            set V[C]=(dx*dx+dy*dy)/10000.
        endmethod
        implement Init
    endstruct
    private module Init
        private static method onInit takes nothing returns nothing
            set thistype.initRect=Rect(0,0,0,0)
        endmethod
    endmodule

    function  GetClosestItem takes real x, real y, boolexpr filter returns item
        local real r=800.
        call ClosestWidget.resetData(x,y)
        loop
            if r>3200. then
                call EnumItemsInRect(bj_mapInitialPlayableArea, filter, function ClosestWidget.enumItems)
                exitwhen true
            else
                call SetRect(ClosestWidget.initRect,x-r,y-r,x+r,y+r)
                call EnumItemsInRect(ClosestWidget.initRect, filter, function  ClosestWidget.enumItems)
                exitwhen ClosestWidget.cItem!=null
            endif
            set r=2*r
        endloop
        return ClosestWidget.cItem
    endfunction

    function GetClosestItemInRange takes real x, real y, real radius, boolexpr filter returns item
        call ClosestWidget.resetData(x,y)
        if radius>=0 then
            call SetRect(ClosestWidget.initRect,x-radius,y-radius,x+radius,y+radius)
            call EnumItemsInRect(ClosestWidget.initRect, filter, function ClosestWidget.enumItems)
        endif
        return ClosestWidget.cItem
    endfunction

    function GetClosestDestructable takes real x, real y, boolean treeOnly, boolexpr filter returns destructable
        local real r=800.
        call ClosestWidget.resetData(x,y)
        set ClosestWidget.cTree=treeOnly
        loop
            if r>3200. then
                call EnumDestructablesInRect(bj_mapInitialPlayableArea, filter, function ClosestWidget.enumDestructables)
                exitwhen true
            else
                call SetRect(ClosestWidget.initRect,x-r,y-r,x+r,y+r)
                call EnumDestructablesInRect(ClosestWidget.initRect, filter, function ClosestWidget.enumDestructables)
                exitwhen ClosestWidget.cDest!=null
            endif
            set r=2*r
        endloop
        return ClosestWidget.cDest
    endfunction

    function GetClosestDestructableInRange takes real x, real y, real radius, boolean treeOnly, boolexpr filter returns destructable
        call ClosestWidget.resetData(x,y)
        if radius>=0 then
            set ClosestWidget.cTree=treeOnly
            call SetRect(ClosestWidget.initRect,x-radius,y-radius,x+radius,y+radius)
            call EnumDestructablesInRect(ClosestWidget.initRect, filter, function ClosestWidget.enumDestructables)
        endif
        return ClosestWidget.cDest
    endfunction
    
    function GetClosestUnit takes real x, real y, boolexpr filter returns unit
        local real r=800.
        call ClosestWidget.resetData(x,y)
        loop
            if r>3200. then
                call GroupEnumUnitsInRect(bj_lastCreatedGroup, bj_mapInitialPlayableArea, filter)
                exitwhen true
            else
                call GroupEnumUnitsInRange(bj_lastCreatedGroup, x, y, r, filter)
                exitwhen FirstOfGroup(bj_lastCreatedGroup)!=null
            endif
            set r=2*r
        endloop
        call ForGroup(bj_lastCreatedGroup, function ClosestWidget.enumUnits)
        return ClosestWidget.cUnit
    endfunction
    
    function GetClosestUnitInRange takes real x, real y, real radius, boolexpr filter returns unit
        call ClosestWidget.resetData(x,y)
        if radius>=0 then
            call GroupEnumUnitsInRange(bj_lastCreatedGroup, x, y, radius, filter)
            call ForGroup(bj_lastCreatedGroup, function ClosestWidget.enumUnits)
        endif
        return ClosestWidget.cUnit
    endfunction

    function GetClosestUnitInGroup takes real x, real y, group g returns unit
        call ClosestWidget.resetData(x,y)
        call ForGroup(g, function ClosestWidget.enumUnits)
        return ClosestWidget.cUnit
    endfunction

    function GetClosestNUnitsInRange takes real x, real y, real radius, integer n, group g, boolexpr filter returns nothing
        local integer q=n+1
        call ClosestWidget.resetData(x,y)
        if radius>=0 then
            call GroupEnumUnitsInRange(bj_lastCreatedGroup, x, y, radius, filter)
            call ForGroup(bj_lastCreatedGroup, function ClosestWidget.saveGroup)
            call ClosestWidget.sortUnits(1,C)
            loop
            exitwhen n==0 or Q[-n+q]==null
                call GroupAddUnit(g, Q[-n+q])
                set n =n-1
            endloop
        endif
        set C=0
    endfunction
    
    function GetClosestNUnitsInGroup takes real x, real y, integer n, group sourceGroup, group destGroup returns nothing
        local integer q=n+1
        call ClosestWidget.resetData(x,y)
        call ForGroup(sourceGroup, function ClosestWidget.saveGroup)
        call ClosestWidget.sortUnits(1,C)
        loop
            exitwhen n==0 or Q[-n+q]==null
            call GroupAddUnit(destGroup, Q[-n+q])
            set n=n-1
        endloop
        set C=0
    endfunction
endlibrary

function DistanceBetweenPointsReal takes real XA, real YA, real XB, real YB returns real
    local real dx = XB - XA
    local real dy = YB - YA
    return SquareRoot(dx * dx + dy * dy)
endfunction

//TESH.scrollpos=0
//TESH.alwaysfold=0
//============================================================================
// SpellEffectEvent
// - Version 1.1.0.0
//
// API
// ---
//     RegisterSpellEffectEvent(integer abil, code onCast)
//
// Requires
// --------
//     RegisterPlayerUnitEvent: hiveworkshop.com/forums/showthread.php?t=203338
//
// Optional
// --------
//     Table: hiveworkshop.com/forums/showthread.php?t=188084
//
library SpellEffectEvent requires RegisterPlayerUnitEvent, optional Table
 
//============================================================================
private module M
   
    static if LIBRARY_Table then
        static Table tb
    else
        static hashtable ht = InitHashtable()
    endif
   
    static method onCast takes nothing returns nothing
        static if LIBRARY_Table then
            call TriggerEvaluate(.tb.trigger[GetSpellAbilityId()])
        else
            call TriggerEvaluate(LoadTriggerHandle(.ht, 0, GetSpellAbilityId()))
        endif
    endmethod
 
    private static method onInit takes nothing returns nothing
        static if LIBRARY_Table then
            set .tb = Table.create()
        endif
        call RegisterPlayerUnitEvent(EVENT_PLAYER_UNIT_SPELL_EFFECT, function thistype.onCast)
    endmethod
endmodule
 
//============================================================================
private struct S extends array
    implement M
endstruct
 
//============================================================================
function RegisterSpellEffectEvent takes integer abil, code onCast returns nothing
    static if LIBRARY_Table then
        if not S.tb.handle.has(abil) then
            set S.tb.trigger[abil] = CreateTrigger()
        endif
        call TriggerAddCondition(S.tb.trigger[abil], Filter(onCast))
    else
        if not HaveSavedHandle(S.ht, 0, abil) then
            call SaveTriggerHandle(S.ht, 0, abil, CreateTrigger())
        endif
        call TriggerAddCondition(LoadTriggerHandle(S.ht, 0, abil), Filter(onCast))
    endif
endfunction
 
endlibrary

//TESH.scrollpos=29
//TESH.alwaysfold=0
/**************************************************************
*
*   RegisterPlayerUnitEvent
*   v5.1.0.1
*   By Magtheridon96
*
*   I would like to give a special thanks to Bribe, azlier
*   and BBQ for improving this library. For modularity, it only
*   supports player unit events.
*
*   Functions passed to RegisterPlayerUnitEvent must either
*   return a boolean (false) or nothing. (Which is a Pro)
*
*   Warning:
*   --------
*
*       - Don't use TriggerSleepAction inside registered code.
*       - Don't destroy a trigger unless you really know what you're doing.
*
*   API:
*   ----
*
*       - function RegisterPlayerUnitEvent takes playerunitevent whichEvent, code whichFunction returns nothing
*           - Registers code that will execute when an event fires.
*       - function RegisterPlayerUnitEventForPlayer takes playerunitevent whichEvent, code whichFunction, player whichPlayer returns nothing
*           - Registers code that will execute when an event fires for a certain player.
*       - function GetPlayerUnitEventTrigger takes playerunitevent whichEvent returns trigger
*           - Returns the trigger corresponding to ALL functions of a playerunitevent.
*
**************************************************************/
library RegisterPlayerUnitEvent // Special Thanks to Bribe and azlier
    globals
        private trigger array t
    endglobals
   
    function RegisterPlayerUnitEvent takes playerunitevent p, code c returns nothing
        local integer i = GetHandleId(p)
        local integer k = 15
        if t[i] == null then
            set t[i] = CreateTrigger()
            loop
                call TriggerRegisterPlayerUnitEvent(t[i], Player(k), p, null)
                exitwhen k == 0
                set k = k - 1
            endloop
        endif
        call TriggerAddCondition(t[i], Filter(c))
    endfunction
   
    function RegisterPlayerUnitEventForPlayer takes playerunitevent p, code c, player pl returns nothing
        local integer i = 16 * GetHandleId(p) + GetPlayerId(pl)
        if t[i] == null then
            set t[i] = CreateTrigger()
            call TriggerRegisterPlayerUnitEvent(t[i], pl, p, null)
        endif
        call TriggerAddCondition(t[i], Filter(c))
    endfunction
   
    function GetPlayerUnitEventTrigger takes playerunitevent p returns trigger
        return t[GetHandleId(p)]
    endfunction
endlibrary

function AngleBetweenPointsReal takes real XA, real YA, real XB, real YB returns real
	return bj_RADTODEG * Atan2(YB - YA, XB - XA)
endfunction

library DummyRecycler /*
    
//                      DummyRecycler v1.25
//                          by Flux
//  
//  A system that recycles dummy units while considering their facing angle.
//  It can be used as attachment dummies for visual effects or as dummy caster.
//
//  Why is recycling a unit important?
//      Because creating a unit is is one of the slowest function in the game
//      and there are reports that will always leave a permanent tiny bit of 
//      memory (0.04 KB).
//      On average, retrieving a pending Dummy is approximately 4x faster compared
//      to creating a new one and recycling a Dummy compared to removing it is
//      approximately 1.3x faster.
//      Furthermore, if you're using a lot of "Unit has entered map" events,
//      using this system will even result to even more better performance
//      because retrieving Dummy units does not cause that event to run.


    */ requires /*
       nothing
       
    */ optional Table/*
        if not found, this system will use a hashtable. Hashtables are limited to
        255 per map.
        
    */ optional WorldBounds /*
        if not found, this system will initialize its own Map Boundaries.
//
//
//  Features:
//
//    -- Dummy Sharing
//        When a Dummy List gets low on unit count, it will borrow Dummy Units 
//        from the Dummy List with the highest unit count. The transfer is not
//        instant because the shared Dummy Unit has to turn to the appropriate 
//        angle of its new Dummy List before it can be recycled. 
//        See BORROW_REQUEST.
//
//    -- Self-balancing recycling algorithm
//        Recycled Dummy Units will be thrown to the List having the least number
//        of Dummy Units.
//
//    -- Recycling least used
//        Allows recycling a Dummy from the Dummy List with the highest
//        unit count. It is useful when the facing angle of the Dummy Unit
//        does not matter. 
//        See GetRecycledDummyAnyAngle.
//
//    -- Self-adaptation
//        When there are no free Dummy Units from a Dummy List, it will end up creating
//        a new unit instead but that unit will be permanently added as a Dummy
//        Unit to be recycled increasing the overall total Dummy Unit count.
//
//    -- Count control
//        Allows limiting the overall number of Dummy Units. 
//        See MAX_DUMMY_COUNT.
//
//    -- Delayed Recycle
//        Allows recycling Dummy Units after some delay to allocate time for the 
//        death animation of Special Effects to be seen. 
//        See DummyAddRecycleTimer.
//
// ******************************************************************
// ***************************** API: *******************************
// ******************************************************************
//
//  function GetRecycledDummy takes real x, real y, real z, real facing returns unit
//      - Retrieve an unused Dummy Unit from the List.
//      - The equivalent of CreateUnit.
//      - To use as a Dummy Caster, follow it with PauseUnit(dummy, false).
//
//  function GetRecycledDummyAnyAngle takes real x, real y, real z returns unit
//      - Use this function if the facing angle of the Dummy doesn't matter to you.
//      - It will return a unit from the list having the highest number of unused Dummy Units.
//      - To use as a Dummy Caster, follow it with PauseUnit(dummy, false).
//
//  function RecycleDummy takes unit u returns nothing
//      - Recycle the Dummy unit for it to be used again later.
//      - The equivalent of RemoveUnit.
//
//  function DummyAddRecycleTimer takes unit u, real time returns nothing
//      - Recycle the Dummy unit after a certain time. 
//      - Use this to allocate time for the the death animation of an effect attached to the 
//        Dummy Unit to finish..
//      - The equivalent of UnitApplyTimedLife.
//
//  function ShowDummy takes unit u, boolean flag returns nothing
//      - Shows/hides Dummy Unit without conflicting with the Locust ability.
//
//--------------------
//      CREDITS
//--------------------
//  Bribe - for the MissileRecycler (vJASS) where I got this concept from
//       http://www.hiveworkshop.com/forums/jass-resources-412/system-missilerecycler-206086/
//        - for the optional Table
//       http://www.hiveworkshop.com/forums/jass-resources-412/snippet-new-table-188084/
//  Vexorian - for the Attachable and Pitch Animation Model (dummy.mdx)
//       http://www.wc3c.net/showthread.php?t=101150
//  Maker and IcemanBo - for the unit permanent 0.04 KB memory leak of units.
//       http://www.hiveworkshop.com/forums/trigger-gui-editor-tutorials-279/memory-leaks-263410/
//  Nestharus - for the data structure
//       http://www.hiveworkshop.com/forums/2809461-post7.html
//            - for the optional WorldBounds
//       http://githubusercontent.com/nestharus/JASS/master/jass/Systems/WorldBounds/script.j

// =============================================================== //
// ====================== CONFIGURATION ========================== //
// =============================================================== */

    globals
        //The rawcode of the Dummy Unit
        private constant integer DUMMY_ID = 'h000'
        
        //The owner of the Dummy Unit
        private constant player OWNER = Player(14)
        
        //The number of indexed angle. The higher the value the:
        // - Lesser the turning time for the Dummy Units.
        // - Higher the total number of Dummy Units created at Map Initialization.
        //          Recommended Value: 10 (Max difference of 18 degrees)
        private constant integer ANGLES_COUNT = 10
        
        //The number of Dummy units per ANGLES_COUNT. The higher the value the:
        // - Higher the number of units that can be recycled per angle, when 
        //   no more units are in queue, the system will resort to use CreateUnit.
        // - Higher the total number of Dummy Units created at Map Initialization.
        //    Recommended Value: 3 to 5 (for less overhead in Map Loading Screen)
        private constant integer STORED_UNIT_COUNT = 3
        
        //The maximum number of Dummy units that can exist. When the system resort
        //to using CreateUnit, the unit will be permanently added to the Dummy
        //List. To avoid spamming Dummy Units and having too much free Dummy
        //Units to allocate, the maximum number of Dummy Units is capped.
        //               Recommended Value: 80 to 120
        private constant integer MAX_DUMMY_COUNT = 100
        
        //When a certain angle have less than BORROW_REQUEST units in its list,
        //it will start to borrow Dummy Units from the list with the highest
        //Dummy Unit count.
        //      Recommended Value: Half of maximum STORED_UNIT_COUNT
        private constant integer BORROW_REQUEST = 5
        
        //It will only return a Dummy if the current dummy is close
        //to it's appropriate facing angle. This is to avoid returning
        //a Dummy which is still turning to face it's list angle.
        private constant real ANGLE_TOLERANCE = 10.0
        
        //An additional option to automatically hide recycled dummy units in the
        //corner of the map camera bounds
        private constant boolean HIDE_ON_MAP_CORNER = true
    endglobals
    
    //Every time a new dummy unit is retrieved, it will apply this resets
    //If it is redundant/you dont need it, remove it.
    //! textmacro DUMMY_UNIT_RESET
        call SetUnitScale(bj_lastCreatedUnit, 1, 0, 0)
        call SetUnitVertexColor(bj_lastCreatedUnit, 255, 255, 255, 255)
        call SetUnitAnimationByIndex(bj_lastCreatedUnit, 90)
        call ShowDummy(bj_lastCreatedUnit, true)
    //! endtextmacro
// =============================================================== //
// ==================== END CONFIGURATION ======================== //
// =============================================================== //
    
    
    globals
        private integer dummyCount = ANGLES_COUNT*STORED_UNIT_COUNT
        private real array angle 
        private integer array count 
        private integer array countHead
        private integer array countNext
        private integer array countPrev
        private integer array next
        private integer array prev
        private unit array dummy
        private integer upper
        private integer lower
        private integer lastInstance
        private constant real FACING_OFFSET = 180.0/ANGLES_COUNT
    endglobals
    
    static if HIDE_ON_MAP_CORNER and not LIBRARY_WorldBounds then
        private module BoundsInit
        
            readonly static real x
            readonly static real y
            
            private static method onInit takes nothing returns nothing
                local rect map = GetWorldBounds()
                set thistype.x = GetRectMaxX(map)
                set thistype.y = GetRectMaxY(map)
                call RemoveRect(map)
                set map = null
            endmethod
            
        endmodule
        
        private struct Bounds extends array
            implement BoundsInit
        endstruct
    endif
    
    private module M
        
        static if LIBRARY_Table then
            static Table tb
        else
            static hashtable hash = InitHashtable()
        endif
        
        private static method onInit takes nothing returns nothing
            local real add = 360.0/ANGLES_COUNT
            local real a = 0
            local integer this = ANGLES_COUNT
            local integer head = 0
            local integer cHead = JASS_MAX_ARRAY_SIZE - 1   //avoid allocation collision
            local integer i = R2I(MAX_DUMMY_COUNT/ANGLES_COUNT + 0.5)
            set upper = STORED_UNIT_COUNT
            set lower = STORED_UNIT_COUNT
            static if LIBRARY_Table then
                set tb = Table.create()
            endif
            //Initialize countHeads
            loop
                exitwhen i < 0
                set countNext[cHead] = cHead
                set countPrev[cHead] = cHead
                set countHead[i] = cHead
                set cHead = cHead - 1
                set i = i - 1
            endloop
            set cHead = countHead[STORED_UNIT_COUNT]  //All heads will be inserted here initially
            //Create the Dummy units
            loop
                exitwhen a >= 360
                //Initialize head
                set next[head] = head
                set prev[head] = head
                set count[head] = STORED_UNIT_COUNT
                set angle[head] = a
                //Insert head in the Count List 
                set countNext[head] = cHead
                set countPrev[head] = countPrev[cHead]
                set countNext[countPrev[head]] = head
                set countPrev[countNext[head]] = head
                set i = 0
                loop
                    exitwhen i >= STORED_UNIT_COUNT
                    //Queued Linked List
                    set next[this] = head
                    set prev[this] = prev[head]
                    set next[prev[this]] = this
                    set prev[next[this]] = this
                    static if HIDE_ON_MAP_CORNER then
                        static if LIBRARY_WorldBounds then
                            set dummy[this] = CreateUnit(OWNER, DUMMY_ID, WorldBounds.maxX, WorldBounds.maxY, a)
                        else
                            set dummy[this] = CreateUnit(OWNER, DUMMY_ID, Bounds.x, Bounds.y, a)
                        endif
                    else
                        set dummy[this] = CreateUnit(OWNER, DUMMY_ID, 0, 0, a)
                    endif
                    call PauseUnit(dummy[this], true)
                    static if LIBRARY_Table then
                        set tb[GetHandleId(dummy[this])] = this
                    else
                        call SaveInteger(hash, GetHandleId(dummy[this]), 0, this)
                    endif
                    set this = this + 1
                    set i = i + 1
                endloop
                set head = head + 1
                set a = a + add
            endloop
            set lastInstance = this
        endmethod
        
    endmodule
    
    private struct S extends array
        implement M
    endstruct
    
    private function GetHead takes integer facing returns integer
        if facing < 0 or facing >= 360 then
            set facing = facing - (facing/360)*360
            if facing < 0 then
                set facing = facing + 360
            endif
        endif
        return R2I((facing*ANGLES_COUNT/360.0))
    endfunction
    
    function ShowDummy takes unit u, boolean flag returns nothing
        if IsUnitHidden(u) == flag then
            call ShowUnit(u, flag)
            if flag and GetUnitTypeId(u) == DUMMY_ID then
                call UnitRemoveAbility(u, 'Aloc')
                call UnitAddAbility(u, 'Aloc')
            endif
        endif
    endfunction
    
    function GetRecycledDummy takes real x, real y, real z, real facing returns unit
        local integer head = GetHead(R2I(facing + FACING_OFFSET))
        local integer this = next[head]
        local integer cHead
        
        //If there are Dummy Units in the Queue List already facing close to the appropriate angle
        if this != head and RAbsBJ(GetUnitFacing(dummy[this]) - angle[head]) <= ANGLE_TOLERANCE then
            //Remove from the Queue List
            set next[prev[this]] = next[this]
            set prev[next[this]] = prev[this]
            //For double free protection
            set next[this] = -1
            //Unit Properties
            set bj_lastCreatedUnit = dummy[this]
            call SetUnitX(bj_lastCreatedUnit, x)
            call SetUnitY(bj_lastCreatedUnit, y)
            call SetUnitFacing(bj_lastCreatedUnit, facing)
            call SetUnitFlyHeight(bj_lastCreatedUnit, z, 0)
            //! runtextmacro DUMMY_UNIT_RESET()
            //Update Count and Bounds
            set count[head] = count[head] - 1
            
            //------------------------------------------------
            //                 Unit Sharing
            //------------------------------------------------
            if count[head] < BORROW_REQUEST and count[countNext[countHead[upper]]] > count[head] then
                set count[head] = count[head] + 1
                set this = next[countNext[countHead[upper]]]
                call SetUnitFacing(dummy[this], angle[head])
                //Remove
                set next[prev[this]] = next[this]
                set prev[next[this]] = prev[this]
                //Add to the Current List
                set next[this] = head
                set prev[this] = prev[head]
                set next[prev[this]] = this
                set prev[next[this]] = this
                set head = countNext[countHead[upper]]
                set count[head] = count[head] - 1
            endif
            
            //---------------------------
            //Update Count Lists
            //---------------------------
            //Remove from the current Count List
            set countNext[countPrev[head]] = countNext[head]
            set countPrev[countNext[head]] = countPrev[head]
            //Add to the new Count List
            set cHead = countHead[count[head]]
            set countNext[head] = cHead
            set countPrev[head] = countPrev[cHead]
            set countNext[countPrev[head]] = head
            set countPrev[countNext[head]] = head
            
            //---------------------------
            //  Update Bounds
            //---------------------------
            set cHead = countHead[upper]
            if countNext[cHead] == cHead then
                set upper = upper - 1
            endif
            if count[head] < lower then
                set lower = count[head]
            endif
        else
            set bj_lastCreatedUnit = CreateUnit(OWNER, DUMMY_ID, x, y, facing)
            call PauseUnit(bj_lastCreatedUnit, true)
            call SetUnitFlyHeight(bj_lastCreatedUnit, z, 0)
            if dummyCount < MAX_DUMMY_COUNT then
                set this = lastInstance
                //For double free protection
                set next[this] = -1
                set dummy[this] = bj_lastCreatedUnit
                static if LIBRARY_Table then
                    set S.tb[GetHandleId(bj_lastCreatedUnit)] = this
                else
                    call SaveInteger(S.hash, GetHandleId(bj_lastCreatedUnit), 0, this)
                endif
                set lastInstance = lastInstance + 1
            endif
            set dummyCount = dummyCount + 1
        endif

        return bj_lastCreatedUnit
    endfunction
    
    function RecycleDummy takes unit u returns nothing
        static if LIBRARY_Table then
            local integer this = S.tb[GetHandleId(u)]
        else
            local integer this = LoadInteger(S.hash, GetHandleId(u), 0)
        endif
        local integer head
        local integer cHead
        
        //If the unit is a legit Dummy Unit
        if this > 0 and next[this] == -1 then
            //Find where to insert based on the list having the least number of units
            set head = countNext[countHead[lower]]
            set next[this] = head
            set prev[this] = prev[head]
            set next[prev[this]] = this
            set prev[next[this]] = this
            //Update Status
            call SetUnitFacing(u, angle[head])
            call PauseUnit(u, true)
            call SetUnitOwner(u, OWNER, false)
            static if HIDE_ON_MAP_CORNER then
                static if LIBRARY_WorldBounds then
                    call SetUnitX(u, WorldBounds.maxX)
                    call SetUnitY(u, WorldBounds.maxY)
                else
                    call SetUnitX(u, Bounds.x)
                    call SetUnitY(u, Bounds.y)
                endif
            else
                call SetUnitScale(u, 0, 0, 0)
                call SetUnitVertexColor(u, 0, 0, 0, 0)
            endif
            set count[head] = count[head] + 1
            
            //---------------------------
            //    Update Count Lists
            //---------------------------
            //Remove
            set countNext[countPrev[head]] = countNext[head]
            set countPrev[countNext[head]] = countPrev[head]
            //Add to the new Count List
            set cHead = countHead[count[head]]
            set countNext[head] = cHead
            set countPrev[head] = countPrev[cHead]
            set countNext[countPrev[head]] = head
            set countPrev[countNext[head]] = head
            
            //---------------------------
            //  Update Bounds
            //---------------------------
            set cHead = countHead[lower]
            if countNext[cHead] == cHead then
                set lower = lower + 1
            endif
            if count[head] > upper then
                set upper = count[head]
            endif
        elseif this == 0 then
            call RemoveUnit(u)
        debug elseif next[this] != -1 then
            debug call BJDebugMsg("|cffffcc00[DummyRecycler]:|r Attempted to recycle a pending/free Dummy Unit.")
        endif
        
    endfunction
    
    private function Expires takes nothing returns nothing
        local timer t = GetExpiredTimer()
        local integer id = GetHandleId(t)
        static if LIBRARY_Table then
            call RecycleDummy(S.tb.unit[id])
            call S.tb.unit.remove(id)
        else
            call RecycleDummy(LoadUnitHandle(S.hash, id, 0))
            call FlushChildHashtable(S.hash, id)
        endif
        call DestroyTimer(t)
        set t = null
    endfunction

    function DummyAddRecycleTimer takes unit u, real time returns nothing
        local timer t = CreateTimer()
        static if LIBRARY_Table then
            set S.tb.unit[GetHandleId(t)] = u
        else
            call SaveUnitHandle(S.hash, GetHandleId(t), 0, u)
        endif
        call TimerStart(t, time, false, function Expires)
        set t = null
    endfunction
    
    function GetRecycledDummyAnyAngle takes real x, real y, real z returns unit
        return GetRecycledDummy(x, y, z, angle[countNext[countHead[upper]]])
    endfunction
    
    // runtextmacro DUMMY_DEBUG_TOOLS()
    
endlibrary

library AttackIndexer requires Table
// vJass version 1.1.0.4

//requires Globals:
// - unit udg_DamageEventAttackTarget
// - boolean udg_DamageFromPrimaryAttack

//These are unique integers per-attack which can be used as parent keys in a GUI hashtable:
// - integer udg_DamageHashKeyForAttack
// - integer array udg_AttackEventHashKey --indexed by the Attacking Unit's Custom Value

//Optional - only needed if USE_GUI_HASH is true:
// - hashtable udg_AttackIndexerHash

globals
    // Attack data structure stored in TableArray[0-11]
    private constant integer TARGET_INDEX   = -1
    private constant integer RESOLVED_INDEX = -2
endglobals

private struct UnitData extends array
    static constant boolean USE_GUI_HASH = true
    static constant boolean DEBUG = false

    TableArray tableArray
    integer points
    boolean circled
    integer attack1
    integer attack2

    method operator unit takes nothing returns unit
        return udg_UDexUnits[this]
    endmethod

    method assignAttackIndices takes nothing returns nothing
        set this.attack1 = BlzGetUnitWeaponIntegerField(/*
            */ this.unit,/*
            */ UNIT_WEAPON_IF_ATTACK_WEAPON_SOUND, /*
            */ 0 /*
        */)
        set this.attack2 = BlzGetUnitWeaponIntegerField(/*
            */ this.unit,/*
            */ UNIT_WEAPON_IF_ATTACK_WEAPON_SOUND, /*
            */ 1 /*
        */)
    endmethod

    static method onUnitAttacked takes nothing returns boolean
        local unit attackedUnit = GetTriggerUnit()
        local unit attacker = GetAttacker()
        local thistype this = GetUnitUserData(attacker)
        local TableArray tableArray = this.tableArray
        local integer point

        if tableArray == 0 then
            // There are 24 different weapon types, so to track
            // primary attack and secondary attack, we can only
            // have 12 unique simultanous attacks per attacker.
            set tableArray = TableArray[12]
            set this.tableArray = tableArray
            call this.assignAttackIndices()

            static if thistype.USE_GUI_HASH then
                if udg_AttackIndexerHash == null then
                    set udg_AttackIndexerHash = InitHashtable()
                endif
            endif
        endif

        // The hashtable will initialize point first to 0.
        set point = this.points

        if this.circled then
            static if thistype.DEBUG then
                if not tableArray[point].boolean[RESOLVED_INDEX] then
                    call BJDebugMsg( /*
                        */ "The attack with hashkey " + I2S(tableArray[point]) + /*
                        */ " has either missed, or the unit is attacking too quickly for Attack Indexer to keep up with." /*
                    */ )
                endif
            endif

            // Clean old data from 12 attacks ago.
            call tableArray[point].flush()
            static if thistype.USE_GUI_HASH then
                call FlushChildHashtable(udg_AttackIndexerHash, tableArray[point])
            endif
        endif

        if point < 11 then
            set this.points = point + 1
        else
            // Wrap around so as to recycle -12th indices.
            set this.points = 0
            set this.circled = true
        endif

        // I'd like to allow the user to use the normal 'Unit is Attacked' event here.
        // Therefore, to avoid recursion issues, this variable must be attached to the
        // custom value of the attacking unit.
        set udg_AttackEventHashKey[this] = tableArray[point]

        set tableArray[point].unit[TARGET_INDEX] = attackedUnit

        call BlzSetUnitWeaponIntegerField(/*
            */ attacker, /*
            */ UNIT_WEAPON_IF_ATTACK_WEAPON_SOUND, /*
            */ 0, /*
            */ point * 2 /*
        */)
        call BlzSetUnitWeaponIntegerField(/*
            */ attacker, /*
            */ UNIT_WEAPON_IF_ATTACK_WEAPON_SOUND, /*
            */ 1, /*
            */ point * 2 + 1 /*
        */)

        set attackedUnit = null
        set attacker = null
        return false
    endmethod

    static method onUnitRemoved takes nothing returns boolean
        local integer hashIndex = 0
        local thistype this = udg_UDex
        if this.tableArray != 0 then
            // Clear out data from memory
            call this.tableArray.flush()

            static if thistype.USE_GUI_HASH then
                loop
                    call FlushChildHashtable(udg_AttackIndexerHash, this.tableArray[hashIndex])
                    exitwhen hashIndex == 11
                    set hashIndex = hashIndex + 1
                endloop
            endif

            set this.tableArray = 0
            set this.points = 0
            set this.circled = false
        endif
        return false
    endmethod

    static method onUnitTransformed takes nothing returns boolean
        local thistype this = udg_UDex
        if this.tableArray > 0 then
            call this.assignAttackIndices()
        endif
        return false
    endmethod

    static method onInit takes nothing returns nothing
        local trigger trig = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(trig, EVENT_PLAYER_UNIT_ATTACKED)
        call TriggerAddCondition(trig, Filter(function thistype.onUnitAttacked))

        set trig = CreateTrigger()
        call TriggerRegisterVariableEvent(trig, "udg_UnitIndexEvent", EQUAL, 2.00)
        call TriggerAddCondition(trig, Filter(function thistype.onUnitRemoved))

        set trig = CreateTrigger()
        call TriggerRegisterVariableEvent(trig, "udg_UnitTypeEvent", EQUAL, 1.00)
        call TriggerAddCondition(trig, Filter(function thistype.onUnitTransformed))

        set trig = null
    endmethod
endstruct

struct Attack extends array
    unit attackTarget
    boolean isPrimaryAttack

    // vJass users will have direct access to this, so they can use it with Table.
    // Main thing to consider is to avoid clashing indices, so I recommend either
    // using StringHash or a bucket of shared indices across a map's systems.
    Table attackHashKey

    // Only to be used internally by Damage Engine
    method adjustOnDamage takes nothing returns nothing
        local Damage damageData = this
        local integer point2D = GetHandleId(damageData.weaponType)
        local integer tablePoint = point2D / 2
        local integer trueWeapon
        local UnitData unitData = GetUnitUserData(damageData.sourceUnit)
        local TableArray tableArray = unitData.tableArray

        //A simple flag to notify that the attack actually hit something.
        //I feel that this is mainly useful for debugging.
        set tableArray[tablePoint].boolean[RESOLVED_INDEX] = true

        set this.attackHashKey = tableArray[tablePoint]
        set this.attackTarget = tableArray[tablePoint].unit[TARGET_INDEX]
        set this.isPrimaryAttack = tablePoint * 2 == point2D

        if this.isPrimaryAttack then
            set trueWeapon = unitData.attack1
        else
            set trueWeapon = unitData.attack2
        endif

        // Put the weapon type back to normal; this means
        // that the whole experience is un-marred despite
        // this hack.
        set damageData.weaponType = ConvertWeaponType(trueWeapon)
    endmethod
endstruct

//! textmacro ATTACK_INDEXER_ADJUSTMENTS
    call Attack(d).adjustOnDamage()
//! endtextmacro

//! textmacro ATTACK_INDEXER_GUI_VARS
    set udg_DamageEventAttackTarget = Attack(Damage.index).attackTarget
    set udg_DamageFromPrimaryAttack = Attack(Damage.index).isPrimaryAttack
    set udg_DamageHashKeyForAttack  = Attack(Damage.index).attackHashKey
//! endtextmacro

endlibrary

/*
    vJass Damage Engine 5.A.0.0 
    
    This update enables compatibility with AttackIndexer.
*/
/*
JASS API:

    struct Damage extends array
        readonly static unit source // udg_DamageEventSource in real-time
        readonly static unit target // udg_DamageEventTarget in real-time
        static real          amount // udg_DamageEventAmount in real-time

        readonly unit    sourceUnit   // udg_DamageEventSource by index
        readonly unit    targetUnit   // udg_DamageEventTarget by index
        real             damage       // udg_DamageEventAmount by index
        readonly real    prevAmt      // udg_DamageEventPrevAmt by index
        attacktype       attackType   // udg_DamageEventAttackT by index
        damagetype       damageType   // udg_DamageEventDamageT by index
        weapontype       weaponType   // udg_DamageEventWeaponT by index
        integer          userType     // udg_DamageEventType by index
        readonly boolean isAttack     // udg_IsDamageAttack by index
        readonly boolean isCode       // udg_IsDamageCode by index
        readonly boolean isMelee      // udg_IsDamageMelee by index
        readonly boolean isRanged     // udg_IsDamageRanged by index
        readonly boolean isSpell      // udg_IsDamageSpell by index
        real             armorPierced // udg_DamageEventArmorPierced by index
        integer          armorType    // udg_DamageEventArmorT by index
        integer          defenseType  // udg_DamageEventDefenseT by index

        readonly integer eFilter

    Set to false to disable the damage event triggers or to true to reverse that:
        static boolean operator enabled

    Same arguments as "UnitDamageTarget" but has the benefit of being performance-friendly during recursive events.
    Will automatically cause the damage to be registered as Code damage.

        static method apply takes
            unit source,
            unit target,
            real amount,
            boolean isAttack,
            boolean isRanged,
            attacktype at,
            damagetype dt,
            weapontype wt
        returns Damage

    A simplified version of the above function that autofills each boolean, attacktype and weapontype.
    
        static method applySpell takes
            unit src,
            unit tgt,
            real amt,
            damagetype dt
        returns Damage

    A different variation of the above which autofills the "isAttack" boolean
    and populates damagetype as DAMAGE_TYPE_NORMAL.

        static method applyAttack takes
            unit src,
            unit tgt,
            real amt,
            boolean ranged,
            attacktype at,
            weapontype wt
        returns Damage

    struct DamageTrigger extends array
        method operator filter= takes integer filter returns nothing
        // Apply primary filters such as DamageEngine_FILTER_MELEE/RANGED/SPELL which are based off of limitop handles to enable easier access for GUI folks
        // Full filter list:
        - integer DamageEngine_FILTER_ATTACK
        - integer DamageEngine_FILTER_MELEE
        - integer DamageEngine_FILTER_OTHER
        - integer DamageEngine_FILTER_RANGED
        - integer DamageEngine_FILTER_SPELL
        - integer DamageEngine_FILTER_CODE

        boolean configured //set to True after configuring any filters listed below.

    Apply custom filters after setting any desired udg_DamageFilter variables (for GUI).
    Alternatively, vJass users can set these instead. Just be mindful to set the variable
    "configured" to true after settings these:
      unit    source
      unit    target
      integer sourceType
      integer targetType
      integer sourceBuff
      integer targetBuff
      real    damageMin
      integer attackType
      integer damageType
      integer userType

        method configure takes nothing returns nothing

    The string in the aruments below requires the following API:
      "" for standard damage event
      "Modifier(or Mod if you prefer)/After/Lethal/AOE" for the others

        static method registerTrigger takes
            trigger whichTrig, 
            string var, 
            real value 
        returns nothing
        
            static method unregister takes 
            trigger whichTrig, 
            string eventName, 
            real value, 
            boolean reset 
        returns boolean

        static method getIndex takes 
            trigger fromTrigger, 
            string eventName, 
            real value 
        returns integer

    If you already have the index of the trigger you want to unregister:
        
        method unregisterByIndex takes 
            boolean reset
        returns boolean

    Converts a code argument to a trigger, while checking if the same code had already been registered before.
      Use it via DamageTrigger[function MyCallbackFunction]
    
        static method operator [] takes 
            code callback
        returns trigger

    The accepted strings here use the same criteria as DamageTrigger.getIndex/registerTrigger/unregister:

        function TriggerRegisterDamageEngineEx takes
            trigger whichTrig,
            string eventName,
            real value,
            integer opId 
        returns nothing

        function TriggerRegisterDamageEngine takes 
            trigger whichTrig, 
            string eventName, 
            real value
        returns nothing
        
        function RegisterDamageEngineEx takes 
            code callback, 
            string eventName, 
            real value, 
            integer opId 
        returns nothing
        
            function RegisterDamageEngine takes 
            code callback, 
            string eventName, 
            real value 
        returns nothing
*/

//===========================================================================
library DamageEngine requires optional AttackIndexer
globals
    private constant boolean USE_GUI = true //If you don't use any of the GUI events, set to false to slightly improve performance

    private constant boolean USE_SCALING     = USE_GUI   //If you don't need or want to use DamageScalingUser/WC3 then set this to false
    private constant boolean USE_EXTRA       = true      //If you don't use DamageEventLevel or SourceDamageEvent, set this to false
    private constant boolean USE_ARMOR_MOD   = true      //If you do not modify nor detect armor/defense, set this to false
    private constant boolean USE_MELEE_RANGE = true      //If you do not detect melee nor ranged damage, set this to false
    private constant boolean USE_LETHAL      = true      //If you do not use LethalDamageEvent nor negative damage (explosive) types, set this to false

/*
    When manually-enabled recursion is enabled via DamageEngine_inception, 
    the engine will never go deeper than MAX_RECURSIVE_TOLERANCE:
*/
    private constant integer MAX_RECURSIVE_TOLERANCE = 16

    public constant integer TYPE_CODE = 1         //Must be the same as udg_DamageTypeCode, or 0 if you prefer to disable the automatic flag.
    public constant integer TYPE_PURE = 2         //Must be the same as udg_DamageTypePure
    private constant real   DEATH_VAL = 0.405     //In case M$ ever changes this, it'll be a quick fix here.

    private timer           async = null
    private boolean         timerStarted = false

    //Values to track the original pre-spirit Link/defensive damage values
    private Damage lastInstance = 0

    private boolean isNotNativeRecursiveDamage = true
    private boolean waitingForDamageEventToRun = false

    private boolean array attacksImmune
    private boolean array damagesImmune

    //Primary triggers used to handle all damage events.
    private trigger damagingTrigger = null
    private trigger damagedTrigger = null
    private trigger recursiveTrigger = null //Catches, stores recursive events

/*
    These variables coincide with Blizzard's "limitop" type definitions
    so as to enable GUI users with some performance perks - however,
    these optimizations need to be tested
*/
    public constant integer FILTER_ATTACK = 0     //LESS_THAN
    public constant integer FILTER_MELEE  = 1     //LESS_THAN_OR_EQUAL
    public constant integer FILTER_OTHER  = 2     //EQUAL
    public constant integer FILTER_RANGED = 3     //GREATER_THAN_OR_EQUAL
    public constant integer FILTER_SPELL  = 4     //GREATER_THAN
    public constant integer FILTER_CODE   = 5     //NOT_EQUAL
    public constant integer FILTER_MAX    = 6
    private integer         eventFilter   = FILTER_OTHER

/*
    When true, it allows your trigger to go recursively up to 
    MAX_RECURSIVE_TOLERANCE (if needed). It must be set before dealing damage.
*/
    public boolean  inception = false

    private boolean callbacksInProgress = false
    private integer recursiveCallbackDepth = 0
    private group   recursionSources = null
    private group   recursionTargets = null
    private boolean recursiveCallbaksInProgress = false
    private boolean nativeEventsCompleted = false
    private boolean atLeastOneLethalDamageEventRegistered = false

    // Struct members made private to this library.
    private keyword run
    private keyword trigFrozen
    private keyword ownRecursiveDepth
    private keyword manualRecursionRequested
endglobals

native UnitAlive takes unit u returns boolean

//GUI Vars:
/*
    Retained from 3.8 and prior:
    ----------------------------
    unit            udg_DamageEventSource
    unit            udg_DamageEventTarget
    unit            udg_EnhancedDamageTarget
    group           udg_DamageEventAOEGroup
    integer         udg_DamageEventAOE
    integer         udg_DamageEventLevel
    real            udg_DamageModifierEvent
    real            udg_DamageEvent
    real            udg_AfterDamageEvent
    real            udg_DamageEventAmount
    real            udg_DamageEventPrevAmt
    real            udg_AOEDamageEvent
    boolean         udg_DamageEventOverride
    boolean         udg_NextDamageType
    boolean         udg_DamageEventType
    boolean         udg_IsDamageSpell

    //Added in 5.0:
    boolean          udg_IsDamageMelee
    boolean          udg_IsDamageRanged
    unit             udg_AOEDamageSource
    real             udg_LethalDamageEvent
    real             udg_LethalDamageHP
    real             udg_DamageScalingWC3
    integer          udg_DamageEventAttackT
    integer          udg_DamageEventDamageT
    integer          udg_DamageEventWeaponT

    //Added in 5.1:
    boolean          udg_IsDamageCode

    //Added in 5.2:
    integer          udg_DamageEventArmorT
    integer          udg_DamageEventDefenseT

    //Addded in 5.3:
    real             DamageEventArmorPierced
    real             udg_DamageScalingUser

    //Added in 5.4.2 to allow GUI users to re-issue the exact same attack and damage type at the attacker.
    attacktype array udg_CONVERTED_ATTACK_TYPE
    damagetype array udg_CONVERTED_DAMAGE_TYPE

    //Added after Reforged introduced the new native BlzGetDamageIsAttack
    boolean         udg_IsDamageAttack

    //Added in 5.6 to give GUI users control over the "IsDamageAttack", "IsDamageRanged" and "DamageEventWeaponT" field
    boolean         udg_NextDamageIsAttack  //The first boolean value in the UnitDamageTarget native
    boolean         udg_NextDamageIsMelee   //Flag the damage classification as melee
    boolean         udg_NextDamageIsRanged  //The second boolean value in the UnitDamageTarget native
    integer         udg_NextDamageWeaponT   //Allows control over damage sound effect

    //Added in 5.7 to enable efficient, built-in filtering (see the below "checkConfig" method - I recommend commenting-out anything you don't need in your map)
    integer udg_DamageFilterAttackT
    integer udg_DamageFilterDamageT     //filter for a specific attack/damage type
    unit    udg_DamageFilterSource
    unit    udg_DamageFilterTarget      //filter for a specific source/target
    integer udg_DamageFilterSourceT
    integer udg_DamageFilterTargetT     //unit type of source/target
    integer udg_DamageFilterType        //which DamageEventType was used
    integer udg_DamageFilterSourceB
    integer udg_DamageFilterTargetB     //if source/target has a buff
    real    udg_DamageFilterMinAmount   //only allow a minimum damage threshold

    //Added in 5.8:
    boolean udg_RemoveDamageEvent       //Allow GUI users to more fully unregister a damage event trigger. Can only be used from within a damage event (of any kind).
    integer udg_DamageFilterSourceA
    integer udg_DamageFilterTargetA     //Check if a source or target have a specific ability (will overwrite any source or target buff check, I need to use this because GUI differentiates ability ID and buff ID)
    integer udg_DamageFilterSourceI
    integer udg_DamageFilterTargetI     //Check if a source or target have a specific type of item
    integer udg_DamageFilterSourceC
    integer udg_DamageFilterTargetC     //Classification of source/target (e.g. hero, treant, ward)

    //Added in 5.9
    real udg_SourceDamageEvent          //Like AOEDamageEvent, fires each time the source unit has finished dealing damage, but doesn't care if the damage hit multiple units.
    real udg_PreDamageEvent             //Like DamageModifierEvent 3.99 or less, except can be any real value.
    real udg_ArmorDamageEvent           //Like DamageModifierEvent 4.00 or more, except can be any real value.
    real udg_OnDamageEvent              //Like DamageEvent equal to 1.00 or some non-zero/non-2 value, except can be any real value.
    real udg_ZeroDamageEvent            //Like DamageEvent equal to 0.00 or 2.00, except can be any real value.
*/

struct DamageTrigger extends array

    static method checkItem takes unit u, integer id returns boolean
        local integer i
        if IsUnitType(u, UNIT_TYPE_HERO) then
            set i = UnitInventorySize(u)
            loop
                exitwhen i <= 0
                set i = i - 1
                if GetItemTypeId(UnitItemInSlot(u, i)) == id then
                    return true
                endif
            endloop
        endif
        return false
    endmethod

/*
    Map makers should probably not use these filters,
    unless someone tests performance to see
    if such an ugly hack is even worth it.
*/
    method checkConfig takes nothing returns boolean

        //call BJDebugMsg("Checking configuration")

        if this.sourceType      != 0 and GetUnitTypeId(udg_DamageEventSource) != this.sourceType then
        elseif this.targetType  != 0 and GetUnitTypeId(udg_DamageEventTarget) != this.targetType then
        elseif this.sourceBuff  != 0 and GetUnitAbilityLevel(udg_DamageEventSource, this.sourceBuff) == 0 then
        elseif this.targetBuff  != 0 and GetUnitAbilityLevel(udg_DamageEventTarget, this.targetBuff) == 0 then
        elseif this.failChance  > 0.00 and GetRandomReal(0.00, 1.00) <= this.failChance then
        elseif this.userType    != 0 and udg_DamageEventType != this.userType then
        elseif this.source      != null and this.source != udg_DamageEventSource then
        elseif this.target      != null and this.target != udg_DamageEventTarget then
        elseif this.attackType  >= 0 and this.attackType != udg_DamageEventAttackT then
        elseif this.damageType  >= 0 and this.damageType != udg_DamageEventDamageT then
        elseif this.sourceItem  != 0 and not .checkItem(udg_DamageEventSource, this.sourceItem) then
        elseif this.targetItem  != 0 and not .checkItem(udg_DamageEventTarget, this.targetItem) then
        elseif this.sourceClass >= 0 and not IsUnitType(udg_DamageEventSource, ConvertUnitType(this.sourceClass)) then
        elseif this.targetClass >= 0 and not IsUnitType(udg_DamageEventTarget, ConvertUnitType(this.targetClass)) then
        elseif udg_DamageEventAmount >= this.damageMin then
            //call BJDebugMsg("Configuration passed")
            return true
        endif
        //call BJDebugMsg("Checking failed")
        return false
    endmethod

    //The below variables are to be treated as constant
    readonly static thistype MOD    = 1
    readonly static thistype SHIELD = 4
    readonly static thistype DAMAGE = 5
    readonly static thistype ZERO   = 6
    readonly static thistype AFTER  = 7
    readonly static thistype LETHAL = 8
    readonly static thistype AOE    = 9
    private  static integer  count  = 9

    static thistype lastRegistered  = 0

    private static thistype array   trigIndexStack

    static thistype eventIndex = 0

    static boolean array filters
    readonly string eventStr
    readonly real weight
    boolean usingGUI

    private thistype next
    private trigger rootTrig

    //The below variables are to be treated as private
    boolean trigFrozen          //Whether the trigger is currently disabled due to recursion
    integer ownRecursiveDepth   //How deep the user recursion currently is.
    boolean manualRecursionRequested       //Added in 5.4.2 to simplify the inception variable for very complex DamageEvent triggers.

    //configuration variables:
    boolean configured
    unit    source
    unit    target
    integer sourceType
    integer targetType
    integer sourceBuff
    integer targetBuff
    integer sourceItem
    integer targetItem
    integer sourceClass
    integer targetClass
    real    damageMin
    real    failChance
    integer attackType
    integer damageType
    integer userType

    // getter:
    method operator runChance takes nothing returns real
        return 1.00 - this.failChance
    endmethod

    // setter:
    method operator runChance= takes real chance returns nothing
        set this.failChance = 1.00 - chance
    endmethod

    method configure takes nothing returns nothing
        set this.attackType  = udg_DamageFilterAttackT
        set this.damageType  = udg_DamageFilterDamageT
        set this.source      = udg_DamageFilterSource
        set this.target      = udg_DamageFilterTarget
        set this.sourceType  = udg_DamageFilterSourceT
        set this.targetType  = udg_DamageFilterTargetT
        set this.sourceItem  = udg_DamageFilterSourceI
        set this.targetItem  = udg_DamageFilterTargetI
        set this.sourceClass = udg_DamageFilterSourceC
        set this.targetClass = udg_DamageFilterTargetC
        set this.userType    = udg_DamageFilterType
        set this.damageMin   = udg_DamageFilterMinAmount
        set this.failChance  = 1.00 - (udg_DamageFilterRunChance - udg_DamageFilterFailChance)

        if udg_DamageFilterSourceA > 0 then
            set this.sourceBuff = udg_DamageFilterSourceA
            set udg_DamageFilterSourceA = 0
        else
            set this.sourceBuff = udg_DamageFilterSourceB
        endif

        if udg_DamageFilterTargetA > 0 then
            set this.targetBuff = udg_DamageFilterTargetA
            set udg_DamageFilterTargetA = 0
        else
            set this.targetBuff = udg_DamageFilterTargetB
        endif

        set udg_DamageFilterSource = null
        set udg_DamageFilterTarget = null

        //These handles can have a valid value of 0, so we need to distinguish them.
        set udg_DamageFilterAttackT = -1
        set udg_DamageFilterDamageT = -1
        set udg_DamageFilterSourceC = -1
        set udg_DamageFilterTargetC = -1

        set udg_DamageFilterSourceT = 0
        set udg_DamageFilterTargetT = 0
        set udg_DamageFilterType    = 0
        set udg_DamageFilterSourceB = 0
        set udg_DamageFilterTargetB = 0
        set udg_DamageFilterSourceI = 0
        set udg_DamageFilterTargetI = 0
        
        set udg_DamageFilterMinAmount  = 0.00
        set udg_DamageFilterFailChance = 0.00
        set udg_DamageFilterRunChance  = 1.00

        set this.configured = true
    endmethod

    static method setGUIFromStruct takes boolean full returns nothing
        set udg_DamageEventAmount  = Damage.index.damage
        set udg_DamageEventAttackT = GetHandleId(Damage.index.attackType)
        set udg_DamageEventDamageT = GetHandleId(Damage.index.damageType)
        set udg_DamageEventWeaponT = GetHandleId(Damage.index.weaponType)
        set udg_DamageEventType    = Damage.index.userType
        
        static if USE_ARMOR_MOD then
            set udg_DamageEventArmorPierced = Damage.index.armorPierced
            set udg_DamageEventArmorT       = Damage.index.armorType
            set udg_DamageEventDefenseT     = Damage.index.defenseType
        endif
        if full then
            set udg_DamageEventSource  = Damage.index.sourceUnit
            set udg_DamageEventTarget  = Damage.index.targetUnit
            set udg_DamageEventPrevAmt = Damage.index.prevAmt
            set udg_IsDamageAttack     = Damage.index.isAttack
            set udg_IsDamageCode       = Damage.index.isCode
            set udg_IsDamageSpell      = Damage.index.isSpell
            
            //! runtextmacro optional ATTACK_INDEXER_GUI_VARS()

            static if USE_MELEE_RANGE then
                set udg_IsDamageMelee  = Damage.index.isMelee
                set udg_IsDamageRanged = Damage.index.isRanged
            endif
        endif
    endmethod

    static method setStructFromGUI takes nothing returns nothing
        set Damage.index.damage     = udg_DamageEventAmount
        set Damage.index.attackType = ConvertAttackType(udg_DamageEventAttackT)
        set Damage.index.damageType = ConvertDamageType(udg_DamageEventDamageT)
        set Damage.index.weaponType = ConvertWeaponType(udg_DamageEventWeaponT)
        set Damage.index.userType   = udg_DamageEventType
        
        static if USE_ARMOR_MOD then
            set Damage.index.armorPierced = udg_DamageEventArmorPierced
            set Damage.index.armorType    = udg_DamageEventArmorT
            set Damage.index.defenseType  = udg_DamageEventDefenseT
        endif
    endmethod

    static method getVerboseStr takes string eventName returns string
        if eventName == "Modifier" or eventName == "Mod" then
            return "udg_DamageModifierEvent"
        endif
        return "udg_" + eventName + "DamageEvent"
    endmethod

    private static method getStrIndex takes string var, real lbs returns thistype
        local integer root = R2I(lbs)
        if (var == "udg_DamageModifierEvent" and root < 4) or var == "udg_PreDamageEvent" then
            set root = MOD
        elseif var == "udg_DamageModifierEvent" or var == "udg_ArmorDamageEvent" then
            set root = SHIELD
        elseif (var == "udg_DamageEvent" and root == 2 or root == 0) or var == "udg_ZeroDamageEvent" then
            set root = ZERO
        elseif var == "udg_DamageEvent" or var == "udg_OnDamageEvent" then
            set root = DAMAGE
        elseif var == "udg_AfterDamageEvent" then
            set root = AFTER
        elseif var == "udg_LethalDamageEvent" then
            set root = LETHAL
        elseif var == "udg_AOEDamageEvent" or var == "udg_SourceDamageEvent" then
            set root = AOE
        else
            set root = 0
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_GDD()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_PDD()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_01()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_02()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_03()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_04()
            //! runtextmacro optional DAMAGE_EVENT_REG_PLUGIN_05()
        endif
        return root
    endmethod

    private method toggleAllFilters takes boolean flag returns nothing
        set filters[this + FILTER_ATTACK] = flag
        set filters[this + FILTER_MELEE] = flag
        set filters[this + FILTER_OTHER] = flag
        set filters[this + FILTER_RANGED] = flag
        set filters[this + FILTER_SPELL] = flag
        set filters[this + FILTER_CODE] = flag
    endmethod

    method operator filter= takes integer opId returns nothing
        set this = this * FILTER_MAX
        if opId == FILTER_OTHER then
            call this.toggleAllFilters(true)
        else
            if opId == FILTER_ATTACK then
                set filters[this + FILTER_ATTACK] = true
                set filters[this + FILTER_MELEE] = true
                set filters[this + FILTER_RANGED] = true
            else
                set filters[this + opId] = true
            endif
        endif
    endmethod

    static method registerVerbose takes /*
        */ trigger whichTrig, /*
        */ string var, /*
        */ real lbs, /*
        */ boolean GUI, /*
        */ integer filt /*
    */ returns thistype
        local thistype index = getStrIndex(var, lbs)
        local thistype i = 0
        local thistype id = 0

        if index == 0 then
            return 0
        elseif lastRegistered.rootTrig == whichTrig and lastRegistered.usingGUI then
            //allows GUI to register multiple different types of Damage filters to the same trigger
            set filters[lastRegistered*FILTER_MAX + filt] = true
            return 0
        endif

        set atLeastOneLethalDamageEventRegistered = /*
            */ atLeastOneLethalDamageEventRegistered or index == LETHAL

        if trigIndexStack[0] == 0 then
            set count = count + 1   //List runs from index 10 and up
            set id = count
        else
            set id = trigIndexStack[0]
            set trigIndexStack[0] = trigIndexStack[id]
        endif
        set lastRegistered = id
        set id.filter = filt
        set id.rootTrig = whichTrig
        set id.usingGUI = GUI
        set id.weight = lbs
        set id.eventStr = var

        //Next 2 lines added to fix a bug when using manual vJass configuration,
        //discovered and solved by lolreported
        set id.attackType = -1
        set id.damageType = -1

        //they will probably bug out with class types as well, so I should add them, just in case:
        set id.sourceClass = -1
        set id.targetClass = -1

        loop
            set i = index.next
            exitwhen i == 0 or lbs < i.weight
            set index = i
        endloop
        set index.next = id
        set id.next = i

        //call BJDebugMsg("Registered " + I2S(id) + " to " + I2S(index) + " and before " + I2S(i))
        return lastRegistered
    endmethod

    static method registerTrigger takes trigger t, string var, real lbs returns thistype
        return registerVerbose(t, DamageTrigger.getVerboseStr(var), lbs, false, FILTER_OTHER)
    endmethod

    private static thistype prev = 0
    static method getIndex takes /* 
        */ trigger t, /* 
        */ string eventName, /* 
        */ real lbs /* 
    */ returns thistype
        local thistype index = getStrIndex(getVerboseStr(eventName), lbs)
        loop
            set prev = index
            set index = index.next
            exitwhen index == 0 or index.rootTrig == t
        endloop
        return index
    endmethod

    method unregisterByIndex takes boolean reset returns boolean
        if this == 0 then
            return false
        endif
        set prev.next = this.next

        set trigIndexStack[this] = trigIndexStack[0]
        set trigIndexStack[0] = this

        if reset then
            call this.configure()
            set this.configured = false
            call thistype(this*FILTER_MAX).toggleAllFilters(false)
        endif
        return true
    endmethod

    static method unregister takes /*
        */ trigger t, /*
        */ string eventName, /*
        */ real lbs, /*
        */ boolean reset /*
    */ returns boolean
        return getIndex(t, eventName, lbs).unregisterByIndex(reset)
    endmethod

    method run takes nothing returns nothing
        local integer cat = this
        local Damage d = Damage.index

        static if USE_GUI then
            local boolean structUnset = false
            local boolean guiUnset = false
            local boolean mod = cat <= DAMAGE
        endif

        if callbacksInProgress then
            return
        endif
        set callbacksInProgress = true
        call DisableTrigger(damagingTrigger)
        call DisableTrigger(damagedTrigger)
        call EnableTrigger(recursiveTrigger)
        //call BJDebugMsg("Start of event running")
        loop
            set this = this.next
            exitwhen this == 0
            exitwhen cat == MOD and (udg_DamageEventOverride or udg_DamageEventType == TYPE_PURE)
            exitwhen cat == SHIELD and udg_DamageEventAmount <= 0.00

            static if USE_LETHAL then
                exitwhen cat == LETHAL and udg_LethalDamageHP > DEATH_VAL
            endif

            set eventIndex = this
            if (not this.trigFrozen) and /*
                */ filters[this*FILTER_MAX + d.eFilter] and /*
                */ IsTriggerEnabled(this.rootTrig) and /*
                */ ((not this.configured) or (this.checkConfig())) and /*
                */ (cat != AOE or udg_DamageEventAOE > 1 or this.eventStr == "udg_SourceDamageEvent") /*
            */ then
                static if USE_GUI then
                    if mod then
                        if this.usingGUI then
                            if guiUnset then
                                set guiUnset = false
                                call setGUIFromStruct(false)
                            endif
                            //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_PDD()
                        elseif structUnset then
                            set structUnset = false
                            call setStructFromGUI()
                        endif
                    endif
                endif
                //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_01()
                //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_02()
                //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_03()
                //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_04()
                //! runtextmacro optional DAMAGE_EVENT_FILTER_PLUGIN_05()

                //JASS users who do not use actions can modify the below block to just evaluate.
                //It should not make any perceptable difference in terms of performance.
                if TriggerEvaluate(this.rootTrig) then
                    call TriggerExecute(this.rootTrig)
                endif
                //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_01()
                //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_02()
                //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_03()
                //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_04()
                //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_05()
                static if USE_GUI then
                    if mod then
                        if this.usingGUI then
                            //! runtextmacro optional DAMAGE_EVENT_MOD_PLUGIN_PDD()
                            if cat != MOD then
                                set d.damage = udg_DamageEventAmount
                            else
                                set structUnset = true
                            endif
                        elseif cat != MOD then
                            set udg_DamageEventAmount = d.damage
                        else
                            set guiUnset = true
                        endif
                    endif
                    if udg_RemoveDamageEvent then
                        set udg_RemoveDamageEvent = false
                        call this.unregisterByIndex(true)
                    endif
                endif
            endif
        endloop

        static if USE_GUI then
            if structUnset then
                call setStructFromGUI()
            endif
            if guiUnset then
                call setGUIFromStruct(false)
            endif
        else
            call setGUIFromStruct(false)
        endif

        //call BJDebugMsg("End of event running")

        call DisableTrigger(recursiveTrigger)
        call EnableTrigger(damagingTrigger)
        call EnableTrigger(damagedTrigger)
        set callbacksInProgress = false
    endmethod

/*
    Used by RegisterDamageEngineEx to create triggers behind-the-scenes,
    allowing the user to simply pass the function they want to execute.
*/
    static trigger array autoTriggers
    static boolexpr array autoFuncs
    static integer autoN = 0

    static method operator [] takes code callback returns trigger
        local integer i = 0
        local boolexpr b = Filter(callback)
        loop
            if i == autoN then
                set autoTriggers[i] = CreateTrigger()
                set autoFuncs[i] = b
                call TriggerAddCondition(autoTriggers[i], b)
                exitwhen true
            endif
            set i = i + 1
            exitwhen b == autoFuncs[i]
        endloop
        return autoTriggers[i]
    endmethod
endstruct

//! runtextmacro optional DAMAGE_EVENT_USER_STRUCT_PLUGIN_01()
//! runtextmacro optional DAMAGE_EVENT_USER_STRUCT_PLUGIN_02()
//! runtextmacro optional DAMAGE_EVENT_USER_STRUCT_PLUGIN_03()
//! runtextmacro optional DAMAGE_EVENT_USER_STRUCT_PLUGIN_04()
//! runtextmacro optional DAMAGE_EVENT_USER_STRUCT_PLUGIN_05()

struct Damage extends array
    readonly unit    sourceUnit
    readonly unit    targetUnit
    real             damage
    readonly real    prevAmt
    attacktype       attackType
    damagetype       damageType
    weapontype       weaponType
    integer          userType
    readonly boolean isAttack
    readonly boolean isCode
    readonly boolean isSpell

    static if USE_MELEE_RANGE then
        readonly boolean isMelee       //stores udg_IsDamageMelee
    endif

    readonly boolean isRanged      //stores udg_IsDamageRanged
    readonly integer eFilter       //stores the previous eventFilter variable

    static if USE_ARMOR_MOD then
        real    armorPierced  //stores udg_DamageEventArmorPierced
        integer armorType     //stores udg_DamageEventArmorT
        integer defenseType   //stores udg_DamageEventDefenseT
    endif

    readonly static Damage index = 0

    private static Damage damageStack = 0

    private static Damage prepped = 0

    private static integer count = 0 //The number of currently-running queued or sequential damage instances

    private Damage stackRef
    private DamageTrigger recursiveTrig

    private integer prevArmorT
    private integer prevDefenseT

    static method operator source takes nothing returns unit
        return udg_DamageEventSource
    endmethod

    static method operator target takes nothing returns unit
        return udg_DamageEventTarget
    endmethod

    static method operator amount takes nothing returns real
        return Damage.index.damage
    endmethod

    static method operator amount= takes real r returns nothing
        set Damage.index.damage = r
    endmethod

    static if USE_ARMOR_MOD then
        private method setArmor takes boolean reset returns nothing
            local real pierce
            local integer damage_at
            local integer damage_dt

            if reset then
                set pierce = udg_DamageEventArmorPierced
                set damage_at = Damage.index.prevArmorT
                set damage_dt = Damage.index.prevDefenseT
                set udg_DamageEventArmorPierced = 0.00
                set this.armorPierced = 0.00
            else
                set pierce = -udg_DamageEventArmorPierced
                set damage_at = udg_DamageEventArmorT
                set damage_dt = udg_DamageEventDefenseT
            endif

            if not (pierce == 0.00) then //Changed from != to not == due to bug reported by BLOKKADE
                call BlzSetUnitArmor(udg_DamageEventTarget, BlzGetUnitArmor(udg_DamageEventTarget) + pierce)
            endif

            if Damage.index.prevArmorT != udg_DamageEventArmorT then
                call BlzSetUnitIntegerField(udg_DamageEventTarget, UNIT_IF_ARMOR_TYPE, damage_at)
            endif
            if Damage.index.prevDefenseT != udg_DamageEventDefenseT then
                call BlzSetUnitIntegerField(udg_DamageEventTarget, UNIT_IF_DEFENSE_TYPE, damage_dt)
            endif
        endmethod
    endif

    static if USE_EXTRA then
        private static method onAOEEnd takes nothing returns nothing
            call DamageTrigger.AOE.run()
            set udg_DamageEventAOE = 1
            set udg_DamageEventLevel = 1
            set udg_EnhancedDamageTarget = null
            set udg_AOEDamageSource = null
            call GroupClear(udg_DamageEventAOEGroup)
        endmethod
    endif

    private static method afterDamage takes nothing returns nothing
        if udg_DamageEventDamageT != 0 and not (udg_DamageEventPrevAmt == 0.00) then
            call DamageTrigger.AFTER.run()
            set udg_DamageEventDamageT  = 0
            set udg_DamageEventPrevAmt  = 0.00
        endif
    endmethod

    private method runDamagingEvents takes boolean natural returns boolean

        static if USE_ARMOR_MOD then
            set this.armorType    = BlzGetUnitIntegerField(this.targetUnit, UNIT_IF_ARMOR_TYPE)
            set this.defenseType  = BlzGetUnitIntegerField(this.targetUnit, UNIT_IF_DEFENSE_TYPE)
            set this.prevArmorT   = this.armorType
            set this.prevDefenseT = this.defenseType
            set this.armorPierced = 0.00
        endif

        set Damage.index = this
        call DamageTrigger.setGUIFromStruct(true)

        call GroupAddUnit(recursionSources, udg_DamageEventSource)
        call GroupAddUnit(recursionTargets, udg_DamageEventTarget)

        //! runtextmacro optional DAMAGE_EVENT_PRE_VARS_PLUGIN_01()
        //! runtextmacro optional DAMAGE_EVENT_PRE_VARS_PLUGIN_02()
        //! runtextmacro optional DAMAGE_EVENT_PRE_VARS_PLUGIN_03()
        //! runtextmacro optional DAMAGE_EVENT_PRE_VARS_PLUGIN_04()
        //! runtextmacro optional DAMAGE_EVENT_PRE_VARS_PLUGIN_05()

        // Using not == instead of !=; the idea is to eliminate floating point bugs when two numbers are very close to 0,
        // because JASS uses a less-strict comparison for checking if a number is equal than when it is unequal.
        if not (udg_DamageEventAmount == 0.00) then
            set udg_DamageEventOverride = udg_DamageEventDamageT == 0

            call DamageTrigger.MOD.run()

            static if not USE_GUI then
                call DamageTrigger.setGUIFromStruct(false)
            endif

            if natural then
                call BlzSetEventAttackType(this.attackType)
                call BlzSetEventDamageType(this.damageType)
                call BlzSetEventWeaponType(this.weaponType)
                call BlzSetEventDamage(udg_DamageEventAmount)
            endif

            static if USE_ARMOR_MOD then
                call this.setArmor(false)
            endif

            return false
        endif
        return true //return value is based on whether the event is a 0 damage event (true) or not (false).
    endmethod

    private static method unfreeze takes nothing returns nothing
        local Damage i = damageStack

        loop
            exitwhen i == 0
            set i = i - 1
            set i.stackRef.recursiveTrig.trigFrozen = false
            set i.stackRef.recursiveTrig.ownRecursiveDepth = 0
        endloop

        call EnableTrigger(damagingTrigger)
        call EnableTrigger(damagedTrigger)

        set recursiveCallbaksInProgress = false
        set damageStack = 0
        set prepped = 0
        set callbacksInProgress = false
        set recursiveCallbackDepth = 0
        call GroupClear(recursionSources)
        call GroupClear(recursionTargets)

        //call BJDebugMsg("Cleared up the groups")
    endmethod

    static method runAfterDamageEvents takes nothing returns nothing
        local Damage i = 0
        local integer exit

        if nativeEventsCompleted then
            set nativeEventsCompleted = false
            call afterDamage()
        endif

        if isNotNativeRecursiveDamage and not recursiveCallbaksInProgress then
            if damageStack != 0 then
                set recursiveCallbaksInProgress = true
                loop
                /*
                    Use two loops. The outer loop handles all normal event
                    execution, while the inner loop intelligently handles
                    recursive execution (when it's used).
                */
                    set recursiveCallbackDepth = recursiveCallbackDepth + 1
                    set exit = damageStack
                    loop
                        set prepped = i.stackRef

                        if UnitAlive(prepped.targetUnit) then

                            // We don't need to trigger `damagingTrigger` itself, so just call its handler directly.
                            call prepped.runDamagingEvents(false)

                            if prepped.damage > 0.00 then
                                call DisableTrigger(damagingTrigger) // Disallow `damagingTrigger` because we only want `damageTrigger` to run.
                                call EnableTrigger(damagedTrigger)   // Re-enable `damagedTrigger` in case the user forgot to do so.

                                set waitingForDamageEventToRun = true

                                call UnitDamageTarget( /*
                                    */ prepped.sourceUnit, /*
                                    */ prepped.targetUnit, /*
                                    */ prepped.damage, /*
                                    */ prepped.isAttack, /*
                                    */ prepped.isRanged, /*
                                    */ prepped.attackType, /*
                                    */ prepped.damageType, /*
                                    */ prepped.weaponType /*
                                */ )
                            else
                                if udg_DamageEventDamageT != 0 then
                                    //No native events run at all in this case
                                    call DamageTrigger.DAMAGE.run()
                                endif

                                if prepped.damage < 0.00 then
                                /*
                                    No need for BlzSetEventDamage/UnitDamageTarget here,
                                    because we can safely adjust the unit's life instead.
                                */
                                    call SetWidgetLife( /*
                                        */ prepped.targetUnit, /*
                                        */ GetWidgetLife(prepped.targetUnit) - prepped.damage /*
                                    */ )
                                endif

                                static if USE_ARMOR_MOD then
                                    call prepped.setArmor(true)
                                endif
                            endif
                            call afterDamage()
                        endif
                        set i = i + 1
                        exitwhen i == exit
                    endloop
                    exitwhen i == damageStack
                endloop
            endif
            call unfreeze()
        endif
    endmethod

    private static method failsafeClear takes nothing returns nothing
        static if USE_ARMOR_MOD then
            call Damage.index.setArmor(true)
        endif
        set isNotNativeRecursiveDamage = true
        set recursiveCallbaksInProgress = false

        set waitingForDamageEventToRun = false

        if udg_DamageEventDamageT != 0 then
            call DamageTrigger.DAMAGE.run()
            set nativeEventsCompleted = true
        endif

        call runAfterDamageEvents()
    endmethod

    static method operator enabled= takes boolean b returns nothing
        if b then
            if callbacksInProgress then
                call EnableTrigger(recursiveTrigger)
            else
                call EnableTrigger(damagingTrigger)
                call EnableTrigger(damagedTrigger)
            endif
        else
            if callbacksInProgress then
                call DisableTrigger(recursiveTrigger)
            else
                call DisableTrigger(damagingTrigger)
                call DisableTrigger(damagedTrigger)
            endif
        endif
    endmethod

    static method operator enabled takes nothing returns boolean
        return IsTriggerEnabled(damagingTrigger)
    endmethod

    private static boolean threadCompleted = false

    private static method asyncCallbackSafeCallback takes nothing returns nothing
        if waitingForDamageEventToRun then
        /*
            This means that WarCraft 3 didn't run the DAMAGED event despite running the DAMAGING event.
        */
            call failsafeClear()
        else
            set isNotNativeRecursiveDamage = true
            set recursiveCallbaksInProgress = false
            call runAfterDamageEvents()
        endif

        static if USE_EXTRA then
            call onAOEEnd()
        endif

        set threadCompleted = true
    endmethod

    private static method asyncCallback takes nothing returns nothing
        set callbacksInProgress = false
        set Damage.enabled = true
    /*
        Open a new thread in case of a thread crash during callback.
    */
        call ForForce(bj_FORCE_PLAYER[0], function thistype.asyncCallbackSafeCallback)

        if not threadCompleted then
            //call BJDebugMsg("DamageEngine issue: thread crashed!")
            call unfreeze()
        else
            set threadCompleted = false
        endif

        set Damage.count = 0
        set Damage.index = 0
        set timerStarted = false

        //call BJDebugMsg("Timer wrapped up")
    endmethod

    private method addRecursive takes nothing returns nothing
        local DamageTrigger currentIndex

        if not (this.damage == 0.00) then

            set currentIndex = DamageTrigger.eventIndex

            set this.recursiveTrig = currentIndex

            if not this.isCode then
            /*
                If the recursive damage trigger is executed, this can only
                mean that the user has manually dealt damage from a trigger.
                Hence flag the damage as being 'code' if they didn't already
                manually do this.
            */
                set this.isCode = true
                set this.userType = TYPE_CODE
            endif

            set inception = inception or /*
                */ currentIndex.manualRecursionRequested

            if recursiveCallbaksInProgress and /*
                */ IsUnitInGroup(this.sourceUnit, recursionSources) and /*
                */ IsUnitInGroup(this.targetUnit, recursionTargets) /*
            */ then
                if not inception then
                    set currentIndex.trigFrozen = true

                elseif not currentIndex.trigFrozen then
                    
                    set currentIndex.manualRecursionRequested = true

                    if currentIndex.ownRecursiveDepth < recursiveCallbackDepth then

                        set currentIndex.ownRecursiveDepth = /*
                            */ currentIndex.ownRecursiveDepth + 1

                        if currentIndex.ownRecursiveDepth >= MAX_RECURSIVE_TOLERANCE then
                            set currentIndex.trigFrozen = true
                        endif
                    endif
                endif
            endif

            // push the reference to the top of the damage stack.
            set damageStack.stackRef = this
            set damageStack = damageStack + 1

            //call BJDebugMsg("damageStack: " + I2S(damageStack) + " ownRecursiveDepth: " + I2S(currentIndex.ownRecursiveDepth) + " recursiveCallbackDepth: " + I2S(recursiveCallbackDepth))
        endif
        set inception = false
    endmethod

    private static method clearNexts takes nothing returns nothing
        set udg_NextDamageIsAttack = false
        set udg_NextDamageType = 0
        set udg_NextDamageWeaponT = 0

        static if USE_MELEE_RANGE then
            set udg_NextDamageIsMelee = false
            set udg_NextDamageIsRanged = false
        endif
    endmethod

    static method create takes /*
        */ unit src, /*
        */ unit tgt, /*
        */ real amt, /*
        */ boolean isAttack, /*
        */ attacktype  damage_at, /*
        */ damagetype  damage_dt, /*
        */ weapontype  damage_wt /*
    */ returns Damage
        local Damage d = Damage.count + 1
        set Damage.count = d
        
        set d.sourceUnit = src
        set d.targetUnit = tgt
        set d.damage = amt
        set d.prevAmt = amt

        set d.damageType =  damage_dt
        set d.attackType =  damage_at
        set d.weaponType =  damage_wt

        set d.isAttack = udg_NextDamageIsAttack or isAttack
        set d.isSpell = d.attackType == null and not d.isAttack
        return d
    endmethod

    private static method createFromEvent takes nothing returns Damage
        local Damage d = thistype.create( /*
            */ GetEventDamageSource(), /*
            */ GetTriggerUnit(), /*
            */ GetEventDamage(), /*
            */ BlzGetEventIsAttack(), /*
            */ BlzGetEventAttackType(), /*
            */ BlzGetEventDamageType(), /*
            */ BlzGetEventWeaponType() /*
        */ )

        set d.isCode = udg_NextDamageType != 0 or /*
            */ udg_NextDamageIsAttack or /*
            */ udg_NextDamageIsRanged or /*
            */ udg_NextDamageIsMelee or /*
            */ d.damageType == DAMAGE_TYPE_MIND or /*
            */ udg_NextDamageWeaponT != 0 or /*
            */ (d.damageType == DAMAGE_TYPE_UNKNOWN and not (d.damage == 0.00))

        if d.isCode then
            if udg_NextDamageType != 0 then
                set d.userType = udg_NextDamageType
            else
                set d.userType = TYPE_CODE
            endif

            static if USE_MELEE_RANGE then
                set d.isMelee = udg_NextDamageIsMelee
                set d.isRanged = udg_NextDamageIsRanged
            endif

            set d.eFilter = FILTER_CODE

            if udg_NextDamageWeaponT != 0 then
                set d.weaponType = ConvertWeaponType(udg_NextDamageWeaponT)
                set udg_NextDamageWeaponT = 0
            endif
        else
            set d.userType = 0

            if d.damageType == DAMAGE_TYPE_NORMAL and d.isAttack then

                // Added in version 5.A in order to allow an optional external 
                // Attack Indexer system to reset the event weapon type to normal.
                //! runtextmacro optional ATTACK_INDEXER_ADJUSTMENTS()

                static if USE_MELEE_RANGE then
                    set d.isMelee = IsUnitType(d.sourceUnit, UNIT_TYPE_MELEE_ATTACKER)
                    set d.isRanged = IsUnitType(d.sourceUnit, UNIT_TYPE_RANGED_ATTACKER)

                    if d.isMelee and d.isRanged then
                        // Melee units always play a sound when damaging in WC3, 
                        // so this is an easy check.
                        set d.isMelee = d.weaponType != null

                        // In the case where a unit is both ranged and melee,
                        // the ranged attack plays no sound.
                        set d.isRanged = not d.isMelee
                    endif

                    if d.isMelee then
                        set d.eFilter = FILTER_MELEE
                    elseif d.isRanged then
                        set d.eFilter = FILTER_RANGED
                    else
                        set d.eFilter = FILTER_ATTACK
                    endif
                else
                    set d.eFilter = FILTER_ATTACK
                endif
            else
                if d.isSpell then
                    set d.eFilter = FILTER_SPELL
                else
                    set d.eFilter = FILTER_OTHER
                endif

                static if USE_MELEE_RANGE then
                    // Spells are neither melee nor ranged.
                    set d.isMelee = false
                    set d.isRanged = false
                endif
            endif
        endif
        call clearNexts()
        return d
    endmethod

    private static method onRecursiveDamageCallback takes nothing returns boolean
        local Damage d  = Damage.createFromEvent()
        call d.addRecursive()
        call BlzSetEventDamage(0.00)
        return false
    endmethod

    private static method onDamagingCallback takes nothing returns boolean
        local Damage d = Damage.createFromEvent()

        //call BJDebugMsg("Pre-damage event running for " + GetUnitName(GetTriggerUnit()))

        if timerStarted then
            if waitingForDamageEventToRun then
                //WarCraft 3 didn't run the DAMAGED event despite running the DAMAGING event.

                if d.damageType == DAMAGE_TYPE_SPIRIT_LINK or /*
                    */ d.damageType == DAMAGE_TYPE_DEFENSIVE or /*
                    */ d.damageType == DAMAGE_TYPE_PLANT /*
                */ then
                    set waitingForDamageEventToRun = false
                    set lastInstance = Damage.index
                    set isNotNativeRecursiveDamage = false
                else
                    call failsafeClear() //Not an overlapping event - just wrap it up
                endif
            else
                call runAfterDamageEvents() //wrap up any previous damage index
            endif

            static if USE_EXTRA then
                if d.sourceUnit != udg_AOEDamageSource then

                    call onAOEEnd()
                    set udg_AOEDamageSource = d.sourceUnit
                    set udg_EnhancedDamageTarget = d.targetUnit

                elseif d.targetUnit == udg_EnhancedDamageTarget then

                    set udg_DamageEventLevel= udg_DamageEventLevel + 1

                elseif not IsUnitInGroup(d.targetUnit, udg_DamageEventAOEGroup) then
                    set udg_DamageEventAOE  = udg_DamageEventAOE + 1
                endif
            endif
        else
            call TimerStart(async, 0.00, false, function Damage.asyncCallback)
            set timerStarted = true

            static if USE_EXTRA then
                set udg_AOEDamageSource     = d.sourceUnit
                set udg_EnhancedDamageTarget= d.targetUnit
            endif
        endif

        static if USE_EXTRA then
            call GroupAddUnit(udg_DamageEventAOEGroup, d.targetUnit)
        endif

        if d.runDamagingEvents(true) then
            call DamageTrigger.ZERO.run()
            set isNotNativeRecursiveDamage = true
            call runAfterDamageEvents()
        endif

        set waitingForDamageEventToRun = lastInstance == 0 or /*
            */ attacksImmune[udg_DamageEventAttackT] or /*
            */ damagesImmune[udg_DamageEventDamageT] or /*
            */ not IsUnitType(udg_DamageEventTarget, UNIT_TYPE_MAGIC_IMMUNE)

        return false
    endmethod

    private static method onDamagedCallback takes nothing returns boolean
        local real r = GetEventDamage()
        local Damage d = Damage.index

        //call BJDebugMsg("Second damage event running for " + GetUnitName(GetTriggerUnit()))

        if prepped > 0 then
            set prepped = 0
        elseif callbacksInProgress or d.prevAmt == 0.00 then
            return false
        elseif waitingForDamageEventToRun then
            set waitingForDamageEventToRun = false
        else
        /*
            This should only happen for native recursive WarCraft 3 damage
            such as Spirit Link, Thorns Aura, or Spiked Carapace / Barricades.
        */    
            call afterDamage()
            set Damage.index = lastInstance
            set lastInstance = 0
            set d = Damage.index

        /*
            Since the native recursive damage has now wrapped up, we can resume
            handling events as normal at this point. This means that the original
            target that the DAMAGING event was triggered for is now finally getting
            its DAMAGED event.
        */
            set isNotNativeRecursiveDamage = true

            call DamageTrigger.setGUIFromStruct(true)
        endif

        static if USE_ARMOR_MOD then
            call d.setArmor(true)
        endif

        static if USE_SCALING then
            if not (udg_DamageEventAmount == 0.00) and not (r == 0.00) then
                set udg_DamageScalingWC3 = r / udg_DamageEventAmount
            elseif udg_DamageEventAmount > 0.00 then
                set udg_DamageScalingWC3 = 0.00
            else
                set udg_DamageScalingWC3 = 1.00
                if udg_DamageEventPrevAmt == 0.00 then
                    set udg_DamageScalingUser = 0.00
                else
                    set udg_DamageScalingUser = /*
                        */ udg_DamageEventAmount / udg_DamageEventPrevAmt
                endif
            endif
        endif
        set udg_DamageEventAmount = r
        set d.damage = r

        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_GDD()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_PDD()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_01()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_02()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_03()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_04()
        //! runtextmacro optional DAMAGE_EVENT_VARS_PLUGIN_05()

        if udg_DamageEventAmount > 0.00 then

            call DamageTrigger.SHIELD.run()

            static if not USE_GUI then
                set udg_DamageEventAmount = d.damage
            endif

            static if USE_LETHAL then
                if atLeastOneLethalDamageEventRegistered or udg_DamageEventType < 0 then
                    set udg_LethalDamageHP = /*
                        */ GetWidgetLife(udg_DamageEventTarget) - udg_DamageEventAmount

                    if udg_LethalDamageHP <= DEATH_VAL then
                        if atLeastOneLethalDamageEventRegistered then
                            call DamageTrigger.LETHAL.run()

                            set udg_DamageEventAmount = /*
                                */ GetWidgetLife(udg_DamageEventTarget) - udg_LethalDamageHP
                            set d.damage = udg_DamageEventAmount
                        endif
                        if udg_DamageEventType < 0 and /*
                            */ udg_LethalDamageHP <= DEATH_VAL /*
                        */ then
                            call SetUnitExploded(udg_DamageEventTarget, true)
                        endif
                    endif
                endif
            endif

            static if USE_SCALING then
                if udg_DamageEventPrevAmt == 0.00 or /*
                    */ udg_DamageScalingWC3 == 0.00 /*
                */ then
                    set udg_DamageScalingUser = 0.00
                else
                    set udg_DamageScalingUser = /*
                        */ udg_DamageEventAmount / udg_DamageEventPrevAmt / udg_DamageScalingWC3
                endif
            endif
        endif

        if udg_DamageEventDamageT != 0 then
            call DamageTrigger.DAMAGE.run()
        endif

        call BlzSetEventDamage(udg_DamageEventAmount)

        set nativeEventsCompleted = true

        if udg_DamageEventAmount == 0.00 then
            call runAfterDamageEvents()
        endif

        // This return statement was needed years ago to avoid potential crashes on Mac.
        // I am not sure if that's still a thing.
        return false
    endmethod

    static method apply takes /*
        */ unit src, /*
        */ unit tgt, /*
        */ real amt, /*
        */ boolean a, /*
        */ boolean r, /*
        */ attacktype damage_at, /*
        */ damagetype damage_dt, /*
        */ weapontype damage_wt /*
    */ returns Damage
        local Damage d

        if udg_NextDamageType == 0 then
           set udg_NextDamageType = TYPE_CODE
        endif

        if callbacksInProgress then
            set d = create(src, tgt, amt, a, damage_at, damage_dt, damage_wt)
            set d.isCode = true
            set d.eFilter = FILTER_CODE

            set d.userType = udg_NextDamageType

            static if USE_MELEE_RANGE then
                if not d.isSpell then
                    set d.isRanged = udg_NextDamageIsRanged or r
                    set d.isMelee  = not d.isRanged
                endif
            endif

            call d.addRecursive()
        else
            call UnitDamageTarget(src, tgt, amt, a, r, damage_at, damage_dt, damage_wt)

            set d = Damage.index

            call runAfterDamageEvents()
        endif

        call clearNexts()

        return d
    endmethod

    static method applySpell takes /*
        */ unit src, /*
        */ unit tgt, /*
        */ real amt, /*
        */ damagetype damage_dt /*
    */ returns Damage
        return apply(src, tgt, amt, false, false, null, damage_dt, null)
    endmethod

    static method applyAttack takes /*
        */ unit src, /*
        */ unit tgt, /*
        */ real amt, /*
        */ boolean ranged, /*
        */ attacktype damage_at, /*
        */ weapontype damage_wt /*
    */ returns Damage
        return apply(src, tgt, amt, true, ranged, damage_at, DAMAGE_TYPE_NORMAL, damage_wt)
    endmethod

/*
    This part is the most critical to get things kicked off. All the code we've seen up until now
    is related to event handling, trigger assignment, edge cases, etc. But it's the following that
    is really quite esesntial for any damage engine - not just this one.
*/
    private static method onInit takes nothing returns nothing
        set async = CreateTimer()

        set recursionSources = CreateGroup()
        set recursionTargets = CreateGroup()

        set damagingTrigger  = CreateTrigger()
        set damagedTrigger   = CreateTrigger()
        set recursiveTrigger = CreateTrigger() //Moved from globals block as per request of user Ricola3D

        call TriggerRegisterAnyUnitEventBJ(damagingTrigger, EVENT_PLAYER_UNIT_DAMAGING)
        call TriggerAddCondition(damagingTrigger, Filter(function Damage.onDamagingCallback))

        call TriggerRegisterAnyUnitEventBJ(damagedTrigger, EVENT_PLAYER_UNIT_DAMAGED)
        call TriggerAddCondition(damagedTrigger, Filter(function Damage.onDamagedCallback))

        //For recursion
        call TriggerRegisterAnyUnitEventBJ(recursiveTrigger, EVENT_PLAYER_UNIT_DAMAGING)
        call TriggerAddCondition(recursiveTrigger, Filter(function Damage.onRecursiveDamageCallback))
        call DisableTrigger(recursiveTrigger) //starts disabled. Will be enabled during recursive event handling.

    /*
        For preventing Thorns/Defensive glitch.
        Data gathered from https://www.hiveworkshop.com/threads/repo-in-progress-mapping-damage-types-to-their-abilities.316271/
    */        
        set attacksImmune[0]  = false //ATTACK_TYPE_NORMAL
        set attacksImmune[1]  = true  //ATTACK_TYPE_MELEE
        set attacksImmune[2]  = true  //ATTACK_TYPE_PIERCE
        set attacksImmune[3]  = true  //ATTACK_TYPE_SIEGE
        set attacksImmune[4]  = false //ATTACK_TYPE_MAGIC
        set attacksImmune[5]  = true  //ATTACK_TYPE_CHAOS
        set attacksImmune[6]  = true  //ATTACK_TYPE_HERO

        set damagesImmune[0]  = true  //DAMAGE_TYPE_UNKNOWN
        set damagesImmune[4]  = true  //DAMAGE_TYPE_NORMAL
        set damagesImmune[5]  = true  //DAMAGE_TYPE_ENHANCED
        set damagesImmune[8]  = false //DAMAGE_TYPE_FIRE
        set damagesImmune[9]  = false //DAMAGE_TYPE_COLD
        set damagesImmune[10] = false //DAMAGE_TYPE_LIGHTNING
        set damagesImmune[11] = true  //DAMAGE_TYPE_POISON
        set damagesImmune[12] = true  //DAMAGE_TYPE_DISEASE
        set damagesImmune[13] = false //DAMAGE_TYPE_DIVINE
        set damagesImmune[14] = false //DAMAGE_TYPE_MAGIC
        set damagesImmune[15] = false //DAMAGE_TYPE_SONIC
        set damagesImmune[16] = true  //DAMAGE_TYPE_ACID
        set damagesImmune[17] = false //DAMAGE_TYPE_FORCE
        set damagesImmune[18] = false //DAMAGE_TYPE_DEATH
        set damagesImmune[19] = false //DAMAGE_TYPE_MIND
        set damagesImmune[20] = false //DAMAGE_TYPE_PLANT
        set damagesImmune[21] = false //DAMAGE_TYPE_DEFENSIVE
        set damagesImmune[22] = true  //DAMAGE_TYPE_DEMOLITION
        set damagesImmune[23] = true  //DAMAGE_TYPE_SLOW_POISON
        set damagesImmune[24] = false //DAMAGE_TYPE_SPIRIT_LINK
        set damagesImmune[25] = false //DAMAGE_TYPE_SHADOW_STRIKE
        set damagesImmune[26] = true  //DAMAGE_TYPE_UNIVERSAL
    endmethod

    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_DMGPKG()
    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_01()
    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_02()
    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_03()
    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_04()
    //! runtextmacro optional DAMAGE_EVENT_STRUCT_PLUGIN_05()

endstruct

// Called from the GUI configuration trigger once the assignments are in place.
public function DebugStr takes nothing returns nothing
    local integer i = 0
    loop
        set udg_CONVERTED_ATTACK_TYPE[i] = ConvertAttackType(i)
        exitwhen i == 6
        set i = i + 1
    endloop

    set i = 0
    loop
        set udg_CONVERTED_DAMAGE_TYPE[i] = ConvertDamageType(i)
        exitwhen i == 26
        set i = i + 1
    endloop

    set udg_AttackTypeDebugStr[0]  = "SPELLS"   //ATTACK_TYPE_NORMAL in JASS
    set udg_AttackTypeDebugStr[1]  = "NORMAL"   //ATTACK_TYPE_MELEE in JASS
    set udg_AttackTypeDebugStr[2]  = "PIERCE"
    set udg_AttackTypeDebugStr[3]  = "SIEGE"
    set udg_AttackTypeDebugStr[4]  = "MAGIC"
    set udg_AttackTypeDebugStr[5]  = "CHAOS"
    set udg_AttackTypeDebugStr[6]  = "HERO"
    set udg_DamageTypeDebugStr[0]  = "UNKNOWN"
    set udg_DamageTypeDebugStr[4]  = "NORMAL"
    set udg_DamageTypeDebugStr[5]  = "ENHANCED"
    set udg_DamageTypeDebugStr[8]  = "FIRE"
    set udg_DamageTypeDebugStr[9]  = "COLD"
    set udg_DamageTypeDebugStr[10] = "LIGHTNING"
    set udg_DamageTypeDebugStr[11] = "POISON"
    set udg_DamageTypeDebugStr[12] = "DISEASE"
    set udg_DamageTypeDebugStr[13] = "DIVINE"
    set udg_DamageTypeDebugStr[14] = "MAGIC"
    set udg_DamageTypeDebugStr[15] = "SONIC"
    set udg_DamageTypeDebugStr[16] = "ACID"
    set udg_DamageTypeDebugStr[17] = "FORCE"
    set udg_DamageTypeDebugStr[18] = "DEATH"
    set udg_DamageTypeDebugStr[19] = "MIND"
    set udg_DamageTypeDebugStr[20] = "PLANT"
    set udg_DamageTypeDebugStr[21] = "DEFENSIVE"
    set udg_DamageTypeDebugStr[22] = "DEMOLITION"
    set udg_DamageTypeDebugStr[23] = "SLOW_POISON"
    set udg_DamageTypeDebugStr[24] = "SPIRIT_LINK"
    set udg_DamageTypeDebugStr[25] = "SHADOW_STRIKE"
    set udg_DamageTypeDebugStr[26] = "UNIVERSAL"
    set udg_WeaponTypeDebugStr[0]  = "NONE"    //WEAPON_TYPE_WHOKNOWS in JASS
    set udg_WeaponTypeDebugStr[1]  = "METAL_LIGHT_CHOP"
    set udg_WeaponTypeDebugStr[2]  = "METAL_MEDIUM_CHOP"
    set udg_WeaponTypeDebugStr[3]  = "METAL_HEAVY_CHOP"
    set udg_WeaponTypeDebugStr[4]  = "METAL_LIGHT_SLICE"
    set udg_WeaponTypeDebugStr[5]  = "METAL_MEDIUM_SLICE"
    set udg_WeaponTypeDebugStr[6]  = "METAL_HEAVY_SLICE"
    set udg_WeaponTypeDebugStr[7]  = "METAL_MEDIUM_BASH"
    set udg_WeaponTypeDebugStr[8]  = "METAL_HEAVY_BASH"
    set udg_WeaponTypeDebugStr[9]  = "METAL_MEDIUM_STAB"
    set udg_WeaponTypeDebugStr[10] = "METAL_HEAVY_STAB"
    set udg_WeaponTypeDebugStr[11] = "WOOD_LIGHT_SLICE"
    set udg_WeaponTypeDebugStr[12] = "WOOD_MEDIUM_SLICE"
    set udg_WeaponTypeDebugStr[13] = "WOOD_HEAVY_SLICE"
    set udg_WeaponTypeDebugStr[14] = "WOOD_LIGHT_BASH"
    set udg_WeaponTypeDebugStr[15] = "WOOD_MEDIUM_BASH"
    set udg_WeaponTypeDebugStr[16] = "WOOD_HEAVY_BASH"
    set udg_WeaponTypeDebugStr[17] = "WOOD_LIGHT_STAB"
    set udg_WeaponTypeDebugStr[18] = "WOOD_MEDIUM_STAB"
    set udg_WeaponTypeDebugStr[19] = "CLAW_LIGHT_SLICE"
    set udg_WeaponTypeDebugStr[20] = "CLAW_MEDIUM_SLICE"
    set udg_WeaponTypeDebugStr[21] = "CLAW_HEAVY_SLICE"
    set udg_WeaponTypeDebugStr[22] = "AXE_MEDIUM_CHOP"
    set udg_WeaponTypeDebugStr[23] = "ROCK_HEAVY_BASH"
    set udg_DefenseTypeDebugStr[0] = "LIGHT"
    set udg_DefenseTypeDebugStr[1] = "MEDIUM"
    set udg_DefenseTypeDebugStr[2] = "HEAVY"
    set udg_DefenseTypeDebugStr[3] = "FORTIFIED"
    set udg_DefenseTypeDebugStr[4] = "NORMAL"   //Typically deals flat damage to all armor types
    set udg_DefenseTypeDebugStr[5] = "HERO"
    set udg_DefenseTypeDebugStr[6] = "DIVINE"
    set udg_DefenseTypeDebugStr[7] = "UNARMORED"
    set udg_ArmorTypeDebugStr[0]   = "NONE"      //ARMOR_TYPE_WHOKNOWS in JASS, added in 1.31
    set udg_ArmorTypeDebugStr[1]   = "FLESH"
    set udg_ArmorTypeDebugStr[2]   = "METAL"
    set udg_ArmorTypeDebugStr[3]   = "WOOD"
    set udg_ArmorTypeDebugStr[4]   = "ETHEREAL"
    set udg_ArmorTypeDebugStr[5]   = "STONE"
    
    // Added 25 July 2017 to allow detection of things like Bash or Pulverize or AOE spread
    set udg_DamageEventAOE = 1
    set udg_DamageEventLevel = 1
/*
    In-game World Editor doesn't allow Attack Type and Damage Type comparisons.
    Therefore, I need to code them as integers into GUI
*/
    set udg_ATTACK_TYPE_SPELLS = 0
    set udg_ATTACK_TYPE_NORMAL = 1
    set udg_ATTACK_TYPE_PIERCE = 2
    set udg_ATTACK_TYPE_SIEGE = 3
    set udg_ATTACK_TYPE_MAGIC = 4
    set udg_ATTACK_TYPE_CHAOS = 5
    set udg_ATTACK_TYPE_HERO = 6
    // -
    set udg_DAMAGE_TYPE_UNKNOWN = 0
    set udg_DAMAGE_TYPE_NORMAL = 4
    set udg_DAMAGE_TYPE_ENHANCED = 5
    set udg_DAMAGE_TYPE_FIRE = 8
    set udg_DAMAGE_TYPE_COLD = 9
    set udg_DAMAGE_TYPE_LIGHTNING = 10
    set udg_DAMAGE_TYPE_POISON = 11
    set udg_DAMAGE_TYPE_DISEASE = 12
    set udg_DAMAGE_TYPE_DIVINE = 13
    set udg_DAMAGE_TYPE_MAGIC = 14
    set udg_DAMAGE_TYPE_SONIC = 15
    set udg_DAMAGE_TYPE_ACID = 16
    set udg_DAMAGE_TYPE_FORCE = 17
    set udg_DAMAGE_TYPE_DEATH = 18
    set udg_DAMAGE_TYPE_MIND = 19
    set udg_DAMAGE_TYPE_PLANT = 20
    set udg_DAMAGE_TYPE_DEFENSIVE = 21
    set udg_DAMAGE_TYPE_DEMOLITION = 22
    set udg_DAMAGE_TYPE_SLOW_POISON = 23
    set udg_DAMAGE_TYPE_SPIRIT_LINK = 24
    set udg_DAMAGE_TYPE_SHADOW_STRIKE = 25
    set udg_DAMAGE_TYPE_UNIVERSAL = 26
    
/*
    The below variables don't affect damage amount, but do affect the sound played
    They also give important information about the type of attack used.
    They can differentiate between ranged and melee for units who are both
*/    
    
    set udg_WEAPON_TYPE_NONE = 0

    // Metal Light/Medium/Heavy
    set udg_WEAPON_TYPE_ML_CHOP = 1
    set udg_WEAPON_TYPE_MM_CHOP = 2
    set udg_WEAPON_TYPE_MH_CHOP = 3
    set udg_WEAPON_TYPE_ML_SLICE = 4
    set udg_WEAPON_TYPE_MM_SLICE = 5
    set udg_WEAPON_TYPE_MH_SLICE = 6
    set udg_WEAPON_TYPE_MM_BASH = 7
    set udg_WEAPON_TYPE_MH_BASH = 8
    set udg_WEAPON_TYPE_MM_STAB = 9
    set udg_WEAPON_TYPE_MH_STAB = 10

    // Wood Light/Medium/Heavy
    set udg_WEAPON_TYPE_WL_SLICE = 11
    set udg_WEAPON_TYPE_WM_SLICE = 12
    set udg_WEAPON_TYPE_WH_SLICE = 13
    set udg_WEAPON_TYPE_WL_BASH = 14
    set udg_WEAPON_TYPE_WM_BASH = 15
    set udg_WEAPON_TYPE_WH_BASH = 16
    set udg_WEAPON_TYPE_WL_STAB = 17
    set udg_WEAPON_TYPE_WM_STAB = 18

    // Claw Light/Medium/Heavy
    set udg_WEAPON_TYPE_CL_SLICE = 19
    set udg_WEAPON_TYPE_CM_SLICE = 20
    set udg_WEAPON_TYPE_CH_SLICE = 21

    // Axe Medium
    set udg_WEAPON_TYPE_AM_CHOP = 22

    // Rock Heavy
    set udg_WEAPON_TYPE_RH_BASH = 23

/*
    Since GUI still doesn't provide Defense Type and Armor Types,
    I needed to include the below:
*/
    set udg_ARMOR_TYPE_NONE = 0
    set udg_ARMOR_TYPE_FLESH = 1
    set udg_ARMOR_TYPE_METAL = 2
    set udg_ARMOR_TYPE_WOOD = 3
    set udg_ARMOR_TYPE_ETHEREAL = 4
    set udg_ARMOR_TYPE_STONE = 5

    set udg_DEFENSE_TYPE_LIGHT = 0
    set udg_DEFENSE_TYPE_MEDIUM = 1
    set udg_DEFENSE_TYPE_HEAVY = 2
    set udg_DEFENSE_TYPE_FORTIFIED = 3
    set udg_DEFENSE_TYPE_NORMAL = 4
    set udg_DEFENSE_TYPE_HERO = 5
    set udg_DEFENSE_TYPE_DIVINE = 6
    set udg_DEFENSE_TYPE_UNARMORED = 7

/*
    The remaining stuff is an ugly 'optimization' that I did a long
    time ago, thinking that it would improve performance for GUI users
    by not having so many different triggerconditions evaluating per
    damage event. I am not sure if it even worked; in Lua it might
    perform worse, but in vJass it remains to be tested.
*/

    set udg_UNIT_CLASS_HERO = 0
    set udg_UNIT_CLASS_DEAD = 1
    set udg_UNIT_CLASS_STRUCTURE = 2

    set udg_UNIT_CLASS_FLYING = 3
    set udg_UNIT_CLASS_GROUND = 4

    set udg_UNIT_CLASS_ATTACKS_FLYING = 5
    set udg_UNIT_CLASS_ATTACKS_GROUND = 6

    set udg_UNIT_CLASS_MELEE = 7
    set udg_UNIT_CLASS_RANGED = 8

    set udg_UNIT_CLASS_GIANT = 9
    set udg_UNIT_CLASS_SUMMONED = 10
    set udg_UNIT_CLASS_STUNNED = 11
    set udg_UNIT_CLASS_PLAGUED = 12
    set udg_UNIT_CLASS_SNARED = 13

    set udg_UNIT_CLASS_UNDEAD = 14
    set udg_UNIT_CLASS_MECHANICAL = 15
    set udg_UNIT_CLASS_PEON = 16
    set udg_UNIT_CLASS_SAPPER = 17
    set udg_UNIT_CLASS_TOWNHALL = 18
    set udg_UNIT_CLASS_ANCIENT = 19

    set udg_UNIT_CLASS_TAUREN = 20
    set udg_UNIT_CLASS_POISONED = 21
    set udg_UNIT_CLASS_POLYMORPHED = 22
    set udg_UNIT_CLASS_SLEEPING = 23
    set udg_UNIT_CLASS_RESISTANT = 24
    set udg_UNIT_CLASS_ETHEREAL = 25
    set udg_UNIT_CLASS_MAGIC_IMMUNE = 26

    set udg_DamageFilterAttackT = -1
    set udg_DamageFilterDamageT = -1
    set udg_DamageFilterSourceC = -1
    set udg_DamageFilterTargetC = -1
    set udg_DamageFilterRunChance = 1.00
endfunction

public function RegisterFromHook takes /*
    */ trigger whichTrig, /*
    */ string var, /*
    */ limitop op, /*
    */ real value /*
*/ returns nothing
    call DamageTrigger.registerVerbose(whichTrig, var, value, true, GetHandleId(op))
endfunction
hook TriggerRegisterVariableEvent RegisterFromHook

function TriggerRegisterDamageEngineEx takes /*
    */ trigger whichTrig, /*
    */ string eventName, /*
    */ real value, /*
    */ integer opId /*
*/ returns DamageTrigger
    return DamageTrigger.registerVerbose( /*
        */ whichTrig, /*
        */ DamageTrigger.getVerboseStr(eventName), /*
        */ value, /*
        */ false, /*
        */ opId /*
    */ )
endfunction

function TriggerRegisterDamageEngine takes /*
    */ trigger whichTrig, /*
    */ string eventName, /*
    */ real value /*
*/ returns DamageTrigger
    return DamageTrigger.registerTrigger(whichTrig, eventName, value)
endfunction

function RegisterDamageEngineEx takes /*
    */ code callback, /*
    */ string eventName, /*
    */ real value, /*
    */ integer opId /*
*/ returns DamageTrigger
    return TriggerRegisterDamageEngineEx(DamageTrigger[callback], eventName, value, opId)
endfunction

//Similar to TriggerRegisterDamageEvent, but takes code instead of trigger as the first argument.
function RegisterDamageEngine takes /*
    */ code callback, /*
    */ string eventName, /*
    */ real value /*
*/ returns DamageTrigger
    return RegisterDamageEngineEx(callback, eventName, value, FILTER_OTHER)
endfunction

/*
    The below macros are for GUI to tap into more powerful vJass event filtering:
*/

//! textmacro DAMAGE_TRIGGER_CONFIG
    if not DamageTrigger.eventIndex.configured then
//! endtextmacro

//! textmacro DAMAGE_TRIGGER_CONFIG_END
        call DamageTrigger.eventIndex.configure()
    endif
    if not DamageTrigger.eventIndex.checkConfig() then
        return
    endif
//! endtextmacro

endlibrary

library Table /* made by Bribe, special thanks to Vexorian & Nestharus, version 4.1.0.1.
   
    One map, one hashtable. Welcome to NewTable 4.1.0.1
   
    This newest iteration of Table introduces the new HashTable struct.
    You can now instantiate HashTables which enables the use of large
    parent and large child keys, just like a standard hashtable. Previously,
    the user would have to instantiate a Table to do this on their own which -
    while doable - is something the user should not have to do if I can add it
    to this resource myself (especially if they are inexperienced).
   
    This library was originally called NewTable so it didn't conflict with
    the API of Table by Vexorian. However, the damage is done and it's too
    late to change the library name now. To help with damage control, I
    have provided an extension library called TableBC, which bridges all
    the functionality of Vexorian's Table except for 2-D string arrays &
    the ".flush(integer)" method. I use ".flush()" to flush a child hash-
    table, because I wanted the API in NewTable to reflect the API of real
    hashtables (I thought this would be more intuitive).
   
    API
   
    ------------
    struct Table
    | static method create takes nothing returns Table
    |     create a new Table
    |    
    | method destroy takes nothing returns nothing
    |     destroy it
    |    
    | method flush takes nothing returns nothing
    |     flush all stored values inside of it
    |    
    | method remove takes integer key returns nothing
    |     remove the value at index "key"
    |    
    | method operator []= takes integer key, $TYPE$ value returns nothing
    |     assign "value" to index "key"
    |    
    | method operator [] takes integer key returns $TYPE$
    |     load the value at index "key"
    |    
    | method has takes integer key returns boolean
    |     whether or not the key was assigned
    |
    ----------------
    struct TableArray
    | static method operator [] takes integer array_size returns TableArray
    |     create a new array of Tables of size "array_size"
    |
    | method destroy takes nothing returns nothing
    |     destroy it
    |
    | method flush takes nothing returns nothing
    |     flush and destroy it
    |
    | method operator size takes nothing returns integer
    |     returns the size of the TableArray
    |
    | method operator [] takes integer key returns Table
    |     returns a Table accessible exclusively to index "key"
*/
   
globals
    private integer less = 0    //Index generation for TableArrays (below 0).
    private integer more = 8190 //Index generation for Tables.
    //Configure it if you use more than 8190 "key" variables in your map (this will never happen though).
   
    private hashtable ht = InitHashtable()
    private key sizeK
    private key listK
endglobals
   
private struct dex extends array
    static method operator size takes nothing returns Table
        return sizeK
    endmethod
    static method operator list takes nothing returns Table
        return listK
    endmethod
endstruct
   
private struct handles extends array
    method has takes integer key returns boolean
        return HaveSavedHandle(ht, this, key)
    endmethod
    method remove takes integer key returns nothing
        call RemoveSavedHandle(ht, this, key)
    endmethod
endstruct
   
private struct agents extends array
    method operator []= takes integer key, agent value returns nothing
        call SaveAgentHandle(ht, this, key, value)
    endmethod
endstruct
   
//! textmacro NEW_ARRAY_BASIC takes SUPER, FUNC, TYPE
private struct $TYPE$s extends array
    method operator [] takes integer key returns $TYPE$
        return Load$FUNC$(ht, this, key)
    endmethod
    method operator []= takes integer key, $TYPE$ value returns nothing
        call Save$FUNC$(ht, this, key, value)
    endmethod
    method has takes integer key returns boolean
        return HaveSaved$SUPER$(ht, this, key)
    endmethod
    method remove takes integer key returns nothing
        call RemoveSaved$SUPER$(ht, this, key)
    endmethod
endstruct
private module $TYPE$m
    method operator $TYPE$ takes nothing returns $TYPE$s
        return this
    endmethod
endmodule
//! endtextmacro
   
//! textmacro NEW_ARRAY takes FUNC, TYPE
private struct $TYPE$s extends array
    method operator [] takes integer key returns $TYPE$
        return Load$FUNC$Handle(ht, this, key)
    endmethod
    method operator []= takes integer key, $TYPE$ value returns nothing
        call Save$FUNC$Handle(ht, this, key, value)
    endmethod
    method has takes integer key returns boolean
        return HaveSavedHandle(ht, this, key)
    endmethod
    method remove takes integer key returns nothing
        call RemoveSavedHandle(ht, this, key)
    endmethod
endstruct
private module $TYPE$m
    method operator $TYPE$ takes nothing returns $TYPE$s
        return this
    endmethod
endmodule
//! endtextmacro
   
//Run these textmacros to include the entire hashtable API as wrappers.
//Don't be intimidated by the number of macros - Vexorian's map optimizer is
//supposed to kill functions which inline (all of these functions inline).
//! runtextmacro NEW_ARRAY_BASIC("Real", "Real", "real")
//! runtextmacro NEW_ARRAY_BASIC("Boolean", "Boolean", "boolean")
//! runtextmacro NEW_ARRAY_BASIC("String", "Str", "string")
//New textmacro to allow table.integer[] syntax for compatibility with textmacros that might desire it.
//! runtextmacro NEW_ARRAY_BASIC("Integer", "Integer", "integer")
   
//! runtextmacro NEW_ARRAY("Player", "player")
//! runtextmacro NEW_ARRAY("Widget", "widget")
//! runtextmacro NEW_ARRAY("Destructable", "destructable")
//! runtextmacro NEW_ARRAY("Item", "item")
//! runtextmacro NEW_ARRAY("Unit", "unit")
//! runtextmacro NEW_ARRAY("Ability", "ability")
//! runtextmacro NEW_ARRAY("Timer", "timer")
//! runtextmacro NEW_ARRAY("Trigger", "trigger")
//! runtextmacro NEW_ARRAY("TriggerCondition", "triggercondition")
//! runtextmacro NEW_ARRAY("TriggerAction", "triggeraction")
//! runtextmacro NEW_ARRAY("TriggerEvent", "event")
//! runtextmacro NEW_ARRAY("Force", "force")
//! runtextmacro NEW_ARRAY("Group", "group")
//! runtextmacro NEW_ARRAY("Location", "location")
//! runtextmacro NEW_ARRAY("Rect", "rect")
//! runtextmacro NEW_ARRAY("BooleanExpr", "boolexpr")
//! runtextmacro NEW_ARRAY("Sound", "sound")
//! runtextmacro NEW_ARRAY("Effect", "effect")
//! runtextmacro NEW_ARRAY("UnitPool", "unitpool")
//! runtextmacro NEW_ARRAY("ItemPool", "itempool")
//! runtextmacro NEW_ARRAY("Quest", "quest")
//! runtextmacro NEW_ARRAY("QuestItem", "questitem")
//! runtextmacro NEW_ARRAY("DefeatCondition", "defeatcondition")
//! runtextmacro NEW_ARRAY("TimerDialog", "timerdialog")
//! runtextmacro NEW_ARRAY("Leaderboard", "leaderboard")
//! runtextmacro NEW_ARRAY("Multiboard", "multiboard")
//! runtextmacro NEW_ARRAY("MultiboardItem", "multiboarditem")
//! runtextmacro NEW_ARRAY("Trackable", "trackable")
//! runtextmacro NEW_ARRAY("Dialog", "dialog")
//! runtextmacro NEW_ARRAY("Button", "button")
//! runtextmacro NEW_ARRAY("TextTag", "texttag")
//! runtextmacro NEW_ARRAY("Lightning", "lightning")
//! runtextmacro NEW_ARRAY("Image", "image")
//! runtextmacro NEW_ARRAY("Ubersplat", "ubersplat")
//! runtextmacro NEW_ARRAY("Region", "region")
//! runtextmacro NEW_ARRAY("FogState", "fogstate")
//! runtextmacro NEW_ARRAY("FogModifier", "fogmodifier")
//! runtextmacro NEW_ARRAY("Hashtable", "hashtable")
   
struct Table extends array
   
    // Implement modules for intuitive syntax (tb.handle; tb.unit; etc.)
    implement realm
    implement integerm
    implement booleanm
    implement stringm
    implement playerm
    implement widgetm
    implement destructablem
    implement itemm
    implement unitm
    implement abilitym
    implement timerm
    implement triggerm
    implement triggerconditionm
    implement triggeractionm
    implement eventm
    implement forcem
    implement groupm
    implement locationm
    implement rectm
    implement boolexprm
    implement soundm
    implement effectm
    implement unitpoolm
    implement itempoolm
    implement questm
    implement questitemm
    implement defeatconditionm
    implement timerdialogm
    implement leaderboardm
    implement multiboardm
    implement multiboarditemm
    implement trackablem
    implement dialogm
    implement buttonm
    implement texttagm
    implement lightningm
    implement imagem
    implement ubersplatm
    implement regionm
    implement fogstatem
    implement fogmodifierm
    implement hashtablem
   
    method operator handle takes nothing returns handles
        return this
    endmethod
   
    method operator agent takes nothing returns agents
        return this
    endmethod
   
    //set this = tb[GetSpellAbilityId()]
    method operator [] takes integer key returns Table
        return LoadInteger(ht, this, key) //return this.integer[key]
    endmethod
   
    //set tb[389034] = 8192
    method operator []= takes integer key, Table tb returns nothing
        call SaveInteger(ht, this, key, tb) //set this.integer[key] = tb
    endmethod
   
    //set b = tb.has(2493223)
    method has takes integer key returns boolean
        return HaveSavedInteger(ht, this, key) //return this.integer.has(key)
    endmethod
   
    //call tb.remove(294080)
    method remove takes integer key returns nothing
        call RemoveSavedInteger(ht, this, key) //call this.integer.remove(key)
    endmethod
   
    //Remove all data from a Table instance
    method flush takes nothing returns nothing
        call FlushChildHashtable(ht, this)
    endmethod
   
    //local Table tb = Table.create()
    static method create takes nothing returns Table
        local Table this = dex.list[0]
       
        if this == 0 then
            set this = more + 1
            set more = this
        else
            set dex.list[0] = dex.list[this]
            call dex.list.remove(this) //Clear hashed memory
        endif
       
        debug set dex.list[this] = -1
        return this
    endmethod
   
    // Removes all data from a Table instance and recycles its index.
    //
    //     call tb.destroy()
    //
    method destroy takes nothing returns nothing
        debug if dex.list[this] != -1 then
            debug call BJDebugMsg("Table Error: Tried to double-free instance: " + I2S(this))
            debug return
        debug endif
       
        call this.flush()
       
        set dex.list[this] = dex.list[0]
        set dex.list[0] = this
    endmethod
   
    //! runtextmacro optional TABLE_BC_METHODS()
endstruct
   
//! runtextmacro optional TABLE_BC_STRUCTS()
   
struct TableArray extends array
   
    //Returns a new TableArray to do your bidding. Simply use:
    //
    //    local TableArray ta = TableArray[array_size]
    //
    static method operator [] takes integer array_size returns TableArray
        local Table tb = dex.size[array_size] //Get the unique recycle list for this array size
        local TableArray this = tb[0]         //The last-destroyed TableArray that had this array size
       
        debug if array_size <= 0 then
            debug call BJDebugMsg("TypeError: Invalid specified TableArray size: " + I2S(array_size))
            debug return 0
        debug endif
       
        if this == 0 then
            set this = less - array_size
            set less = this
        else
            set tb[0] = tb[this]  //Set the last destroyed to the last-last destroyed
            call tb.remove(this)  //Clear hashed memory
        endif
       
        set dex.size[this] = array_size //This remembers the array size
        return this
    endmethod
   
    //Returns the size of the TableArray
    method operator size takes nothing returns integer
        return dex.size[this]
    endmethod
   
    //This magic method enables two-dimensional[array][syntax] for Tables,
    //similar to the two-dimensional utility provided by hashtables them-
    //selves.
    //
    //ta[integer a].unit[integer b] = unit u
    //ta[integer a][integer c] = integer d
    //
    //Inline-friendly when not running in debug mode
    //
    method operator [] takes integer key returns Table
        static if DEBUG_MODE then
            local integer i = this.size
            if i == 0 then
                call BJDebugMsg("IndexError: Tried to get key from invalid TableArray instance: " + I2S(this))
                return 0
            elseif key < 0 or key >= i then
                call BJDebugMsg("IndexError: Tried to get key [" + I2S(key) + "] from outside TableArray bounds: " + I2S(i))
                return 0
            endif
        endif
        return this + key
    endmethod
   
    //Destroys a TableArray without flushing it; I assume you call .flush()
    //if you want it flushed too. This is a public method so that you don't
    //have to loop through all TableArray indices to flush them if you don't
    //need to (ie. if you were flushing all child-keys as you used them).
    //
    method destroy takes nothing returns nothing
        local Table tb = dex.size[this.size]
       
        debug if this.size == 0 then
            debug call BJDebugMsg("TypeError: Tried to destroy an invalid TableArray: " + I2S(this))
            debug return
        debug endif
       
        if tb == 0 then
            //Create a Table to index recycled instances with their array size
            set tb = Table.create()
            set dex.size[this.size] = tb
        endif
       
        call dex.size.remove(this) //Clear the array size from hash memory
       
        set tb[this] = tb[0]
        set tb[0] = this
    endmethod
   
    private static Table tempTable
    private static integer tempEnd
   
    //Avoids hitting the op limit
    private static method clean takes nothing returns nothing
        local Table tb = .tempTable
        local integer end = tb + 0x1000
        if end < .tempEnd then
            set .tempTable = end
            call ForForce(bj_FORCE_PLAYER[0], function thistype.clean)
        else
            set end = .tempEnd
        endif
        loop
            call tb.flush()
            set tb = tb + 1
            exitwhen tb == end
        endloop
    endmethod
   
    //Flushes the TableArray and also destroys it. Doesn't get any more
    //similar to the FlushParentHashtable native than this.
    //
    method flush takes nothing returns nothing
        debug if this.size == 0 then
            debug call BJDebugMsg("TypeError: Tried to flush an invalid TableArray instance: " + I2S(this))
            debug return
        debug endif
        set .tempTable = this
        set .tempEnd = this + this.size
        call ForForce(bj_FORCE_PLAYER[0], function thistype.clean)
        call this.destroy()
    endmethod
   
endstruct
   
//NEW: Added in Table 4.0. A fairly simple struct but allows you to do more
//than that which was previously possible.
struct HashTable extends array

    //Enables myHash[parentKey][childKey] syntax.
    //Basically, it creates a Table in the place of the parent key if
    //it didn't already get created earlier.
    method operator [] takes integer index returns Table
        local Table t = Table(this)[index]
        if t == 0 then
            set t = Table.create()
            set Table(this)[index] = t //whoops! Forgot that line. I'm out of practice!
        endif
        return t
    endmethod

    //You need to call this on each parent key that you used if you
    //intend to destroy the HashTable or simply no longer need that key.
    method remove takes integer index returns nothing
        local Table t = Table(this)[index]
        if t != 0 then
            call t.destroy()
            call Table(this).remove(index)
        endif
    endmethod
   
    //Added in version 4.1
    method has takes integer index returns boolean
        return Table(this).has(index)
    endmethod
   
    //HashTables are just fancy Table indices.
    method destroy takes nothing returns nothing
        call Table(this).destroy()
    endmethod
   
    //Like I said above...
    static method create takes nothing returns thistype
        return Table.create()
    endmethod

endstruct

endlibrary
 
library TableBC requires Table
/*
    Backwards-compatibility add-on for scripts employing Vexorian's Table.

    Added 31 July 2015: introduced static method operator [] and
    static method flush2D for Table, HandleTable and StringTable. Now,
    almost all of the Vexorian API has been replicated (minus the .flush paradox).

    The Table library itself was unchanged to implement these
    enhancements, so you need only update this library to experience the
    improved syntax compatibility.
   
    Disclaimer:
   
    The following error does not occur with HandleTables & StringTables, only
    with the standard, integer-based Table, so you do not need to make any
    changes to StringTable/HandleTable-employing scripts.
   
    The this.flush(key) method from the original Table cannot be parsed with
    the new Table. For the scripts that use this method, they need to be up-
    dated to use the more fitting this.remove(key) method.
   
    Please don't try using StringTables/HandleTables with features exclusive
    to the new Table as they will cause syntax errors. I do not have any plan
    to endorse these types of Tables because delegation in JassHelper is not
    advanced enough for three types of Tables without copying every single
    method over again (as you can see this already generates plenty of code).
    StringTable & HandleTable are wrappers for StringHash & GetHandleId, so
    just type them out.
*/

//! textmacro TABLE_BC_METHODS
    method reset takes nothing returns nothing
        call this.flush()
    endmethod
    method exists takes integer key returns boolean
        return this.has(key)
    endmethod
    static method operator [] takes string id returns Table
        local integer index = StringHash(id)
        local Table t = Table(thistype.typeid)[index]
        if t == 0 then
            set t = Table.create()
            set Table(thistype.typeid)[index] = t
        endif
        return t
    endmethod
    static method flush2D takes string id returns nothing
        local integer index = StringHash(id)
        local Table t = Table(thistype.typeid)[index]
        if t != 0 then
            call t.destroy()
            call Table(thistype.typeid).remove(index)
        endif
    endmethod
//! endtextmacro

//! textmacro TABLE_BC_STRUCTS
struct HandleTable extends array
    static method operator [] takes string index returns thistype
        return Table[index]
    endmethod
    static method flush2D takes string index returns nothing
        call Table.flush2D(index)
    endmethod
    method operator [] takes handle key returns integer
        return Table(this)[GetHandleId(key)]
    endmethod
    method operator []= takes handle key, integer value returns nothing
        set Table(this)[GetHandleId(key)] = value
    endmethod
    method flush takes handle key returns nothing
        call Table(this).remove(GetHandleId(key))
    endmethod
    method exists takes handle key returns boolean
        return Table(this).has(GetHandleId(key))
    endmethod
    method reset takes nothing returns nothing
        call Table(this).flush()
    endmethod
    method destroy takes nothing returns nothing
        call Table(this).destroy()
    endmethod
    static method create takes nothing returns thistype
        return Table.create()
    endmethod
endstruct

struct StringTable extends array
    static method operator [] takes string index returns thistype
        return Table[index]
    endmethod
    static method flush2D takes string index returns nothing
        call Table.flush2D(index)
    endmethod
    method operator [] takes string key returns integer
        return Table(this)[StringHash(key)]
    endmethod
    method operator []= takes string key, integer value returns nothing
        set Table(this)[StringHash(key)] = value
    endmethod
    method flush takes string key returns nothing
        call Table(this).remove(StringHash(key))
    endmethod
    method exists takes string key returns boolean
        return Table(this).has(StringHash(key))
    endmethod
    method reset takes nothing returns nothing
        call Table(this).flush()
    endmethod
    method destroy takes nothing returns nothing
        call Table(this).destroy()
    endmethod
    static method create takes nothing returns thistype
        return Table.create()
    endmethod
endstruct
//! endtextmacro

endlibrary

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~ Alloc ~~ By Sevion ~~ Version 1.09 ~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//  What is Alloc?
//         - Alloc implements an intuitive allocation method for array structs
//
//    =Pros=
//         - Efficient.
//         - Simple.
//         - Less overhead than regular structs.
//
//    =Cons=
//         - Must use array structs (hardly a con).
//         - Must manually call OnDestroy.
//         - Must use Delegates for inheritance.
//         - No default values for variables (use onInit instead).
//         - No array members (use another Alloc struct as a linked list or type declaration).
//
//    Methods:
//         - struct.allocate()
//         - struct.deallocate()
//
//           These methods are used just as they should be used in regular structs.
//
//    Modules:
//         - Alloc
//           Implements the most basic form of Alloc. Includes only create and destroy
//           methods.
//
//  Details:
//         - Less overhead than regular structs
//
//         - Use array structs when using Alloc. Put the implement at the top of the struct.
//
//         - Alloc operates almost exactly the same as default structs in debug mode with the exception of onDestroy.
//
//  How to import:
//         - Create a trigger named Alloc.
//         - Convert it to custom text and replace the whole trigger text with this.
//
//  Thanks:
//         - Nestharus for the method of allocation and suggestions on further merging.
//         - Bribe for suggestions like the static if and method names.
//         - PurgeandFire111 for some suggestions like the merging of Alloc and AllocX as well as OnDestroy stuff.
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
library Alloc    
    module Alloc
        private static integer instanceCount = 0
        private thistype recycle
   
        static method allocate takes nothing returns thistype
            local thistype this
   
            if (thistype(0).recycle == 0) then
                debug if (instanceCount == JASS_MAX_ARRAY_SIZE) then
                    debug call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Alloc ERROR: Attempted to allocate too many instances!")
                    debug return 0
                debug endif
                set instanceCount = instanceCount + 1
                set this = instanceCount
            else
                set this = thistype(0).recycle
                set thistype(0).recycle = thistype(0).recycle.recycle
            endif

            debug set this.recycle = -1
   
            return this
        endmethod
   
        method deallocate takes nothing returns nothing
            debug if (this.recycle != -1) then
                debug call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Alloc ERROR: Attempted to deallocate an invalid instance at [" + I2S(this) + "]!")
                debug return
            debug endif

            set this.recycle = thistype(0).recycle
            set thistype(0).recycle = this
        endmethod
    endmodule
endlibrary

library WorldBounds /* v2.0.0.0
************************************************************************************
*
*	struct WorldBounds extends array
*
*	Fields
*	-------------------------
*
*	readonly static integer maxX
*	readonly static integer maxY
*	readonly static integer minX
*	readonly static integer minY
*
*	readonly static integer centerX
*	readonly static integer centerY
*
*	readonly static rect world
*	readonly static region worldRegion
*
************************************************************************************/
private module WorldBoundInit

    private static method onInit takes nothing returns nothing
        set world = GetWorldBounds()
        set maxX = R2I(GetRectMaxX(world))
        set maxY = R2I(GetRectMaxY(world))
        set minX = R2I(GetRectMinX(world))
        set minY = R2I(GetRectMinY(world))
        set centerX = R2I((maxX + minX)/2)
        set centerY = R2I((minY + maxY)/2)
        set playMaxX = GetRectMaxX(bj_mapInitialPlayableArea)
        set playMaxY = GetRectMaxY(bj_mapInitialPlayableArea)
        set playMinX = GetRectMinX(bj_mapInitialPlayableArea)
        set playMinY = GetRectMinY(bj_mapInitialPlayableArea)
        set worldRegion = CreateRegion()
        call RegionAddRect(worldRegion, world)
        endmethod
    endmodule
    
    struct WorldBounds extends array
        readonly static integer maxX
        readonly static integer maxY
        readonly static integer minX
        readonly static integer minY
        readonly static integer centerX
        readonly static integer centerY
        readonly static rect world
        readonly static region worldRegion
        readonly static real playMaxX
        readonly static real playMaxY
        readonly static real playMinX
        readonly static real playMinY
        implement WorldBoundInit
    endstruct
    
endlibrary

//TESH.scrollpos=21
//TESH.alwaysfold=0
library TimerUtils initializer init
//*********************************************************************
//* TimerUtils (red+blue+orange flavors for 1.24b+) 2.0
//* ----------
//*
//*  To implement it , create a custom text trigger called TimerUtils
//* and paste the contents of this script there.
//*
//*  To copy from a map to another, copy the trigger holding this
//* library to your map.
//*
//* (requires vJass)   More scripts: htt://www.wc3c.net
//*
//* For your timer needs:
//*  * Attaching
//*  * Recycling (with double-free protection)
//*
//* set t=NewTimer()      : Get a timer (alternative to CreateTimer)
//* set t=NewTimerEx(x)   : Get a timer (alternative to CreateTimer), call
//*                            Initialize timer data as x, instead of 0.
//*
//* ReleaseTimer(t)       : Relese a timer (alt to DestroyTimer)
//* SetTimerData(t,2)     : Attach value 2 to timer
//* GetTimerData(t)       : Get the timer's value.
//*                         You can assume a timer's value is 0
//*                         after NewTimer.
//*
//* Multi-flavor:
//*    Set USE_HASH_TABLE to true if you don't want to complicate your life.
//*
//* If you like speed and giberish try learning about the other flavors.
//*
//********************************************************************

//================================================================
    globals
        //How to tweak timer utils:
        // USE_HASH_TABLE = true  (new blue)
        //  * SAFEST
        //  * SLOWEST (though hash tables are kind of fast)
        //
        // USE_HASH_TABLE = false, USE_FLEXIBLE_OFFSET = true  (orange)
        //  * kinda safe (except there is a limit in the number of timers)
        //  * ALMOST FAST
        //
        // USE_HASH_TABLE = false, USE_FLEXIBLE_OFFSET = false (red)
        //  * THE FASTEST (though is only  faster than the previous method
        //                  after using the optimizer on the map)
        //  * THE LEAST SAFE ( you may have to tweak OFSSET manually for it to
        //                     work)
        //
        private constant boolean USE_HASH_TABLE      = true
        private constant boolean USE_FLEXIBLE_OFFSET = false

        private constant integer OFFSET     = 0x100000
        private          integer VOFFSET    = OFFSET
              
        //Timers to preload at map init:
        private constant integer QUANTITY   = 256
        
        //Changing this  to something big will allow you to keep recycling
        // timers even when there are already AN INCREDIBLE AMOUNT of timers in
        // the stack. But it will make things far slower so that's probably a bad idea...
        private constant integer ARRAY_SIZE = 8190

    endglobals

    //==================================================================================================
    globals
        private integer array data[ARRAY_SIZE]
        private hashtable     ht
    endglobals
    
    

    //It is dependent on jasshelper's recent inlining optimization in order to perform correctly.
    function SetTimerData takes timer t, integer value returns nothing
        static if(USE_HASH_TABLE) then
            // new blue
            call SaveInteger(ht,0,GetHandleId(t), value)
            
        elseif (USE_FLEXIBLE_OFFSET) then
            // orange
            static if (DEBUG_MODE) then
                if(GetHandleId(t)-VOFFSET<0) then
                    call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
                endif
            endif
            set data[GetHandleId(t)-VOFFSET]=value
        else
            // new red
            static if (DEBUG_MODE) then
                if(GetHandleId(t)-OFFSET<0) then
                    call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
                endif
            endif
            set data[GetHandleId(t)-OFFSET]=value
        endif        
    endfunction

    function GetTimerData takes timer t returns integer
        static if(USE_HASH_TABLE) then
            // new blue
            return LoadInteger(ht,0,GetHandleId(t) )
            
        elseif (USE_FLEXIBLE_OFFSET) then
            // orange
            static if (DEBUG_MODE) then
                if(GetHandleId(t)-VOFFSET<0) then
                    call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
                endif
            endif
            return data[GetHandleId(t)-VOFFSET]
        else
            // new red
            static if (DEBUG_MODE) then
                if(GetHandleId(t)-OFFSET<0) then
                    call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
                endif
            endif
            return data[GetHandleId(t)-OFFSET]
        endif        
    endfunction

    //==========================================================================================
    globals
        private timer array tT[ARRAY_SIZE]
        private integer tN = 0
        private constant integer HELD=0x28829022
        //use a totally random number here, the more improbable someone uses it, the better.
        
        private boolean       didinit = false
    endglobals
    private keyword init

    //==========================================================================================
    // I needed to decide between duplicating code ignoring the "Once and only once" rule
    // and using the ugly textmacros. I guess textmacros won.
    //
    //! textmacro TIMERUTIS_PRIVATE_NewTimerCommon takes VALUE
    // On second thought, no.
    //! endtextmacro

    function NewTimerEx takes integer value returns timer
        if (tN==0) then
            if (not didinit) then 
                //This extra if shouldn't represent a major performance drawback
                //because QUANTITY rule is not supposed to be broken every day. 
                call init.evaluate()
                set tN = tN - 1
            else
                //If this happens then the QUANTITY rule has already been broken, try to fix the
                // issue, else fail.
                debug call BJDebugMsg("NewTimer: Warning, Exceeding TimerUtils_QUANTITY, make sure all timers are getting recycled correctly")
                set tT[0]=CreateTimer()
                static if( not USE_HASH_TABLE) then
                    debug call BJDebugMsg("In case of errors, please increase it accordingly, or set TimerUtils_USE_HASH_TABLE to true")
                    static if( USE_FLEXIBLE_OFFSET) then
                        if (GetHandleId(tT[0])-VOFFSET<0) or (GetHandleId(tT[0])-VOFFSET>=ARRAY_SIZE) then
                            //all right, couldn't fix it
                            call BJDebugMsg("NewTimer: Unable to allocate a timer, you should probably set TimerUtils_USE_HASH_TABLE to true or fix timer leaks.")
                            return null
                        endif
                    else
                        if (GetHandleId(tT[0])-OFFSET<0) or (GetHandleId(tT[0])-OFFSET>=ARRAY_SIZE) then
                            //all right, couldn't fix it
                            call BJDebugMsg("NewTimer: Unable to allocate a timer, you should probably set TimerUtils_USE_HASH_TABLE to true or fix timer leaks.")
                            return null
                        endif
                    endif
                endif
            endif
        else
            set tN=tN-1
        endif
        call SetTimerData(tT[tN],value)
     return tT[tN]
    endfunction
    
    function NewTimer takes nothing returns timer
        return NewTimerEx(0)
    endfunction


    //==========================================================================================
    function ReleaseTimer takes timer t returns nothing
        if(t==null) then
            debug call BJDebugMsg("Warning: attempt to release a null timer")
            return
        endif
        if (tN==ARRAY_SIZE) then
            debug call BJDebugMsg("Warning: Timer stack is full, destroying timer!!")

            //stack is full, the map already has much more troubles than the chance of bug
            call DestroyTimer(t)
        else
            call PauseTimer(t)
            if(GetTimerData(t)==HELD) then
                debug call BJDebugMsg("Warning: ReleaseTimer: Double free!")
                return
            endif
            call SetTimerData(t,HELD)
            set tT[tN]=t
            set tN=tN+1
        endif    
    endfunction

    private function init takes nothing returns nothing
     local integer i=0
     local integer o=-1
     local boolean oops = false
        if ( didinit ) then
            return
        else
            set didinit = true
        endif
     
        static if( USE_HASH_TABLE ) then
            set ht = InitHashtable()
            loop
                exitwhen(i==QUANTITY)
                set tT[i]=CreateTimer()
                call SetTimerData(tT[i], HELD)
                set i=i+1
            endloop
            set tN = QUANTITY
        else
            loop
                set i=0
                loop
                    exitwhen (i==QUANTITY)
                    set tT[i] = CreateTimer()
                    if(i==0) then
                        set VOFFSET = GetHandleId(tT[i])
                        static if(USE_FLEXIBLE_OFFSET) then
                            set o=VOFFSET
                        else
                            set o=OFFSET
                        endif
                    endif
                    if (GetHandleId(tT[i])-o>=ARRAY_SIZE) then
                        exitwhen true
                    endif
                    if (GetHandleId(tT[i])-o>=0)  then
                        set i=i+1
                    endif
                endloop
                set tN = i
                exitwhen(tN == QUANTITY)
                set oops = true
                exitwhen not USE_FLEXIBLE_OFFSET
                debug call BJDebugMsg("TimerUtils_init: Failed a initialization attempt, will try again")               
            endloop
            
            if(oops) then
                static if ( USE_FLEXIBLE_OFFSET) then
                    debug call BJDebugMsg("The problem has been fixed.")
                    //If this message doesn't appear then there is so much
                    //handle id fragmentation that it was impossible to preload
                    //so many timers and the thread crashed! Therefore this
                    //debug message is useful.
                elseif(DEBUG_MODE) then
                    call BJDebugMsg("There were problems and the new timer limit is "+I2S(i))
                    call BJDebugMsg("This is a rare ocurrence, if the timer limit is too low:")
                    call BJDebugMsg("a) Change USE_FLEXIBLE_OFFSET to true (reduces performance a little)")
                    call BJDebugMsg("b) or try changing OFFSET to "+I2S(VOFFSET) )
                endif
            endif
        endif

    endfunction

endlibrary

library MissileEffect requires WorldBounds, Alloc
    /* ------------------------------------- Missile Effect v2.8 ------------------------------------ */
    // This is a simple helper library for the Relativistic Missiles system.
    // Credits:
    //     Sevion for the Alloc module
    //         - www.hiveworkshop.com/threads/snippet-alloc.192348/
    //     Nestharus for World Bounds Library
    /* ---------------------------------------- By Chopinski ---------------------------------------- */
    
    /* ---------------------------------------------------------------------------------------------- */
    /*                                             System                                             */
    /* ---------------------------------------------------------------------------------------------- */
    private module LinkedList
        readonly thistype next
        readonly thistype prev

        method init takes nothing returns thistype
            set next = this
            set prev = this

            return this
        endmethod

        method pushBack takes thistype node returns thistype
            set node.prev = prev
            set node.next = this
            set prev.next = node
            set prev = node

            return node
        endmethod

        method pushFront takes thistype node returns thistype
            set node.prev = this
            set node.next = next
            set next.prev = node
            set next = node

            return node
        endmethod

        method pop takes nothing returns nothing
            set prev.next = next
            set next.prev = prev
        endmethod
    endmodule

    private struct Effect extends array
        implement LinkedList
        implement Alloc

        real    x
        real    y
        real    z
        real    size
        real    yaw
        real    pitch
        real    roll
        string  path
        effect  effect

        method remove takes nothing returns nothing
            call DestroyEffect(effect)
            call pop()
            call deallocate()
            set effect = null
        endmethod

        method insert takes string fxpath, real x, real y, real z, real scale returns thistype
            local thistype node = pushBack(allocate())

            set node.x      = x
            set node.y      = y
            set node.z      = z
            set node.yaw    = 0.
            set node.pitch  = 0.
            set node.roll   = 0.
            set node.path   = fxpath
            set node.size   = scale
            set node.effect = AddSpecialEffect(fxpath, x, y)
            call BlzSetSpecialEffectZ(node.effect, z)
            call BlzSetSpecialEffectScale(node.effect, scale)

            return node
        endmethod

        static method create takes nothing returns thistype
            return thistype(allocate()).init()
        endmethod
    endstruct

    struct MissileEffect
        real    size
        real    yaw
        real    pitch
        real    roll
        real    time
        integer transparency
        integer animtype
        integer playercolor
        string  path
        effect  effect
        Effect  attachments

        /* -------------------------------- Operators ------------------------------- */
        method operator timeScale= takes real newTimeScale returns nothing
            set time = newTimeScale
            call BlzSetSpecialEffectTimeScale(effect, time)
        endmethod
        
        method operator timeScale takes nothing returns real
            return time
        endmethod

        method operator alpha= takes integer newAlpha returns nothing
            set transparency = newAlpha
            call BlzSetSpecialEffectAlpha(effect, transparency)
        endmethod

        method operator alpha takes nothing returns integer
            return transparency
        endmethod

        method operator playerColor= takes integer playerId returns nothing
            set playercolor = playerId
            call BlzSetSpecialEffectColorByPlayer(effect, Player(playerId))
        endmethod

        method operator playerColor takes nothing returns integer
            return playercolor
        endmethod

        method operator animation= takes integer animType returns nothing
            set animtype = animType
            call BlzPlaySpecialEffect(effect, ConvertAnimType(animtype))
        endmethod

        method operator animation takes nothing returns integer
            return animtype
        endmethod

        /* --------------------------------- Methods -------------------------------- */
        method scale takes effect sfx, real scale returns nothing
            set size = scale
            call BlzSetSpecialEffectScale(sfx, scale)
        endmethod   

        method orient takes real yaw, real pitch, real roll returns nothing
            local Effect node = attachments.next

            set .yaw   = yaw
            set .pitch = pitch
            set .roll  = roll
            call BlzSetSpecialEffectOrientation(effect, yaw, pitch, roll)

            loop
                exitwhen node == attachments
                    set node.yaw   = yaw
                    set node.pitch = pitch
                    set node.roll  = roll
                    call BlzSetSpecialEffectOrientation(node.effect, yaw, pitch, roll)
                set node = node.next
            endloop
        endmethod

        method move takes real x, real y, real z returns boolean
            local Effect node = attachments.next

            if not (x > WorldBounds.maxX or x < WorldBounds.minX or y > WorldBounds.maxY or y < WorldBounds.minY) then
                call BlzSetSpecialEffectPosition(effect, x, y, z)
                loop
                    exitwhen node == attachments
                        call BlzSetSpecialEffectPosition(node.effect, x - node.x, y - node.y, z - node.z)
                    set node = node.next
                endloop
                return true
            endif
            return false
        endmethod

        method attach takes string fxpath, real dx, real dy, real dz, real scale returns effect
            local Effect node = attachments.insert(fxpath, dx, dy, dz, scale)

            call BlzSetSpecialEffectPosition(node.effect, BlzGetLocalSpecialEffectX(effect) - dx, BlzGetLocalSpecialEffectY(effect) - dy, BlzGetLocalSpecialEffectZ(effect) - dz)

            return node.effect
        endmethod

        method detach takes effect sfx returns nothing
            local Effect node = attachments.next

            loop
                exitwhen node == attachments
                    if GetHandleId(node.effect) == GetHandleId(sfx) then
                        call node.remove()
                        exitwhen true
                    endif
                set node = node.next
            endloop
        endmethod

        method setColor takes integer red, integer green, integer blue returns nothing
            call BlzSetSpecialEffectColor(effect, red, green, blue)
        endmethod

        /* -------------------------- Contructor/Destructor ------------------------- */
        method destroy takes nothing returns nothing
            local Effect node = attachments.next

            loop
                exitwhen node == attachments
                    call node.remove()
                set node = node.next
            endloop
            call DestroyEffect(effect)
            call attachments.deallocate()
            
            set effect = null
            set path   = null
            set size   = 1.
            call deallocate()
        endmethod

        static method create takes real x, real y, real z returns thistype
            local thistype this = thistype.allocate()

            set effect = AddSpecialEffect("", x, y)
            set path = ""
            set size = 1
            set time = 0
            set transparency = 0
            set animtype = 0
            set playercolor = 0
            set attachments = Effect.create()
            call BlzSetSpecialEffectZ(effect, z)

            return this
        endmethod
    endstruct
endlibrary

library MissileUtils requires Missiles, Alloc
    /* ------------------------------------- Missile Utils v2.8 ------------------------------------- */
    // This is a simple Utils library for the Relativistic Missiles system.
    // Credits:
    //     Sevion for the Alloc module
    //         - www.hiveworkshop.com/threads/snippet-alloc.192348/
    /* ---------------------------------------- By Chopinski ---------------------------------------- */
    
    /* ---------------------------------------------------------------------------------------------- */
    /*                                            JASS API                                            */
    /* ---------------------------------------------------------------------------------------------- */
    function CreateMissileGroup takes nothing returns MissileGroup
        return MissileGroup.create()
    endfunction
    
    function DestroyMissileGroup takes MissileGroup missiles returns nothing
        if missiles != 0 then
            call missiles.clear()
            call missiles.destroy()
        endif
    endfunction
    
    function MissileGroupGetSize takes MissileGroup missiles returns integer
        if missiles != 0 then
            return missiles.size
        else
            return 0
        endif
    endfunction
    
    function GroupMissileAt takes MissileGroup missiles, integer position returns Missiles
        if missiles != 0 then
            return missiles.missileAt(position)
        else
            return 0
        endif
    endfunction
    
    function ClearMissileGroup takes MissileGroup missiles returns nothing
        if missiles != 0 then
            call missiles.clear()
        endif
    endfunction
    
    function IsMissileInGroup takes Missiles missile, MissileGroup missiles returns boolean
        if missiles != 0 and missile != 0 then
            if missiles.size > 0 then
                return missiles.contains(missile)
            else
                return false
            endif
        else
            return false
        endif
    endfunction
    
    function GroupRemoveMissile takes MissileGroup missiles, Missiles missile returns nothing
        if missiles != 0 and missile != 0 then
            if missiles.size > 0 then
                call missiles.remove(missile)
            endif
        endif
    endfunction
    
    function GroupAddMissile takes MissileGroup missiles, Missiles missile returns nothing
        if missiles != 0 and missile != 0 then
            if not missiles.contains(missile) then
                call missiles.insert(missile)
            endif
        endif
    endfunction
    
    function GroupPickRandomMissile takes MissileGroup missiles returns Missiles
        if missiles != 0 then
            if missiles.size > 0 then
                return missiles.missileAt(GetRandomInt(0, missiles.size - 1))
            else
                return 0
            endif
        else
            return 0
        endif
    endfunction
    
    function FirstOfMissileGroup takes MissileGroup missiles returns Missiles
        if missiles != 0 then
            if missiles.size > 0 then
                return missiles.group.next.missile
            else
                return 0
            endif
        else
            return 0
        endif
    endfunction
    
    function GroupAddMissileGroup takes MissileGroup source, MissileGroup destiny returns nothing
        if source != 0 and destiny != 0 then
            if source.size > 0 and source != destiny then
                call destiny.addGroup(source)
            endif
        endif
    endfunction
    
    function GroupRemoveMissileGroup takes MissileGroup source, MissileGroup destiny returns nothing
        if source != 0 and destiny != 0 then
            if source == destiny then
                call source.clear()
            elseif source.size > 0 then
                call destiny.removeGroup(source)
            endif
        endif
    endfunction
    
    function GroupEnumMissilesOfType takes MissileGroup missiles, integer whichType returns nothing
        local integer i
        local Missiles missile
        
        if missiles != 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count
                        set missile = Missiles.collection[i]
                        
                        if missile.type == whichType then
                            call missiles.insert(missile)
                        endif
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesOfTypeCounted takes MissileGroup missiles, integer whichType, integer amount returns nothing
        local integer i
        local integer j = amount
        local Missiles missile
        
        if missiles != 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count or j == 0
                        set missile = Missiles.collection[i]
                        
                        if missile.type == whichType then
                            call missiles.insert(missile)
                        endif
                        set j = j - 1
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesOfPlayer takes MissileGroup missiles, player p returns nothing
        local integer i
        local Missiles missile
        
        if missiles != 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count
                        set missile = Missiles.collection[i]
                        
                        if missile.owner == p then
                            call missiles.insert(missile)
                        endif
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesOfPlayerCounted takes MissileGroup missiles, player p, integer amount returns nothing
        local integer i
        local integer j = amount
        local Missiles missile
        
        if missiles != 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count or j == 0
                        set missile = Missiles.collection[i]
                        
                        if missile.owner == p then
                            call missiles.insert(missile)
                        endif
                        set j = j - 1
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRect takes MissileGroup missiles, rect r returns nothing
        local integer i
        local Missiles missile
        
        if missiles != 0 and r != null then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count
                        set missile = Missiles.collection[i]
                        
                        if GetRectMinX(r) <= missile.x and missile.x <= GetRectMaxX(r) and GetRectMinY(r) <= missile.y and missile.y <= GetRectMaxY(r) then
                            call missiles.insert(missile)
                        endif
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRectCounted takes MissileGroup missiles, rect r, integer amount returns nothing
        local integer i
        local integer j = amount
        local Missiles missile
        
        if missiles != 0 and r != null then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count or j == 0
                        set missile = Missiles.collection[i]
                        
                        if GetRectMinX(r) <= missile.x and missile.x <= GetRectMaxX(r) and GetRectMinY(r) <= missile.y and missile.y <= GetRectMaxY(r) then
                            call missiles.insert(missile)
                        endif
                        set j = j - 1
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRangeOfLoc takes MissileGroup missiles, location loc, real radius returns nothing
        local real dx
        local real dy
        local integer i
        local Missiles missile
    
        if missiles != 0 and radius > 0 and loc != null then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count
                        set missile = Missiles.collection[i]
                        set dx = missile.x - GetLocationX(loc)
                        set dy = missile.y - GetLocationY(loc)
                        
                        if SquareRoot(dx*dx + dy*dy) <= radius then
                            call missiles.insert(missile)
                        endif
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRangeOfLocCounted takes MissileGroup missiles, location loc, real radius, integer amount returns nothing
        local real dx
        local real dy
        local integer i
        local integer j = amount
        local Missiles missile
    
        if missiles != 0 and radius > 0 and loc != null then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count or j == 0
                        set missile = Missiles.collection[i]
                        set dx = missile.x - GetLocationX(loc)
                        set dy = missile.y - GetLocationY(loc)
                        
                        if SquareRoot(dx*dx + dy*dy) <= radius then
                            call missiles.insert(missile)
                        endif
                        set j = j - 1
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRange takes MissileGroup missiles, real x, real y, real radius returns nothing
        local real dx
        local real dy
        local integer i
        local Missiles missile
    
        if missiles != 0 and radius > 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count
                        set missile = Missiles.collection[i]
                        set dx = missile.x - x
                        set dy = missile.y - y
                        
                        if SquareRoot(dx*dx + dy*dy) <= radius then
                            call missiles.insert(missile)
                        endif
                    set i = i + 1
                endloop
            endif
        endif
    endfunction
    
    function GroupEnumMissilesInRangeCounted takes MissileGroup missiles, real x, real y, real radius, integer amount returns nothing
        local real dx
        local real dy
        local integer i
        local integer j = amount
        local Missiles missile
    
        if missiles != 0 and radius > 0 then
            if Missiles.count > -1 then
                set i = 0
                
                if missiles.size > 0 then
                    call missiles.clear()
                endif
                
                loop
                    exitwhen i > Missiles.count or j == 0
                        set missile = Missiles.collection[i]
                        set dx = missile.x - x
                        set dy = missile.y - y
                        
                        if SquareRoot(dx*dx + dy*dy) <= radius then
                            call missiles.insert(missile)
                        endif
                        set j = j - 1
                    set i = i + 1
                endloop
            endif
        endif
    endfunction

    /* ---------------------------------------------------------------------------------------------- */
    /*                                             System                                             */
    /* ---------------------------------------------------------------------------------------------- */
    private module LinkedList
        readonly thistype next
        readonly thistype prev

        method init takes nothing returns thistype
            set next = this
            set prev = this

            return this
        endmethod

        method pushBack takes thistype node returns thistype
            set node.prev = prev
            set node.next = this
            set prev.next = node
            set prev = node

            return node
        endmethod

        method pushFront takes thistype node returns thistype
            set node.prev = this
            set node.next = next
            set next.prev = node
            set next = node

            return node
        endmethod

        method pop takes nothing returns nothing
            set prev.next = next
            set next.prev = prev
        endmethod
    endmodule

    private struct MGroup extends array
        implement LinkedList
        implement Alloc
        
        Missiles missile
        
        method remove takes nothing returns nothing
            call pop()
            call deallocate()
        endmethod

        method insert takes Missiles m returns thistype
            local thistype node = pushBack(allocate())

            set node.missile = m

            return node
        endmethod
        
        static method create takes nothing returns thistype
            return thistype(allocate()).init()
        endmethod
    endstruct

    struct MissileGroup
        MGroup group
        integer size
        
        method destroy takes nothing returns nothing
            call group.deallocate()
            call deallocate()
        endmethod
        
        method missileAt takes integer i returns Missiles
            local MGroup node = group.next
            local integer j = 0
        
            if size > 0 and i <= size - 1 then
                loop
                    exitwhen j == i
                        set node = node.next
                    set j = j + 1
                endloop
                
                return node.missile
            else
                return 0
            endif
        endmethod
        
        method remove takes Missiles missile returns nothing
            local MGroup node = group.next
        
            loop
                exitwhen node == group
                    if node.missile == missile then
                        set size = size - 1
                        call node.remove()
                        exitwhen true
                    endif
                set node = node.next
            endloop
        endmethod
        
        method insert takes Missiles missile returns nothing
            set size = size + 1
            call group.insert(missile)
        endmethod
        
        method clear takes nothing returns nothing
            local MGroup node = group.next
            
            loop
                exitwhen node == group
                    call node.remove()
                set node = node.next
            endloop
            
            set size = 0
        endmethod
        
        method contains takes Missiles missile returns boolean
            local MGroup node = group.next
            local boolean found = false
        
            loop
                exitwhen node == group
                    if node.missile == missile then
                        set found = true
                        exitwhen true
                    endif
                set node = node.next
            endloop
            
            return found
        endmethod
        
        method addGroup takes MissileGroup source returns nothing
            local MGroup node = source.group.next
        
            loop
                exitwhen node == source.group
                    if not contains(node.missile) then
                        call insert(node.missile)
                    endif
                set node = node.next
            endloop
        endmethod
        
        method removeGroup takes MissileGroup source returns nothing
            local MGroup node = source.group.next
        
            loop
                exitwhen node == source.group
                    if contains(node.missile) then
                        call remove(node.missile)
                    endif
                set node = node.next
            endloop
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = thistype.allocate()
            
            set group = MGroup.create()
            set size = 0
            
            return this
        endmethod
    endstruct
endlibrary

library Missiles requires MissileEffect, TimerUtils, WorldBounds
    /* ---------------------------------------- Missiles v2.8 --------------------------------------- */
    // Thanks and Credits to BPower, Dirac and Vexorian for the Missile Library's at which i based
    // this Missiles library. Credits and thanks to AGD and for the effect orientation ideas.
    // This version of Missiles requires patch 1.31+
    
    // How to Import:
    //     1 - Copy this, MissileEffect and optionaly the MissileUtils libraries to your map
    /* ---------------------------------------- By Chopinski ---------------------------------------- */
    
    /* ---------------------------------------------------------------------------------------------- */
    /*                                             System                                             */
    /* ---------------------------------------------------------------------------------------------- */
    globals
        // The update period of the system
        public  constant real    PERIOD             = 1./40.
        // The max amount of Missiles processed in a PERIOD
        // You can play around with both these values to find
        // your sweet spot. If equal to 0, the system will
        // process all missiles at once every period.
        public  constant real    SWEET_SPOT         = 150
        // the avarage collision size compensation when detecting collisions
        private constant real    COLLISION_SIZE     = 128.
        // item size used in z collision
        private constant real    ITEM_SIZE          = 16.
        // Raw code of the dummy unit used for vision
        private constant integer DUMMY              = 'dumr'
        // Needed, don't touch.
        private location         LOC                = Location(0., 0.)
    endglobals

    private interface MissileEvents
        method onHit takes unit hit returns boolean defaults false
        method onMissile takes Missiles missile returns boolean defaults false
        method onDestructable takes destructable dest returns boolean defaults false
        method onItem takes item i returns boolean defaults false
        method onCliff takes nothing returns boolean defaults false
        method onTerrain takes nothing returns boolean defaults false
        method onTileset takes integer tileset returns boolean defaults false
        method onPeriod takes nothing returns boolean defaults false
        method onFinish takes nothing returns boolean defaults false
        method onBoundaries takes nothing returns boolean defaults false
        method onPause takes nothing returns boolean defaults false
        method onResume takes nothing returns boolean defaults false
        method onRemove takes nothing returns nothing defaults nothing
    endinterface
    
    private function GetLocZ takes real x, real y returns real
        call MoveLocation(LOC, x, y)
        return GetLocationZ(LOC)
    endfunction
    
    private function GetUnitZ takes unit u returns real
        return GetLocZ(GetUnitX(u), GetUnitY(u)) + GetUnitFlyHeight(u)
    endfunction
    
    private function SetUnitZ takes unit u, real z returns nothing
        call SetUnitFlyHeight(u, z - GetLocZ(GetUnitX(u), GetUnitY(u)), 0)
    endfunction
    
    private function GetMapCliffLevel takes nothing returns integer
        return GetTerrainCliffLevel(WorldBounds.maxX, WorldBounds.maxY)
    endfunction

    private struct Pool
        private static player player = Player(PLAYER_NEUTRAL_PASSIVE)
        private static group  group  = CreateGroup()

        timer timer
        unit  unit

        static method recycle takes unit dummy returns nothing
            if GetUnitTypeId(dummy) == DUMMY then
                call GroupAddUnit(group, dummy)
                call SetUnitX(dummy, WorldBounds.maxX)
                call SetUnitY(dummy, WorldBounds.maxY)
                call SetUnitOwner(dummy, player, false)
                call PauseUnit(dummy, true)
            endif
        endmethod

        static method retrieve takes real x, real y, real z, real face returns unit
            if BlzGroupGetSize(group) > 0 then
                set bj_lastCreatedUnit = FirstOfGroup(group)
                call PauseUnit(bj_lastCreatedUnit, false)
                call GroupRemoveUnit(group, bj_lastCreatedUnit)
                call SetUnitX(bj_lastCreatedUnit, x)
                call SetUnitY(bj_lastCreatedUnit, y)
                call SetUnitZ(bj_lastCreatedUnit, z)
                call BlzSetUnitFacingEx(bj_lastCreatedUnit, face)
            else
                set bj_lastCreatedUnit = CreateUnit(player, DUMMY, x, y, face)
                call SetUnitZ(bj_lastCreatedUnit, z)
                call UnitRemoveAbility(bj_lastCreatedUnit, 'Amrf')
            endif

            return bj_lastCreatedUnit
        endmethod

        private static method onExpire takes nothing returns nothing
            local thistype this = GetTimerData(GetExpiredTimer())

            call recycle(unit)
            call ReleaseTimer(timer)
            
            set timer = null
            set unit  = null

            call deallocate()
        endmethod

        static method recycleTimed takes unit dummy, real delay returns nothing
            local thistype this

            if GetUnitTypeId(dummy) != DUMMY then
                debug call BJDebugMsg("[DummyPool] Error: Trying to recycle a non dummy unit")
            else
                set this = thistype.allocate()

                set timer = NewTimerEx(this)
                set unit  = dummy
                
                call TimerStart(timer, delay, false, function thistype.onExpire)
            endif
        endmethod

        private static method onInit takes nothing returns nothing
            local integer i = 0
            local unit u

            loop
                exitwhen i == SWEET_SPOT
                    set u = CreateUnit(player, DUMMY, WorldBounds.maxX, WorldBounds.maxY, 0)
                    call PauseUnit(u, false)
                    call GroupAddUnit(group, u)
                    call UnitRemoveAbility(u, 'Amrf')
                set i = i + 1
            endloop

            set u = null
        endmethod
    endstruct

    private struct Coordinates
        readonly real x
        readonly real y
        readonly real z
        readonly real angle
        readonly real distance
        readonly real square
        readonly real slope
        readonly real alpha

        // Creates an origin - impact link.
        private thistype ref

        private static method math takes thistype a, thistype b returns nothing
            local real dx
            local real dy
            loop
                set dx = b.x - a.x
                set dy = b.y - a.y
                set dx = dx*dx + dy*dy
                set dy = SquareRoot(dx)
                exitwhen dx != 0. and dy != 0.
                set b.x = b.x + .01
                set b.z = b.z - GetLocZ(b.x -.01, b.y) + GetLocZ(b.x, b.y)
            endloop

            set a.square   = dx
            set a.distance = dy
            set a.angle    = Atan2(b.y - a.y, b.x - a.x)
            set a.slope    = (b.z - a.z)/dy
            set a.alpha    = Atan(a.slope)
            // Set b.
            if b.ref == a then
                set b.angle     = a.angle + bj_PI
                set b.distance  = dy
                set b.slope     = -a.slope
                set b.alpha     = -a.alpha
                set b.square    = dx
            endif
        endmethod

        static method link takes thistype a, thistype b returns nothing
            set a.ref = b
            set b.ref = a
            call math(a, b)
        endmethod

        method move takes real toX, real toY, real toZ returns nothing
            set x = toX
            set y = toY
            set z = toZ + GetLocZ(toX, toY)
            if ref != this then
                call math(this, ref)
            endif
        endmethod

        method destroy takes nothing returns nothing
            call .deallocate()
        endmethod

        static method create takes real x, real y, real z returns Coordinates
            local thistype this = thistype.allocate()
            set ref = this
            call move(x, y, z)
            return this
        endmethod
    endstruct
        
    /* -------------------------------------------------------------------------- */
    /*                                   System                                   */
    /* -------------------------------------------------------------------------- */
    private module OnHit
        set o = origin
        set h = height
        set c = open
        set d = o.distance
    
        if .onHit.exists then
            if allocated and collision > 0 then
                call GroupEnumUnitsInRange(group, x, y, collision + COLLISION_SIZE, null)
                loop
                    set u = FirstOfGroup(group)
                    exitwhen u == null
                        if not HaveSavedBoolean(table, this, GetHandleId(u)) then
                            if IsUnitInRangeXY(u, x, y, collision) then
                                if collideZ then
                                    set dx = GetLocZ(GetUnitX(u), GetUnitY(u)) + GetUnitFlyHeight(u)
                                    set dy = BlzGetUnitCollisionSize(u)
                                    if dx + dy >= z - collision and dx <= z + collision then
                                        call SaveBoolean(table, this, GetHandleId(u), true)
                                        if allocated and .onHit(u) then
                                            call terminate()
                                            exitwhen true
                                        endif
                                    endif
                                else
                                    call SaveBoolean(table, this, GetHandleId(u), true)
                                    if allocated and .onHit(u) then
                                        call terminate()
                                        exitwhen true
                                    endif
                                endif
                            endif
                        endif
                    call GroupRemoveUnit(group, u)
                endloop
            endif
        endif
    endmodule
    
    private module OnMissile
        if .onMissile.exists then
            if allocated and collision > 0 then
                set k = 0
                loop
                    exitwhen k > count
                        set missile = collection[k]
                        if missile != this then
                            if not HaveSavedBoolean(table, this, missile) then
                                set dx = missile.x - x
                                set dy = missile.y - y
                                if SquareRoot(dx*dx + dy*dy) <= collision then
                                    call SaveBoolean(table, this, missile, true)
                                    if allocated and .onMissile(missile) then
                                        call terminate()
                                        exitwhen true
                                    endif
                                endif
                            endif
                        endif
                    set k = k + 1
                endloop
            endif
        endif
    endmodule

    private module OnDestructable
        if .onDestructable.exists then
            if allocated and collision > 0 then
                set dx = collision
                call SetRect(rect, x - dx, y - dx, x + dx, y + dx)
                call EnumDestructablesInRect(rect, null, function thistype.onDest)
            endif
        endif
    endmodule

    private module OnItem
        if .onItem.exists then
            if allocated and collision > 0 then
                set dx = collision
                call SetRect(rect, x - dx, y - dx, x + dx, y + dx)
                call EnumItemsInRect(rect, null, function thistype.onItems)
            endif
        endif
    endmodule
       
    private module OnCliff
        if .onCliff.exists then
            set dx = GetTerrainCliffLevel(nextX, nextY)
            set dy = GetTerrainCliffLevel(x, y) 
            if dy < dx and z  < (dx - GetMapCliffLevel())*bj_CLIFFHEIGHT then
                if allocated and .onCliff() then
                    call terminate()
                endif
            endif
        endif
    endmodule
       
    private module OnTerrain
        if .onTerrain.exists then
            if GetLocZ(x, y) > z then
                if allocated and .onTerrain() then
                    call terminate()
                endif
            endif
        endif
    endmodule
    
    private module OnTileset
        if .onTileset.exists then
            set k = GetTerrainType(x, y)
            if k != tileset then
                if allocated and .onTileset(k) then
                    call terminate()
                endif
            endif
            set tileset = k
        endif
    endmodule
    
    private module OnPeriod
        if .onPeriod.exists then
            if allocated and .onPeriod() then
                call terminate()
            endif
        endif
    endmodule
    
    private module OnOrient
        // Homing or not
        set u = target
        if u != null and GetUnitTypeId(u) != 0 then
            call impact.move(GetUnitX(u), GetUnitY(u), GetUnitFlyHeight(u) + toZ)
            set dx = impact.x - nextX
            set dy = impact.y - nextY
            set a = Atan2(dy, dx)
            set travel = o.distance - SquareRoot(dx*dx + dy*dy)
        else
            set a = o.angle
            set target = null
        endif
        
        // turn rate
        if turn != 0 and not (Cos(cA-a) >= Cos(turn)) then
            if Sin(a-cA) >= 0 then
                set cA = cA + turn
            else
                set cA = cA - turn
            endif
        else
            set cA = a
        endif

        set vel = veloc*dilation
        set yaw = cA
        set s = travel + vel
        set veloc = veloc + acceleration
        set travel = s
        set pitch = o.alpha
        set prevX = x
        set prevY = y
        set prevZ = z
        set x = nextX
        set y = nextY
        set z = nextZ
        set nextX = x + vel*Cos(yaw)
        set nextY = y + vel*Sin(yaw)

        // arc calculation
        if h != 0 or o.slope != 0 then
            set nextZ = 4*h*s*(d-s)/(d*d) + o.slope*s + o.z
            set pitch = pitch - Atan(((4*h)*(2*s - d))/(d*d))
        endif
        
        // curve calculation
        if c != 0 then
            set dx = 4*c*s*(d-s)/(d*d)
            set a = yaw + bj_PI/2
            set x = x + dx*Cos(a)
            set y = y + dx*Sin(a)
            set yaw = yaw + Atan(-((4*c)*(2*s - d))/(d*d))
        endif
    endmodule
    
    private module OnFinish
        if s >= d - 0.0001 then
            set finished = true
            if .onFinish.exists then
                if allocated and .onFinish() then
                    call terminate()
                else
                    if travel > 0 and not paused then
                        call terminate()
                    endif
                endif
            else
                call terminate()
            endif
        else
            if not roll then
                call effect.orient(yaw, -pitch, 0)
            else
                call effect.orient(yaw, -pitch, Atan2(c, h))
            endif
        endif
    endmodule
    
    private module OnBoundaries
        if not effect.move(x, y, z) then
            if .onBoundaries.exists then
                if allocated and .onBoundaries() then
                    call terminate()
                endif
            endif
        else
            if dummy != null then
                call SetUnitX(dummy, x)
                call SetUnitY(dummy, y)
            endif
        endif
    endmodule
    
    private module OnPause
        set pid = pid + 1
        set pkey = pid
        set frozen[pid] = this
        
        if .onPause.exists then
            if allocated and .onPause() then
                call terminate()
            endif
        endif
    endmodule
    
    private module OnResume
        local thistype aux
        
        set paused = flag
        if not paused and pkey != -1 then
            set id = id + 1
            set missiles[id] = this
            set aux = frozen[pid]
            set aux.pkey = pkey
            set frozen[pkey] = frozen[pid]
            set pid = pid - 1
            set pkey = -1

            if id + 1 > SWEET_SPOT and SWEET_SPOT > 0 then
                set dilation = (id + 1)/SWEET_SPOT
            else
                set dilation = 1.
            endif

            if id == 0 then
                call TimerStart(timer, PERIOD, true, function thistype.move)
            endif
            
            if .onResume.exists then
                if allocated and .onResume() then
                    call terminate()
                else
                    if finished then
                        call terminate()
                    endif
                endif
            else
                if finished then
                    call terminate()
                endif
            endif
        endif
    endmodule
    
    private module OnRemove
        local thistype aux
    
        if allocated and launched then
            set allocated = false
            
            if pkey != -1 then
                set aux = frozen[pid]
                set aux.pkey = pkey
                set frozen[pkey] = frozen[pid]
                set pid = pid - 1
                set pkey = -1
            endif
            
            if .onRemove.exists then
                call .onRemove()
            endif
            
            if dummy != null then
                call Pool.recycle(dummy)
            endif
            
            set aux = collection[count]
            set aux.index = index
            set collection[index] = collection[count]
            set count = count - 1
            set index = -1
            
            call origin.destroy()
            call impact.destroy()
            call effect.destroy()
            call reset()
            call FlushChildHashtable(table, this)
        endif
    endmodule
    
    private module Operators
        /* -------------------------- Model of the missile -------------------------- */
        method operator model= takes string fx returns nothing
            call DestroyEffect(effect.effect)
            set effect.path = fx
            set effect.effect = AddSpecialEffect(fx, origin.x, origin.y)
            call BlzSetSpecialEffectZ(effect.effect, origin.z)
            call BlzSetSpecialEffectYaw(effect.effect, cA)
        endmethod

        method operator model takes nothing returns string
            return effect.path
        endmethod
        
        /* ----------------------------- Curved movement ---------------------------- */
        method operator curve= takes real value returns nothing
            set open = Tan(value*bj_DEGTORAD)*origin.distance
        endmethod
        
        method operator curve takes nothing returns real
            return Atan(open/origin.distance)*bj_RADTODEG
        endmethod
        
        /* ----------------------------- Arced Movement ----------------------------- */
        method operator arc= takes real value returns nothing
            set height = Tan(value*bj_DEGTORAD)*origin.distance/4
        endmethod
        
        method operator arc takes nothing returns real
            return Atan(4*height/origin.distance)*bj_RADTODEG
        endmethod
        
        /* ------------------------------ Effect scale ------------------------------ */
        method operator scale= takes real value returns nothing
            set effect.size = value
            call effect.scale(effect.effect, value)
        endmethod

        method operator scale takes nothing returns real
            return effect.size
        endmethod

        /* ------------------------------ Missile Speed ----------------------------- */
        method operator speed= takes real newspeed returns nothing
            local real d = origin.distance
            local real s
            local real vel
        
            set veloc = newspeed*PERIOD
            set vel = veloc*dilation
            set s = travel + vel
            set nextX = x + vel*Cos(cA)
            set nextY = y + vel*Sin(cA)

            if height != 0 or origin.slope != 0 then
                set nextZ = 4*height*s*(d-s)/(d*d) + origin.slope*s + origin.z
                set z = nextZ
            endif
        endmethod

        method operator speed takes nothing returns real
            return veloc/PERIOD
        endmethod

        /* ------------------------------- Flight Time ------------------------------ */
        method operator duration= takes real flightTime returns nothing
            local real d = origin.distance
            local real s
            local real vel
        
            set veloc = RMaxBJ(0.00000001, (origin.distance - travel)*PERIOD/RMaxBJ(0.00000001, flightTime))
            set time = flightTime
            set vel = veloc*dilation
            set s = travel + vel
            set nextX = x + vel*Cos(cA)
            set nextY = y + vel*Sin(cA)

            if height != 0 or origin.slope != 0 then
                set nextZ = 4*height*s*(d-s)/(d*d) + origin.slope*s + origin.z
                set z = nextZ
            endif
        endmethod
        
        method operator duration takes nothing returns real
            return time
        endmethod
        
        /* ------------------------------- Sight Range ------------------------------ */
        method operator vision= takes real sightRange returns nothing
            set sight = sightRange
            
            if dummy == null then
                if owner == null then
                    if source != null then
                        set dummy = Pool.retrieve(x, y, z, 0)
                        call SetUnitOwner(dummy, GetOwningPlayer(source), false)
                        call BlzSetUnitRealField(dummy, UNIT_RF_SIGHT_RADIUS, sightRange)
                    endif
                else
                    set dummy = Pool.retrieve(x, y, z, 0)
                    call SetUnitOwner(dummy, owner, false)
                    call BlzSetUnitRealField(dummy, UNIT_RF_SIGHT_RADIUS, sightRange)
                endif
            else
                call SetUnitOwner(dummy, owner, false)
                call BlzSetUnitRealField(dummy, UNIT_RF_SIGHT_RADIUS, sightRange)
            endif
        endmethod
        
        method operator vision takes nothing returns real
            return sight
        endmethod

        /* ------------------------------- Time Scale ------------------------------- */
        method operator timeScale= takes real newTimeScale returns nothing
            set effect.timeScale = newTimeScale
        endmethod
        
        method operator timeScale takes nothing returns real
            return effect.timeScale
        endmethod

        /* ---------------------------------- Alpha --------------------------------- */
        method operator alpha= takes integer newAlpha returns nothing
            set effect.alpha = newAlpha
        endmethod

        method operator alpha takes nothing returns integer
            return effect.alpha
        endmethod

        /* ------------------------------ Player Color ------------------------------ */
        method operator playerColor= takes integer playerId returns nothing
            set effect.playerColor = playerId
        endmethod

        method operator playerColor takes nothing returns integer
            return effect.playerColor
        endmethod

        /* -------------------------------- Animation ------------------------------- */
        method operator animation= takes integer animType returns nothing
            set effect.animation = animType
        endmethod

        method operator animation takes nothing returns integer
            return effect.animation
        endmethod
    endmodule
    
    private module Methods
        /* --------------------------- Bounce and Deflect --------------------------- */
        method bounce takes nothing returns nothing
            call origin.move(x, y, z - GetLocZ(x, y))
            
            set travel = 0
            set finished = false
        endmethod

        method deflect takes real tx, real ty, real tz returns nothing
            local real locZ = GetLocZ(x, y)
            
            set target = null
            set toZ = tz
            
            if z < locZ and .onTerrain.exists then
                set nextX = prevX
                set nextY = prevY
                set nextZ = prevZ
            endif
            
            call impact.move(tx, ty, tz)
            call origin.move(x, y, z - locZ)
            
            set travel = 0
            set finished = false
        endmethod
        
        method deflectTarget takes unit u returns nothing
            call deflect(GetUnitX(u), GetUnitY(u), toZ)
            set target = u
        endmethod

        /* ---------------------------- Flush hit targets --------------------------- */
        method flushAll takes nothing returns nothing
            call FlushChildHashtable(table, this)
        endmethod

        method flush takes widget w returns nothing
            if w != null then
                call RemoveSavedBoolean(table, this, GetHandleId(w))
            endif
        endmethod

        method hitted takes widget w returns boolean
            return HaveSavedBoolean(table, this, GetHandleId(w))
        endmethod

        /* ----------------------- Missile attachment methods ----------------------- */
        method attach takes string model, real dx, real dy, real dz, real scale returns effect
            return effect.attach(model, dx, dy, dz, scale)
        endmethod

        method detach takes effect attachment returns nothing
            if attachment != null then
                call effect.detach(attachment)
            endif
        endmethod

        /* ------------------------------ Missile Pause ----------------------------- */
        method pause takes boolean flag returns nothing
            implement OnResume
        endmethod

        /* ---------------------------------- Color --------------------------------- */
        method color takes integer red, integer green, integer blue returns nothing
            call effect.setColor(red, green, blue)
        endmethod
        
        /* ---------------------- Destructable collision method --------------------- */
        static method onDest takes nothing returns nothing
            local thistype this  = temp
            local destructable d = GetEnumDestructable()
            local real dz
            local real tz

            if not HaveSavedBoolean(table, this, GetHandleId(d)) then
                if collideZ then
                    set dz = GetLocZ(GetWidgetX(d), GetWidgetY(d))
                    set tz = GetDestructableOccluderHeight(d)
                    if dz + tz >= z - collision and dz <= z + collision then
                        call SaveBoolean(table, this, GetHandleId(d), true)
                        if allocated and .onDestructable(d) then
                            set d = null
                            call terminate()
                            return
                        endif
                    endif
                else
                    call SaveBoolean(table, this, GetHandleId(d), true)
                    if allocated and .onDestructable(d) then
                        set d = null
                        call terminate()
                        return
                    endif
                endif
            endif

            set d = null
        endmethod

        /* -------------------------- Item collision method ------------------------- */
        static method onItems takes nothing returns nothing
            local thistype this  = temp
            local item i = GetEnumItem()
            local real dz

            if not HaveSavedBoolean(table, this, GetHandleId(i)) then
                if collideZ then
                    set dz = GetLocZ(GetItemX(i), GetItemY(i))
                    if dz + ITEM_SIZE >= z - collision and dz <= z + collision then
                        call SaveBoolean(table, this, GetHandleId(i), true)
                        if allocated and .onItem(i) then
                            set i = null
                            call terminate()
                            return
                        endif
                    endif
                else
                    call SaveBoolean(table, this, GetHandleId(i), true)
                    if allocated and .onItem(i) then
                        set i = null
                        call terminate()
                        return
                    endif
                endif
            endif

            set i = null
        endmethod

        /* -------------------------------- Terminate ------------------------------- */
        method terminate takes nothing returns nothing
            implement OnRemove
        endmethod
    endmodule

    struct Missiles extends MissileEvents
        private static timer timer = CreateTimer()
        private static group group = CreateGroup()
        private static rect rect = Rect(0., 0., 0., 0.)
        private static hashtable table = InitHashtable()
        private static integer last = 0 
        private static thistype temp = 0
        private static integer id = -1
        private static integer pid = -1
        private static thistype array missiles
        private static thistype array frozen
        private static real dilation = 1
        
        readonly static thistype array collection
        readonly static integer count = -1
        
        private real     cA
        private real     height
        private real     open
        private real     toZ
        private real     time
        private real     sight
        private unit     dummy
        private integer  pkey
        private integer  index
        
        Coordinates      impact
        Coordinates      origin
        MissileEffect    effect
        
        readonly real    x
        readonly real    y
        readonly real    z
        readonly real    prevX
        readonly real    prevY
        readonly real    prevZ
        readonly real    nextX
        readonly real    nextY
        readonly real    nextZ
        readonly real    turn
        readonly real    veloc
        readonly real    travel
        readonly boolean launched
        readonly boolean allocated
        readonly boolean finished
        readonly boolean paused
        readonly integer tileset
        
        unit             source
        unit             target
        player           owner
        boolean          collideZ
        real             collision
        real             damage
        real             acceleration
        integer          data
        integer          type
        boolean          roll
        
        implement Operators
        implement Methods

        /* ------------------------------ Reset members ----------------------------- */
        private method reset takes nothing returns nothing
            set launched     = false
            set finished     = false
            set collideZ     = false
            set paused       = false
            set roll         = false
            set source       = null
            set target       = null
            set owner        = null
            set dummy        = null
            set open         = 0.
            set height       = 0.
            set veloc        = 0.
            set acceleration = 0.
            set collision    = 0.
            set damage       = 0.
            set travel       = 0.
            set turn         = 0.
            set time         = 0.
            set sight        = 0.
            set data         = 0
            set type         = 0
            set tileset      = 0
            set pkey         = -1
            set index        = -1
        endmethod

        /* -------------------------- Destroys the missile -------------------------- */
        private method remove takes integer i returns integer
            if paused then
                implement OnPause
            else
                implement OnRemove
            endif
            
            set missiles[i] = missiles[id]
            set id = id - 1

            if id + 1 > SWEET_SPOT and SWEET_SPOT > 0 then
                set dilation = (id + 1)/SWEET_SPOT
            else
                set dilation = 1
            endif

            if id == -1 then
                call PauseTimer(timer)
            endif
            
            if not allocated then
                call deallocate()
            endif

            return i - 1
        endmethod
        
        /* ---------------------------- Missiles movement --------------------------- */
        private static method move takes nothing returns nothing
            local integer     j = 0
            local integer     i
            local integer     k
            local unit        u
            local real        a
            local real        d
            local real        s
            local real        h
            local real        c
            local real        dx
            local real        dy
            local real        vel
            local real        yaw
            local real        pitch
            local Missiles    missile
            local Coordinates o
            local thistype    this

            if SWEET_SPOT > 0 then
                set i = last
            else
                set i = 0
            endif
            
            loop
                exitwhen ((j >= SWEET_SPOT and SWEET_SPOT > 0) or j > id)
                    set this = missiles[i]
                    set temp = this
                    if allocated and not paused then
                        implement OnHit
                        implement OnMissile
                        implement OnDestructable
                        implement OnItem
                        implement OnCliff
                        implement OnTerrain
                        implement OnTileset
                        implement OnPeriod
                        implement OnOrient
                        implement OnFinish
                        implement OnBoundaries
                    else
                        set i = remove(i)
                        set j = j - 1
                    endif
                set i = i + 1
                set j = j + 1

                if i > id and SWEET_SPOT > 0 then
                    set i = 0
                endif
            endloop
            set last = i

            set u = null
        endmethod
        
        /* --------------------------- Launch the Missile --------------------------- */
        method launch takes nothing returns nothing
            if not launched and allocated then
                set launched = true
                set id = id + 1
                set missiles[id] = this
                set count = count + 1
                set index = count
                set collection[count] = this
                
                if id + 1 > SWEET_SPOT and SWEET_SPOT > 0 then
                    set dilation = (id + 1)/SWEET_SPOT
                else
                    set dilation = 1.
                endif

                if id == 0 then
                    call TimerStart(timer, PERIOD, true, function thistype.move)
                endif
            endif
        endmethod

        /* --------------------------- Main Creator method -------------------------- */
        static method create takes real x, real y, real z, real toX, real toY, real toZ returns thistype
            local thistype this  = thistype.allocate()

            call .reset()
            set .origin = Coordinates.create(x, y, z)
            set .impact = Coordinates.create(toX, toY, toZ)
            set .effect = MissileEffect.create(x, y, origin.z)
            call Coordinates.link(origin, impact)
            set .allocated = true
            set .cA = origin.angle
            set .x = x
            set .y = y
            set .z = impact.z
            set .prevX = x
            set .prevY = y
            set .prevZ = impact.z
            set .nextX = x
            set .nextY = y
            set .nextZ = impact.z
            set .toZ = toZ
            
            return this
        endmethod
    endstruct
endlibrary

scope RelativisticAttack initializer onInit

	//********* To find configuration functions do a search for "**CONFIGURATION**" *******

    globals
		private constant integer ZERO_DAMAGE_HASH_KEY = 513 //Set this to a unique value that is not used elsewhere by attack indexer in your map
		private constant integer ORB_DISALE_ABILITY = 'A000' //Set this to an ability based on "Item Attack Heal Reduction Bonus" with the healing multiplier set to 1.0
		private constant integer ATTACK_DISALE_ABILITY = 'Abun' //Set this to an ability based on "Cargo Hold Orc Burrow"
		private constant real ATTACK_AGI_SPEED_BONUS = 0.02 //Set this to the "Attack speed bonus per agility point" gameplay constant
		private constant real MELEE_DISTANCE = 150. //This is the min distance between the attacker and target that can still cause a relativistic attack
		private constant real AFFECETD_DISTANCE = 2000. //This is the max distance that an attack target can be from a unit with a redirecting ability that will still cause a relativistic attack
		private constant real ORB_TIME = 30. //Set this to slightly higher than the longest time that an orb effect (e.g. poison) lasts on a unit in your map
		private constant integer REDIRECT_ABILITY = 'A001' //Ability ID of your redirecting spell
		private constant integer REDIRECT_EVENT_INT = -513 //Set this to a unique value not used elsewhere in your map. It is used to identify missiles that can be redirected.
		private player arg_player
		private integer arg_int
		private string array projectileArt1
		private string array projectileArt2
    endglobals


struct DummyAttackHandler

        private timer timer
	private boolean cleanup
	private unit dummy
	private unit source
	private unit target
	private Table table

	//**CONFIGURATION**
	//This function should return true for every ability that will be transfered into the dummy unit before it attacks and then removed after and false otherwise

	private static method isTransferableAbility takes integer abilcode returns boolean
		return abilcode != 'Aloc' and abilcode != 'Aeth' and abilcode != 'Aatk' and abilcode != 'Amov' and abilcode != 'AHer' and abilcode != 'AInv' and abilcode != ATTACK_DISALE_ABILITY
	endmethod

    private static method onTimerExpire takes nothing returns nothing
            local thistype this = GetTimerData(GetExpiredTimer())
	    local integer i = 0

	    if cleanup then
            call ReleaseTimer(timer)
            call deallocate()
		
			call DummyAddRecycleTimer(dummy,0.5)
			set i = 0
			loop
				exitwhen not table.has(i)
				call UnitRemoveAbility(dummy,table[i])
				set i = i + 1
			endloop
			call DummyAddRecycleTimer(dummy,0.25)		

			set timer  = null
			set source   = null
			set target   = null
			set cleanup = false
			call table.destroy()
	    else
			call UnitAddAbility(dummy,ATTACK_DISALE_ABILITY)
			set cleanup = true
			call TimerStart(timer, ORB_TIME, false, function thistype.onTimerExpire)
	    endif
    endmethod
	
	static method dummyUnitAttackStart takes unit s, unit t, integer attackt, real damage returns nothing
        local thistype this = thistype.create()
		local ability abil
		local integer i = 0
		local integer abilcode
            	set timer  = NewTimerEx(this)
		set table = Table.create()
		set dummy=GetRecycledDummy(GetUnitX(s),GetUnitY(s),0.,AngleBetweenPointsReal(GetUnitX(s),GetUnitY(s),GetUnitX(t),GetUnitY(t)))
		call SetUnitOwner(dummy,GetOwningPlayer(s),true)
		call PauseUnit(dummy,false)
		call UnitRemoveAbility(dummy,ATTACK_DISALE_ABILITY)
		loop
			set abil=BlzGetUnitAbilityByIndex(s,i)
			exitwhen abil==null
			set abilcode=BlzGetAbilityId(abil)
			if isTransferableAbility(abilcode) then
				call UnitAddAbility(dummy,abilcode)
				set table[i]=abilcode
				call SetUnitAbilityLevel(dummy,abilcode,GetUnitAbilityLevel(s,abilcode))
			endif
			set i = i + 1
		endloop
		call BlzSetUnitWeaponIntegerField( dummy, UNIT_WEAPON_IF_ATTACK_ATTACK_TYPE, 0, attackt )
		call BlzSetUnitBaseDamage(dummy,R2I(damage) - 1,0)
		call IssueTargetOrder(dummy,"attack",t)
		set .cleanup = false
        call TimerStart(timer, 0.5, false, function thistype.onTimerExpire)
	endmethod

endstruct

struct RelativisticAttackMissile extends Missiles

	private integer at
	private real aoef
	private real aoem
	private real aoes
	private real factorm
	private real factors
	private integer targetflags

	//**CONFIGURATION**
	//Filters out units that should not take damage from relativstic attacks that deal splash damage
	private static method SplashDamageEnum takes nothing returns boolean
		return not BlzIsUnitInvulnerable(GetFilterUnit()) and IsUnitEnemy(GetFilterUnit(),arg_player) and IsObjectEditorTarget(GetFilterUnit(),arg_int)
	endmethod

        method onFinish takes nothing returns boolean
		local group processed
		local group g
		local unit u
		if aoef > 0. then
			set g=CreateGroup()
			set processed = CreateGroup()
			set arg_player  = GetOwningPlayer(source)
			set arg_int  = targetflags
			call GroupEnumUnitsInRange(g,GetUnitX(.target),GetUnitY(.target),aoef,function thistype.SplashDamageEnum)
			loop
				set u=FirstOfGroup(g)
				exitwhen u==null
				if not IsUnitInGroup(u,processed) then
					call GroupAddUnit(processed,u)
					call DummyAttackHandler.dummyUnitAttackStart(.source,u,.at,.damage)
				endif
				call GroupRemoveUnit(g,u)
			endloop
			call GroupEnumUnitsInRange(g,GetUnitX(.target),GetUnitY(.target),aoem,function thistype.SplashDamageEnum)
			loop
				set u=FirstOfGroup(g)
				exitwhen u==null
				if not IsUnitInGroup(u,processed) then
					call GroupAddUnit(processed,u)
					call DummyAttackHandler.dummyUnitAttackStart(.source,u,.at,.damage * factorm)
				endif
				call GroupRemoveUnit(g,u)
			endloop
			call GroupEnumUnitsInRange(g,GetUnitX(.target),GetUnitY(.target),aoes,function thistype.SplashDamageEnum)
			loop
				set u=FirstOfGroup(g)
				exitwhen u==null
				if not IsUnitInGroup(u,processed) then
					call GroupAddUnit(processed,u)
					call DummyAttackHandler.dummyUnitAttackStart(.source,u,.at,.damage * factors)
				endif
				call GroupRemoveUnit(g,u)
			endloop
			call DestroyGroup(g)
			call DestroyGroup(processed)
			set g=null
			set processed=null
		else
			call DummyAttackHandler.dummyUnitAttackStart(.source,.target,.at,.damage)
		endif
            	return true
        endmethod

        static method Create takes unit c, unit t, integer attackt, string art, real speed, real arc, real aoef, real aoem, real aoes, real factorm, real factors ,integer targetflags returns nothing
        local real     x = GetUnitX(c)
        local real     y = GetUnitY(c)
	    local real 	   wb_tx = GetUnitX(t)
	    local real 	   wb_ty = GetUnitY(t)
            local thistype this = thistype.create(x, y, GetUnitDefaultFlyHeight(c) + 50.0, wb_tx, wb_ty, 50.0)

        set source    = c
	    set target = t
        set model     = art
        set .speed     = speed
	    if  .speed < 100.0 then
			set .speed = 10000.0
	    endif
	    set .arc = arc * 100
	    set damage 	  = udg_currentAttackDamage[GetUnitUserData(c)]
	    set .owner = GetOwningPlayer(c)
	    set .at = attackt
	    set .aoef = aoef
	    set .aoem = aoem
	    set .aoes = aoes
	    set .factorm = factorm
	    set .factors = factors
	    set .targetflags = targetflags
	    set .data = REDIRECT_EVENT_INT

        call launch()
        set c = null
        endmethod

endstruct

struct RelativisticAttackHandler
    private timer timer
    private unit source
	private unit target
	private string projectileArt
	private integer at
	private real speed
	private real arc
	private integer atindex
	private real aoef
	private real aoem
	private real aoes
	private real factorm
	private real factors
	private integer targetflags
	//private real spillDistance
	//private real spillRadius

	//**CONFIGURATION**
	//this function returns the attack index (0 or 1) to use for getting data
	private static method getAttackIndex takes unit s, unit t returns integer
		if not BlzGetUnitWeaponBooleanField(s,UNIT_WEAPON_BF_ATTACKS_ENABLED,1) then //Only attack 1 is enabled
			return 0
		elseif not BlzGetUnitWeaponBooleanField(s,UNIT_WEAPON_BF_ATTACKS_ENABLED,0) then //Only attack 2 is enabled
			return 1
		elseif GetUnitTypeId(s)=='umtw' and IsUnitType(t,UNIT_TYPE_STRUCTURE) then //Meat Wagon uses attack index 2 for structures
			return 1
		elseif IsUnitType(s,UNIT_TYPE_HERO) and IsUnitType(t,UNIT_TYPE_FLYING) then //Heroes use attack index 2 for air units
			return 1
		endif
		return 0
	endmethod

	//**CONFIGURATION**
	//This function checks if a unit has an AoE attack weapon type in the object editor e.g. Missile (Splash) before trying to access the AoE values
	//You need to add each unit that has an Area of Effect attack defined in the object editor that your map uses manually
	//Note: Accessing the values relating to an area of effect attack via BlzGetUnitWeaponRealField for a unit that doesn't have one will CRASH THE GAME
	//The system will ignore AoE if the below function returns false even if the unit does have an area of effect attack
	private static method hasAoEAttack takes integer utype returns boolean
		return utype=='umtw' //Currently only meat wagon is listed
	endmethod

	//**CONFIGURATION**
	//this function returns the attack index (0 or 1) which has the area of effect attack. Only used if the above function returns true.
	private static method getAoEAttackIndex takes unit s, unit t returns integer
		return 0
	endmethod

	//Not yet implemented
	//private static method hasSpillAttack takes integer utype returns boolean
	//	return false
	//endmethod

        private static method onTimerExpire takes nothing returns nothing
            local thistype this = GetTimerData(GetExpiredTimer())
                call ReleaseTimer(timer)
                call deallocate()

		call BlzSetUnitWeaponStringField(source,UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,atindex,projectileArt)
		call UnitRemoveAbility(source, ORB_DISALE_ABILITY)
		call RelativisticAttackMissile.Create(source,target,at,projectileArt,speed,arc,aoef,aoem,aoes,factorm,factors, targetflags)

                set timer  = null
                set source   = null
                set target   = null
        endmethod

        static method HandleAttack takes unit s, unit t returns nothing
            local thistype this = thistype.create()
	    set atindex=getAttackIndex(s,t)

            set timer  = NewTimerEx(this)
            set source   = s
	    set target = t
	    if BlzGetUnitWeaponIntegerField(s,UNIT_WEAPON_IF_ATTACK_MAXIMUM_NUMBER_OF_TARGETS,atindex) <= 1 then
			if hasAoEAttack(GetUnitTypeId(s)) then
				set atindex=getAoEAttackIndex(s,t)
				set aoef = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_AREA_OF_EFFECT_FULL_DAMAGE,atindex)
				set aoem = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_AREA_OF_EFFECT_MEDIUM_DAMAGE,atindex)
				set aoes = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_AREA_OF_EFFECT_SMALL_DAMAGE,atindex)
				set factorm = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_DAMAGE_FACTOR_MEDIUM,atindex)
				set factors = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_DAMAGE_FACTOR_SMALL,atindex)
				set targetflags = BlzGetUnitWeaponIntegerField(s,UNIT_WEAPON_IF_ATTACK_AREA_OF_EFFECT_TARGETS,atindex)
			else
				set aoef = 0.
				set aoem = 0.
				set aoes = 0.
				set factorm = 0.
				set factors = 0.
			endif
			//set spillDistance = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_DAMAGE_SPILL_DISTANCE,atindex)
			//set spillRadius = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_DAMAGE_SPILL_RADIUS,atindex)
			else
			set aoef = 0.
			set aoem = 0.
			set aoes = 0.
			set factorm = 0.
			set factors = 0.
			//set spillDistance = 0.
			//set spillRadius = 0.
	    endif

	    set projectileArt = BlzGetUnitWeaponStringField(s,UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,atindex)
	    set at=BlzGetUnitWeaponIntegerField(s,UNIT_WEAPON_IF_ATTACK_ATTACK_TYPE,atindex)
	    set speed = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_PROJECTILE_SPEED,atindex)
	    set arc = BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_PROJECTILE_ARC,atindex)

	    call BlzSetUnitWeaponStringField(s,UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,atindex,"")
	    call UnitAddAbility(s, ORB_DISALE_ABILITY )
        call TimerStart(timer, (BlzGetUnitWeaponRealField(s,UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT,atindex) / (1 + (GetHeroAgi(s,true)) * ATTACK_AGI_SPEED_BONUS)) + 0.03, false, function thistype.onTimerExpire)

    endmethod

endstruct

    //**CONFIGURATION**
    //Any unit that doesn't match the below conditions will never launch a relativistic attack

	private function validUnit takes unit u returns boolean
		return IsUnitType(u,UNIT_TYPE_RANGED_ATTACKER) and GetUnitAbilityLevel(u,'Aloc') == 0
	endfunction

    private function onAttackConditions takes nothing returns boolean
		return validUnit(GetAttacker()) and DistanceBetweenPointsReal(GetUnitX(GetTriggerUnit()),GetUnitY(GetTriggerUnit()),GetUnitX(GetAttacker()),GetUnitY(GetAttacker())) > MELEE_DISTANCE
    endfunction


    //**CONFIGURATION**
    //This function controls when to launch a relativistic attack for units that pass the above conditions

    private function onAttackEnum takes nothing returns boolean
		return GetUnitAbilityLevel(GetFilterUnit(),REDIRECT_ABILITY) > 0 //Only launch a relativistic attack if the target is near a unit with the redirect ability
    endfunction

    private function onAttackActions takes nothing returns nothing
	if GetClosestUnitInRange(GetUnitX(GetTriggerUnit()),GetUnitY(GetTriggerUnit()),AFFECETD_DISTANCE, Condition(function onAttackEnum))!=null then //Only launch a relativistic attack if the target is near a unit with the redirect ability and the distance between the units is enough for a ranged attack
		call SaveBoolean(udg_AttackIndexerHash,udg_AttackEventHashKey[GetUnitUserData(GetAttacker())],ZERO_DAMAGE_HASH_KEY,true) //Make sure the real attack deals 0 damage
		call RelativisticAttackHandler.HandleAttack(GetAttacker(),GetTriggerUnit()) //Make sure the real attack has no art and ignores orb effects
	else
		call RemoveSavedBoolean(udg_AttackIndexerHash,udg_AttackEventHashKey[GetUnitUserData(GetAttacker())],ZERO_DAMAGE_HASH_KEY) //Clear the 0 damage flag and reset the art if the conditions aren't met
		call BlzSetUnitWeaponStringField(GetAttacker(),UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,0,projectileArt1[GetUnitUserData(GetAttacker())])
		call BlzSetUnitWeaponStringField(GetAttacker(),UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,0,projectileArt1[GetUnitUserData(GetAttacker())])
	endif
    endfunction


    //**CONFIGURATION**
    //Controls when to reduce damage from the real attack to 0. You won't need to change this most likely)

    private function preDamage_Conditions takes nothing returns boolean
		return udg_IsDamageAttack and validUnit(udg_DamageEventSource) and LoadBoolean(udg_AttackIndexerHash,udg_AttackEventHashKey[GetUnitUserData(udg_DamageEventSource)],ZERO_DAMAGE_HASH_KEY)
    endfunction

    private function preDamage_Actions takes nothing returns nothing
		set udg_DamageEventAmount = 0.
    endfunction

    private function enters_Conditions takes nothing returns boolean
		return validUnit(udg_UDexUnits[udg_UDex])
    endfunction

    private function enters_Actions takes nothing returns nothing
		set projectileArt1[GetUnitUserData(udg_UDexUnits[udg_UDex])] = BlzGetUnitWeaponStringField(udg_UDexUnits[udg_UDex],UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,0)
		set projectileArt1[GetUnitUserData(udg_UDexUnits[udg_UDex])] = BlzGetUnitWeaponStringField(udg_UDexUnits[udg_UDex],UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART,0)
    endfunction

    private function onInit takes nothing returns nothing
		local trigger t = CreateTrigger()
		call TriggerRegisterAnyUnitEventBJ( t, EVENT_PLAYER_UNIT_ATTACKED )
    	call TriggerAddCondition( t, Condition( function onAttackConditions ) )
    	call TriggerAddAction( t, function onAttackActions )
		set t = CreateTrigger()
    	call TriggerRegisterVariableEvent( t, "udg_PreDamageEvent", EQUAL, 1.00 )
    	call TriggerAddCondition( t, Condition( function preDamage_Conditions ) )
    	call TriggerAddAction( t, function preDamage_Actions )
		set t = CreateTrigger()
    	call TriggerRegisterVariableEvent( t, "udg_UnitIndexEvent", EQUAL, 1.00 )
    	call TriggerAddCondition( t, Condition( function enters_Conditions ) )
    	call TriggerAddAction( t, function enters_Actions )
		set t = null
    endfunction
endscope

scope Redirect initializer onInit

	globals
	private constant integer REDIRECT_EVENT_INT = -513 //Set this to a unique value not used elsewhere in your map. It is used to identify missiles that can be redirected.
	private constant integer REDIRECT_ABILITY = 'A001' //Ability ID of your redirecting spell
	private real REDIRECT_AOE = 2000. //Aoe to search for missiles to redirect
	endglobals

    private function redirectSpellActions takes nothing returns nothing
	local MissileGroup mg = MissileGroup.create()
	local Missiles m
	local unit c = GetTriggerUnit()
	local unit t = GetSpellTargetUnit()
	local integer i = 0
	call GroupEnumMissilesInRange(mg,GetUnitX(c),GetUnitY(c),REDIRECT_AOE)
	loop
		set m = mg.missileAt(i)
		exitwhen m == 0
			if m.data == REDIRECT_EVENT_INT and IsPlayerEnemy(m.owner,GetOwningPlayer(c)) then //Filters for which missiles will be redirected
				set m.target = t
			endif
		set i = i + 1
	endloop
	set c=null
	set t=null
    endfunction

    private function onInit takes nothing returns nothing
	call RegisterSpellEffectEvent(REDIRECT_ABILITY, function redirectSpellActions)
    endfunction

endscope

function Trig_Store_Current_Damage_Enters_Actions takes nothing returns nothing
	local integer basedamage = BlzGetUnitBaseDamage(udg_UDexUnits[udg_UDex], 0)
	local integer attbonus = 1 //Set this to the damage bonus for primary attribute in gameplay constants
	local integer att=0 
	if IsUnitType(udg_UDexUnits[udg_UDex],UNIT_TYPE_HERO) then
		set att=GetHeroStr(udg_UDexUnits[udg_UDex],true)
		set att=IMaxBJ(att,GetHeroInt(udg_UDexUnits[udg_UDex],true))
		set att=IMaxBJ(att,GetHeroAgi(udg_UDexUnits[udg_UDex],true))
	endif
    	set udg_currentAttackDamage[GetUnitUserData(udg_UDexUnits[udg_UDex])] = basedamage + (att * attbonus)
endfunction

//===========================================================================
function InitTrig_Store_Current_Damage_Enters takes nothing returns nothing
    set gg_trg_Store_Current_Damage_Enters = CreateTrigger(  )
    call TriggerRegisterVariableEvent( gg_trg_Store_Current_Damage_Enters, "udg_UnitIndexEvent", EQUAL, 1.00 )
    call TriggerAddAction( gg_trg_Store_Current_Damage_Enters, function Trig_Store_Current_Damage_Enters_Actions )
endfunction