Maps

Resources

Models

Skins

Icons

Spells & Systems

Packs

Sounds

Tools

Tutorials

Gallery

Utility

Pastebin

Asset Scanner

Icon Borderiser

Model Checker

Support Us

Shop

Become a Hero

Buy a Banner

Listen to a special audio message from Bill Roper to the Hive Workshop community (Bill is a former Vice President of Blizzard Entertainment, Producer, Designer, Musician, Voice Actor) 🔗Click here to hear his message!
Read Evilhog's interview with Gregory Alper, the original composer of the music for WarCraft: Orcs & Humans 🔗Click here to read the full interview.

Triggers

SuicideSquad.w3x

Variables

Libs

AbilityPreload

ARGB

ListModule

GroupUtils

SoundUtils

Stack

Table

TimerUtils

xebasic

xefx

xecast

xedamage

ZUtils

Optional Libs

AutoFly

AutoIndex

Spell

Suicide Quad

Testmap

Enter map-specific custom script code below. This text will be included in the map script after variables are declared and before any trigger code.

Name	Type	is_array	initial_value

//TESH.scrollpos=0
//TESH.alwaysfold=0
library AbilityPreload
//===========================================================================
// Information:
//==============
//
//      Preloading removes the noticeable delay the first time an ability
//  is loaded in a game. If an ability was not already on a pre-placed unit
//  or a unit that was created during initialization, preloading is needed
//  to prevent a delay.
//
//===========================================================================
// AbilityPreload API:
//=====================
//
//  AbilityPreload(abilityid) :
//        Call this before any time has elapsed to preload a specific
//     ability. If debug mode is enabled, you will see an error message
//     if you call this after initialization, or if you try to preload
//     an ability that does not exist. Will inline to a UnitAddAbility
//     call if debug mode is disabled.
//
//  AbilityRangePreload(start, end) :
//        Same as AbilityPreload, but preloads a range of abilities.
//      It will iterates between the two rawcode values and preload
//      every ability along the way. It will not show an error message
//      for non-existent abilities.
// 
//===========================================================================
// Configuration:
//================

globals
    private constant integer PreloadUnitRawcode = 'zsmc'
    //This is the rawcode for "Sammy!". It is never used and has no model,
    //which makes an ideal preloading unit. Change it if you want to.
endglobals

//===========================================================================

globals
    private unit PreloadUnit
endglobals

function AbilityPreload takes integer abilityid returns nothing
    static if DEBUG_MODE then
        if GetUnitTypeId(PreloadUnit) == 0 then
            call BJDebugMsg("AbilityPreload error: Can't preload an ability after initialization")
            return
        endif
    endif
    call UnitAddAbility(PreloadUnit, abilityid)
    static if DEBUG_MODE then
        if GetUnitAbilityLevel(PreloadUnit, abilityid) == 0 then
            call BJDebugMsg("AbilityPreload error: Attempted to preload a non-existent ability")
        endif
    endif
endfunction

function AbilityRangePreload takes integer start, integer end returns nothing
    local integer i = 1
        static if DEBUG_MODE then
            if GetUnitTypeId(PreloadUnit) == 0 then
                call BJDebugMsg("AbilityPreload error: Can't preload an ability after initialization")
                return
            endif
        endif
        if start > end then
            set i = -1
        endif
        loop
            exitwhen start > end
            call UnitAddAbility(PreloadUnit, start)
            set start = start + i
        endloop
endfunction

//===========================================================================

private struct Init extends array
    private static method onInit takes nothing returns nothing
        set PreloadUnit = CreateUnit(Player(15), PreloadUnitRawcode, 0., 0., 0.)
        call UnitApplyTimedLife(PreloadUnit, 0, .001)
        call ShowUnit(PreloadUnit, false)
        call UnitAddAbility(PreloadUnit, 'Aloc')
    endmethod
endstruct

endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library ARGB initializer init
//******************************************************************************
//*
//* ARGB 1.2
//* ====
//*  For your color needs.
//*  
//*  An ARGB object is a by-value struct, this means that assigning copies the
//* contents of the struct and that you don't have to use .destroy(), the
//* downside is that you cannot assign its members (can't do set c.r= 123 )
//*
//*  This library should have plenty of uses, for example, if your spell involves
//* some unit recoloring you can allow users to input the color in the config
//* section as 0xAARRGGBB and you can then use this to decode that stuff.
//*
//* You can also easily merge two colors and make fading effects using ARGB.mix
//*
//* There's ARGB.fromPlayer which gets an ARGB object containing the player's
//* color. Then you can use the previous utilities on it.
//*
//* The .str() instance method can recolor a string, and the recolorUnit method
//* will apply the ARGB on a unit
//*
//* For other uses, you can use the .red, .green, .blue and .alpha members to get
//* an ARGB object's color value (from 0 to 255).
//*
//* structs that have a recolor method that takes red,green,blue and alpha as 0.255
//* integers can implement the ARGBrecolor module to gain an ability to quickly
//* recolor using an ARGB object.
//*
//********************************************************************************

//=================================================================================
globals
    private string array i2cc
endglobals

//this double naming stuff is beginning to make me insane, if only TriggerEvaluate() wasn't so slow...
struct ARGB extends array
    static method create takes integer a, integer r, integer g, integer b returns ARGB
        return ARGB(b + g*0x100 + r*0x10000 + a*0x1000000)
    endmethod
    
    // not really part of the exported stuff, I may remove it in the future, so please don't call this textmacro
    //! textmacro ARGB_PLAYER_COLOR_2_ARGB
        if(pc==PLAYER_COLOR_RED) then
            return 0xFFFF0303
        elseif(pc==PLAYER_COLOR_BLUE) then
            return 0xFF0042FF
        elseif(pc==PLAYER_COLOR_CYAN) then
            return 0xFF1CE6B9
        elseif(pc==PLAYER_COLOR_PURPLE) then
            return 0xFF540081
        elseif(pc==PLAYER_COLOR_YELLOW) then
            return 0xFFFFFC01
        elseif(pc==PLAYER_COLOR_ORANGE) then
            return 0xFFFE8A0E
        elseif(pc==PLAYER_COLOR_GREEN) then
            return 0xFF20C000
        elseif(pc==PLAYER_COLOR_PINK) then
            return 0xFFE55BB0
        elseif(pc==PLAYER_COLOR_LIGHT_GRAY) then
            return 0xFF959697
        elseif(pc==PLAYER_COLOR_LIGHT_BLUE) then
            return 0xFF7EBFF1
        elseif(pc==PLAYER_COLOR_AQUA) then
            return 0xFF106246
        elseif(pc==PLAYER_COLOR_BROWN) then
            return 0xFF4E2A04
        endif
        
      return 0xFF111111
    //! endtextmacro
    static method fromPlayerColor takes playercolor pc returns ARGB
        //! runtextmacro ARGB_PLAYER_COLOR_2_ARGB()
    endmethod

    static method fromPlayer takes player p returns ARGB
     local playercolor pc=GetPlayerColor(p)
        //! runtextmacro ARGB_PLAYER_COLOR_2_ARGB()
    endmethod

    method operator alpha takes nothing returns integer
        if( integer(this) <0) then
            return 0x80+(-(-integer(this)+0x80000000))/0x1000000
        else
            return (integer(this))/0x1000000
        endif
    endmethod
    method operator alpha= takes integer na returns ARGB
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       return ARGB(b + g*0x100 + r*0x10000 + na*0x1000000) 
    endmethod




    method operator red takes nothing returns integer
     local integer c=integer(this)*0x100
        if(c<0) then
            return 0x80+(-(-c+0x80000000))/0x1000000
        else
            return c/0x1000000
        endif
    endmethod
    method operator red= takes integer nr returns ARGB
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       return ARGB(b + g*0x100 + nr*0x10000 + a*0x1000000) 
    endmethod

    method operator green takes nothing returns integer
     local integer c=integer(this)*0x10000
        if(c<0) then
            return 0x80+(-(-c+0x80000000))/0x1000000
        else
            return c/0x1000000
        endif
    endmethod
    method operator green= takes integer ng returns ARGB
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       return ARGB(b + ng*0x100 + r*0x10000 + a*0x1000000) 
    endmethod

    //=======================================================
    //
    //
    method operator blue takes nothing returns integer
     local integer c=integer(this)*0x1000000
        if(c<0) then
            return 0x80+(-(-c+0x80000000))/0x1000000
        else
            return c/0x1000000
        endif
    endmethod
    method operator blue= takes integer nb returns ARGB
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       return ARGB(nb + g*0x100 + r*0x10000 + a*0x1000000) 
    endmethod

    //====================================================================
    // Mixes two colors, s would be a number 0<=s<=1 that determines
    // the weight given to color c2.
    //
    //  mix(c1,c2,0)   = c1
    //  mix(c1,c2,1)   = c2
    //  mix(c1,c2,0.5) = Mixing the colors c1 and c2 in equal proportions.
    //
    static method mix takes ARGB c1, ARGB c2, real s returns ARGB
      //widest function ever
      return ARGB( R2I(c2.blue*s+c1.blue*(1-s)+0.5) + R2I(c2.green*s+c1.green*(1-s)+0.5)*0x100 + R2I(c2.red*s+c1.red*(1-s)+0.5)*0x10000 + R2I(c2.alpha*s+c1.alpha*(1-s)+0.5)*0x1000000)
    endmethod

    method str takes string s returns string
       return "|c"+i2cc[.alpha]+i2cc[.red]+i2cc[.green]+i2cc[.blue]+s+"|r"
    endmethod

    method recolorUnit takes unit u returns nothing
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       call SetUnitVertexColor(u,r,g,b,a)
    endmethod

endstruct

module ARGBrecolor
    method ARGBrecolor takes ARGB color returns nothing
     local integer a
     local integer r
     local integer g
     local integer b
     local integer col=integer(this)

       if (col<0) then
           set col=-(-col+0x80000000)
           set a=0x80+col/0x1000000
           set col=col-(a-0x80)*0x1000000
       else
           set a=col/0x1000000
           set col=col-a*0x1000000
       endif
       set r=col/0x10000
       set col=col-r*0x10000
       set g=col/0x100
       set b=col-g*0x100
       
       call this.recolor(r, g , b, a)
    endmethod

endmodule

private function init takes nothing returns nothing
 local integer i=0

    // Don't run textmacros you don't own!
    //! textmacro ARGB_CHAR takes int, chr
        set i=0
        loop
            exitwhen i==16
            set i2cc[$int$*16+i]="$chr$"+i2cc[$int$*16+i]
            set i2cc[i*16+$int$]=i2cc[i*16+$int$]+"$chr$"
            set i=i+1
        endloop
    //! endtextmacro
    //! runtextmacro ARGB_CHAR( "0","0")
    //! runtextmacro ARGB_CHAR( "1","1")
    //! runtextmacro ARGB_CHAR( "2","2")
    //! runtextmacro ARGB_CHAR( "3","3")
    //! runtextmacro ARGB_CHAR( "4","4")
    //! runtextmacro ARGB_CHAR( "5","5")
    //! runtextmacro ARGB_CHAR( "6","6")
    //! runtextmacro ARGB_CHAR( "7","7")
    //! runtextmacro ARGB_CHAR( "8","8")
    //! runtextmacro ARGB_CHAR( "9","9")
    //! runtextmacro ARGB_CHAR("10","A")
    //! runtextmacro ARGB_CHAR("11","B")
    //! runtextmacro ARGB_CHAR("12","C")
    //! runtextmacro ARGB_CHAR("13","D")
    //! runtextmacro ARGB_CHAR("14","E")
    //! runtextmacro ARGB_CHAR("15","F")
endfunction

endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library ListModule
//===========================================================================
// Information:
//==============
//
//     This library provides the List module, which allows you to easily create
// a linked list of all of the allocated instances of a struct-type. Iterating
// through a linked list is about 12% faster than iteratating through an array
// in JASS. There is no faster method to iterate through a list of structs than
// the method used by this module. Aside from the marginal speed gain, the best
// use of this library is to hide some ugly low-level code from your structs.
// Rather than manually building and maintaining a list of struct instances,
// just implement the List module, and your code will become much prettier.
//
//===========================================================================
// How to use the List module:
//=============================
//
//     Using the List module is pretty simple. First, implement it in your
// struct (preferably at the top to avoid unnecessary TriggerEvaluate calls).
// In the struct's create method, you must call listAdd(). In the onDestroy
// method, you must also call listRemove(). An example is shown below:
/*
    struct Example
        implement List
        
        static method create takes nothing returns Example
            local Example this = allocate()
                call listAdd() //This method adds the instance to the list.
            return this
        endmethod
        
        method onDestroy takes nothing returns nothing
            call listRemove() //This method removes the instance from the list.
        endmethod
    endstruct
*/
//     The requirement to call listAdd() and listRemove() will be done away
// with once JassHelper supports module onDestroy and module onCreate, but
// for now, it is not too much of a burden.
//
//     Once this is done, your struct will gain all of the methods detailed
// in the API section. Below is an example of how to iterate through the list
// of allocated structs of the implementing struct-type:
/*
    function IterationExample takes nothing returns nothing
        local Example e = Example.first
            loop
                exitwhen e == 0
                //Do something with e here.
                set e = e.next
            endloop
        //Use .last and .prev instead to iterate backwards.
    endmethod
*/
//
//===========================================================================
// List module API:
//==================
//
// (readonly)(static) first -> thistype
//   This member contains the first instance of thistype in the list.
//
// (readonly)(static) last -> thistype
//   This member contains the last instance of thistype in the list.
//
// (readonly)(static) count -> integer
//   This member contains the number of allocated structs of thistype.
//
// (readonly) next -> thistype
//   This member contains the next instance of thistype in the list.
//
// (readonly) prev -> thistype
//   This member contains the previous instance of thistype in the list.
//
// listAdd()
//   This method adds this instance to the list of structs of thistype.
//   This should be called on each instance after it is allocated (within
//   the create method).
//
// listRemove()
//   This method removes this instance from the list of structs of thistype.
//   This should be called on each instance before it is destroyed (within
//   the onDestroy method).
//
// (static) listDestroy()
//   This method destroys all the structs of thistype within the list.
//
//===========================================================================

module List
    private static boolean destroying = false
    private boolean inlist = false
    
    readonly static integer count = 0
    
    readonly thistype next = 0
    readonly thistype prev = 0
    
    static method operator first takes nothing returns thistype
        return thistype(0).next
    endmethod
    
    static method operator last takes nothing returns thistype
        return thistype(0).prev
    endmethod
    
    method listRemove takes nothing returns boolean
        if not inlist then
            return false
        endif
        set inlist = false
        set prev.next = next
        set next.prev = prev
        set count = count - 1
        return true
    endmethod

    method listAdd takes nothing returns boolean
        if inlist or destroying then
            return false
        endif
        set inlist = true
        set last.next = this
        set prev = last
        set thistype(0).prev = this
        set count = count + 1
        return true
    endmethod
    
    static method listDestroy takes nothing returns nothing
        local thistype this = last
            set destroying = true
            loop
                exitwhen this == 0
                call destroy()
                set this = prev
            endloop
            set destroying = false
    endmethod
    
endmodule

endlibrary

//TESH.scrollpos=50
//TESH.alwaysfold=0
library GroupUtils initializer Init requires optional xebasic
//******************************************************************************
//* BY: Rising_Dusk
//* 
//* This library is a combination of several features relevant to groups. First
//* and foremost, it contains a group stack that you can access dynamic groups
//* from. It also provides means to refresh groups and clear any shadow
//* references within them. The included boolexprs are there for backwards
//* compatibility with maps that happen to use them. Since the 1.24c patch,
//* null boolexprs used in GroupEnumUnits* calls no longer leak, so there is no
//* performance gain to using the BOOLEXPR_TRUE constant.
//* 
//* Instead of creating/destroying groups, we have moved on to recycling them.
//* NewGroup pulls a group from the stack and ReleaseGroup adds it back. Always
//* remember to call ReleaseGroup on a group when you are done using it. If you
//* fail to do so enough times, the stack will overflow and no longer work.
//* 
//* GroupRefresh cleans a group of any shadow references which may be clogging
//* its hashtable. If you remove a unit from the game who is a member of a unit
//* group, it will 'effectively' remove the unit from the group, but leave a
//* shadow in its place. Calling GroupRefresh on a group will clean up any
//* shadow references that may exist within it. It is only worth doing this on
//* groups that you plan to have around for awhile.
//* 
//* Constants that can be used from the library:
//*     [group]    ENUM_GROUP      As you might expect, this group is good for
//*                                when you need a group just for enumeration.
//*     [boolexpr] BOOLEXPR_TRUE   This is a true boolexpr, which is important
//*                                because a 'null' boolexpr in enumeration
//*                                calls results in a leak. Use this instead.
//*     [boolexpr] BOOLEXPR_FALSE  This exists mostly for completeness.
//* 
//* This library also includes a simple implementation of a group enumeration
//* call that factors collision of units in a given area of effect. This is
//* particularly useful because GroupEnumUnitsInRange doesn't factor collision.
//* 
//* In your map, you can just replace all instances of GroupEnumUnitsInRange
//* with GroupEnumUnitsInArea with identical arguments and your spells will
//* consider all units colliding with the area of effect. After calling this
//* function as you would normally call GroupEnumUnitsInRange, you are free to
//* do anything with the group that you would normally do.
//* 
//* If you don't use xebasic in your map, you may edit the MAX_COLLISION_SIZE
//* variable below and the library will use that as the added radius to check.
//* If you use xebasic, however, the script will automatically use xe's
//* collision size variable.
//* 
//* You are also able to use GroupUnitsInArea. This function returns all units
//* within the area, no matter what they are, which can be convenient for those
//* instances where you actually want that.
//* 
//* Example usage:
//*     local group MyGroup = NewGroup()
//*     call GroupRefresh(MyGroup)
//*     call ReleaseGroup(MyGroup)
//*     call GroupEnumUnitsInArea(ENUM_GROUP, x, y, 350., BOOLEXPR_TRUE)
//*     call GroupUnitsInArea(ENUM_GROUP, x, y, 350.)
//* 
globals
    //If you don't have xebasic in your map, this value will be used instead.
    //This value corresponds to the max collision size of a unit in your map.
    private constant real    MAX_COLLISION_SIZE = 197.
    //If you are insane and don't care about any of the protection involved in
    //this library, but want this script to be really fast, set this to true.
    private constant boolean LESS_SAFETY        = false
endglobals

globals
    //* Constants that are available to the user
    group    ENUM_GROUP     = CreateGroup()
    boolexpr BOOLEXPR_TRUE  = null
    boolexpr BOOLEXPR_FALSE = null
endglobals

globals
    //* Hashtable for debug purposes
    private hashtable     ht     = InitHashtable()
    //* Temporary references for GroupRefresh
    private boolean       Flag   = false
    private group         Refr   = null
    //* Arrays and counter for the group stack
    private group   array Groups
    private integer       Count  = 0
    //* Variables for use with the GroupUnitsInArea function
    private real          X      = 0.
    private real          Y      = 0.
    private real          R      = 0.
    private hashtable     H      = InitHashtable()
endglobals

private function HookDestroyGroup takes group g returns nothing
    if g == ENUM_GROUP then
        call BJDebugMsg(SCOPE_PREFIX+"Warning: ENUM_GROUP destroyed")
    endif
endfunction

debug hook DestroyGroup HookDestroyGroup

private function AddEx takes nothing returns nothing
    if Flag then
        call GroupClear(Refr)
        set Flag = false
    endif
    call GroupAddUnit(Refr, GetEnumUnit())
endfunction
function GroupRefresh takes group g returns nothing
    set Flag = true
    set Refr = g
    call ForGroup(Refr, function AddEx)
    if Flag then
        call GroupClear(g)
    endif
endfunction

function NewGroup takes nothing returns group
    if Count == 0 then
        set Groups[0] = CreateGroup()
    else
        set Count = Count - 1
    endif
    static if not LESS_SAFETY then
        call SaveInteger(ht, 0, GetHandleId(Groups[Count]), 1)
    endif
    return Groups[Count]
endfunction
function ReleaseGroup takes group g returns boolean
    local integer id = GetHandleId(g)
    static if LESS_SAFETY then
        if g == null then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Null groups cannot be released")
            return false
        elseif Count == 8191 then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Max groups achieved, destroying group")
            call DestroyGroup(g)
            return false
        endif
    else
        if g == null then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Null groups cannot be released")
            return false
        elseif not HaveSavedInteger(ht, 0, id) then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Group not part of stack")
            return false
        elseif LoadInteger(ht, 0, id) == 2 then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Groups cannot be multiply released")
            return false
        elseif Count == 8191 then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: Max groups achieved, destroying group")
            call DestroyGroup(g)
            return false
        endif
        call SaveInteger(ht, 0, id, 2)
    endif
    call GroupClear(g)
    set Groups[Count] = g
    set Count         = Count + 1
    return true
endfunction

private function Filter takes nothing returns boolean
    return IsUnitInRangeXY(GetFilterUnit(), X, Y, R)
endfunction

private function HookDestroyBoolExpr takes boolexpr b returns nothing
    local integer bid = GetHandleId(b)
    if HaveSavedHandle(H, 0, bid) then
        //Clear the saved boolexpr
        call DestroyBoolExpr(LoadBooleanExprHandle(H, 0, bid))
        call RemoveSavedHandle(H, 0, bid)
    endif
endfunction

hook DestroyBoolExpr HookDestroyBoolExpr

private constant function GetRadius takes real radius returns real
    static if LIBRARY_xebasic then
        return radius+XE_MAX_COLLISION_SIZE
    else
        return radius+MAX_COLLISION_SIZE
    endif
endfunction

function GroupEnumUnitsInArea takes group whichGroup, real x, real y, real radius, boolexpr filter returns nothing
    local real    prevX = X
    local real    prevY = Y
    local real    prevR = R
    local integer bid   = 0
    
    //Set variables to new values
    set X = x
    set Y = y
    set R = radius
    if filter == null then
        //Adjusts for null boolexprs passed to the function
        set filter = Condition(function Filter)
    else
        //Check for a saved boolexpr
        set bid = GetHandleId(filter) 
        if HaveSavedHandle(H, 0, bid) then
            //Set the filter to use to the saved one
            set filter = LoadBooleanExprHandle(H, 0, bid)
        else
            //Create a new And() boolexpr for this filter
            set filter = And(Condition(function Filter), filter)
            call SaveBooleanExprHandle(H, 0, bid, filter)
        endif
    endif
    //Enumerate, if they want to use the boolexpr, this lets them
    call GroupEnumUnitsInRange(whichGroup, x, y, GetRadius(radius), filter)
    //Give back original settings so nested enumerations work
    set X = prevX
    set Y = prevY
    set R = prevR
endfunction

function GroupUnitsInArea takes group whichGroup, real x, real y, real radius returns nothing
    local real prevX = X
    local real prevY = Y
    local real prevR = R
    
    //Set variables to new values
    set X = x
    set Y = y
    set R = radius
    //Enumerate
    call GroupEnumUnitsInRange(whichGroup, x, y, GetRadius(radius), Condition(function Filter))
    //Give back original settings so nested enumerations work
    set X = prevX
    set Y = prevY
    set R = prevR
endfunction

private function True takes nothing returns boolean
    return true
endfunction
private function False takes nothing returns boolean
    return false
endfunction
private function Init takes nothing returns nothing
    set BOOLEXPR_TRUE  = Condition(function True)
    set BOOLEXPR_FALSE = Condition(function False)
endfunction
endlibrary

//TESH.scrollpos=301
//TESH.alwaysfold=0
library SoundUtils requires Stack, TimerUtils
//******************************************************************************
//* BY: Rising_Dusk
//* 
//* Sounds are a very picky datatype in WC3. They have many quirks that one must
//* account for in order to use them, and simply using the internal WE Sound
//* Editor isn't enough because the sounds it makes can't be played multiple
//* times at once. 3-D sounds are also very tricky because there are different
//* WC3 sound options that a user can have activated where certain sounds will
//* or will not work. This library attempts to streamline the handling of sounds
//* so that it is less likely to confuse you or cause problems.
//* 
//* The .mp3 format can be used for 3-D sounds, but there is one problem that
//* must be noted. If your computer supports the "Dolby Surround" sound option
//* in WC3 and you have it selected, then .mp3 files will work for 3-D sounds.
//* If you don't, however, they may not work depending on what you do have
//* selected and what is available for your computer. The .wav format works on
//* all possible settings, making them excellent for general use. This library
//* can interface with sounds of either type.
//* 
//* Known issues with sounds that this library resolves:
//*     - A given sound variable can only be played once at a time. In order to
//*       play a sound type multiple times at once, you need multiple variables.
//*     - A sound cannot be played at the same instant that it is created.
//* 
//* The DefineSound function defines a sound type based on some basic parameters
//* the user provides. DefineSoundEx is available if the user wants control over
//* all possible parameters, though they won't have an impact most of the time.
//* The duration parameter for DefineSound and DefineSoundEx is in milliseconds,
//* which is consistent with Blizzard's natives. To get the duration of a given
//* sound, open up the WE's Sound Editor, navigate to your sound, and select
//* "Add as Sound." In doing so, it will show its duration in seconds. Multiply
//* that number by 1000 and use it as the duration argument.
//* 
//* This library returns a sound variable with RunSound that you can change the
//* settings of using the standard JASS sound API. The library assigns default
//* values to the parameters for 2-D and 3-D sounds, that way they will run
//* without any further help.
//* 
//* The library automatically allocates, runs, and recycles a sound when you
//* call RunSound. This library will not automatically recycle looping sounds,
//* so you will need to call ReleaseSound on the looping sound when you want it
//* to end.
//* 
//******************************************************************************
//* 
//*    > function DefineSound takes string fileName, integer duration, ...
//*        boolean looping, boolean is3D returns integer
//* 
//* This function defines a sound type with a short list of parameters. The
//* returned integer serves as a SOUND_TYPE for running this type of sound at
//* any other point in a map.
//* 
//*    > function DefineSoundEx takes string fileName, integer duration, ...
//*        boolean looping, boolean is3D, boolean stopwhenoutofrange, ...
//*        integer fadeInRate, integer fadeOutRate, string eaxSetting ...
//*        returns integer
//* 
//* This function serves an identical purpose to DefineSound, but gives the user
//* full control over the entire list of parameters. Similar to DefineSound, the
//* returned integer serves as a SOUND_TYPE for running this type of sound.
//* 
//*    > function RunSound takes integer soundRef returns sound
//* 
//* This function runs a sound with the parameters held within the soundRef
//* integer argument. The soundRef argument is the returned value of DefineSound
//* or DefineSoundEx.
//* 
//*    > function RunSoundOnUnit takes integer soundRef, unit whichUnit returns sound
//* 
//* The same as RunSound, just this function runs a sound of a given type on a
//* specified unit.
//* 
//*    > function RunSoundAtPoint takes integer soundRef, real x, real y, real z returns sound
//* 
//* The same as RunSound, just this function runs a sound of a given type at a
//* specified point in 3D space.
//* 
//*    > function RunSoundForPlayer takes integer soundRef, player p returns sound
//* 
//* The same as RunSound, just this function runs a sound of a given type only
//* for the specified player.
//* 
//*    > function ReleaseSound takes sound s returns boolean
//* 
//* This function need only be called on looping sounds. If a sound is not
//* looping, it will be released and recycled on its own. This function should
//* be used on looping sounds when you want them to end.
//* 
//* Example usage:
//*     set SOUND_TYPE = DefineSound("Sound\\Path.wav", 300, false, true)
//*     call RunSound(SOUND_TYPE)
//*     call RunSoundOnUnit(SOUND_TYPE, SomeUnit)
//*     call RunSoundAtPoint(SOUND_TYPE, x, y, z)
//*     call RunSoundForPlayer(SOUND_TYPE, Player(5))
//*     call ReleaseSound(SomeLoopingSound)
//* 
globals
    private hashtable ht = InitHashtable() //Attach sound types to sounds
    private hashtable st = InitHashtable() //Sound hashtable
    private hashtable rt = InitHashtable() //Attach soundrecyclers to sounds
    private hashtable kt = InitHashtable() //Attach StopSound data
endglobals

//Struct for each sound type
private struct soundhelper
    //Stack associated to each struct
    Stack   sta
    
    //Sound Settings for this sound type
    string  fileName           = ""
    integer duration           = 0
    boolean looping            = false
    boolean is3D               = false
    boolean stopwhenoutofrange = false
    integer fadeInRate         = 0
    integer fadeOutRate        = 0
    string  eaxSetting         = ""
    
    static method create takes string fileName, integer duration, boolean looping, boolean is3D, boolean stopwhenoutofrange, integer fadeInRate, integer fadeOutRate, string eaxSetting returns soundhelper
        local soundhelper sh      = soundhelper.allocate()
        //Load the parameters so the sound can be created later as necessary
        set sh.fileName           = fileName
        set sh.duration           = duration
        set sh.looping            = looping
        set sh.is3D               = is3D
        set sh.stopwhenoutofrange = stopwhenoutofrange
        set sh.fadeInRate         = fadeInRate
        set sh.fadeOutRate        = fadeOutRate
        set sh.eaxSetting         = eaxSetting
        //Create the stack for the struct
        set sh.sta                = Stack.create()
        return sh
    endmethod
endstruct

//Struct for holding data for the sound recycling
private struct soundrecycler
    timer   t       = null
    sound   s       = null
    integer sh      = 0
    boolean stopped = false //Only gets used if StopSound is called on a new sound
    
    static method create takes sound whichSound, integer soundRef returns soundrecycler
        local soundrecycler sr = soundrecycler.allocate()
        set sr.t       = NewTimer()
        set sr.s       = whichSound
        set sr.sh      = soundRef
        call SetTimerData(sr.t, integer(sr))
        
        //Hook the value to the soundRef and whichSound
        call SaveInteger(rt, soundRef, GetHandleId(whichSound), integer(sr))
        return sr
    endmethod
    private method onDestroy takes nothing returns nothing
        call RemoveSavedInteger(rt, .sh, GetHandleId(.s))
        call ReleaseTimer(.t)
    endmethod
endstruct

//******************************************************************************

private function HookStopSound takes sound soundHandle, boolean killWhenDone, boolean fadeOut returns nothing
    local integer       id       = GetHandleId(soundHandle)
    local integer       soundRef = 0
    local soundrecycler sr       = 0
    if HaveSavedInteger(ht, 0, id) then //Sound is from stacks
        set soundRef = LoadInteger(ht, 0, id)
        if HaveSavedInteger(rt, soundRef, id) then //Sound has a recycler
            set sr         = soundrecycler(LoadInteger(rt, soundRef, id))
            set sr.stopped = true
        endif
        if killWhenDone then
            debug call BJDebugMsg(SCOPE_PREFIX+"Warning: (StopSound) Destroying a sound in the stack")
        endif
    endif
endfunction

hook StopSound HookStopSound

private function HookKillSoundWhenDone takes sound soundHandle returns nothing
    if HaveSavedInteger(ht, 0, GetHandleId(soundHandle)) then
        call BJDebugMsg(SCOPE_PREFIX+"Warning: (KillSoundWhenDone) Destroying a sound in the stack")
    endif
endfunction

debug hook KillSoundWhenDone HookKillSoundWhenDone

//******************************************************************************

function DefineSoundEx takes string fileName, integer duration, boolean looping, boolean is3D, boolean stopwhenoutofrange, integer fadeInRate, integer fadeOutRate, string eaxSetting returns integer
    return integer(soundhelper.create(fileName, duration, looping, is3D, stopwhenoutofrange, fadeInRate, fadeOutRate, eaxSetting))
endfunction
function DefineSound takes string fileName, integer duration, boolean looping, boolean is3D returns integer
    return DefineSoundEx(fileName, duration, looping, is3D, true, 10, 10, "CombatSoundsEAX")
endfunction

function ReleaseSound takes sound s returns boolean
    local integer       id       = GetHandleId(s)
    local integer       soundRef = 0
    local soundhelper   sh       = 0
    local soundrecycler sr       = 0
    
    if s == null then
        debug call BJDebugMsg(SCOPE_PREFIX+"Error: Cannot recycle a null sound")
        return false
    elseif not HaveSavedInteger(ht, 0, id) then
        debug call BJDebugMsg(SCOPE_PREFIX+"Error: Cannot recycle a sound not allocated by RunSound")
        return false
    endif
    
    set soundRef = LoadInteger(ht, 0, id)
    set sh       = soundhelper(soundRef)
    
    call StopSound(s, false, true)             //Stop the sound
    call sh.sta.push(id)                       //Return it to the stack
    call SaveSoundHandle(st, soundRef, id,  s) //Save it to hashtable
    if not sh.looping then
        //soundrecycler only exists for non-looping sounds
        set sr = soundrecycler(LoadInteger(rt, soundRef, id))
        call sr.destroy()                      //Destroy recycler helper
    endif
    return true
endfunction

private function Recycle takes nothing returns nothing
    local soundrecycler sr = soundrecycler(GetTimerData(GetExpiredTimer()))
    local soundhelper   sh = soundhelper(sr.sh)
    local integer       id = GetHandleId(sr.s)
    
    call StopSound(sr.s, false, true)               //Stop the sound
    call sh.sta.push(id)                            //Return it to the stack
    call SaveSoundHandle(st, integer(sh), id, sr.s) //Save it to hashtable
    call sr.destroy()                               //Destroy recycler helper
endfunction

private function Run takes nothing returns nothing
    local soundrecycler sr = soundrecycler(GetTimerData(GetExpiredTimer()))
    local soundhelper   sh = soundhelper(sr.sh)
    
    if not sr.stopped then
        call StartSound(sr.s) //Play sound here
    endif
    if not sh.looping and not sr.stopped then
        call TimerStart(sr.t, sh.duration*0.001, false, function Recycle)
    else
        call sr.destroy()
    endif
endfunction

function RunSound takes integer soundRef returns sound
    local sound         s  = null
    local integer       i  = 0
    local soundhelper   sh = soundhelper(soundRef)
    local soundrecycler sr = 0
    
    if soundRef <= 0 then
        debug call BJDebugMsg(SCOPE_PREFIX+"Error: Cannot run sound of undefined type")
        return null
    endif
    //Check if the stack is empty
    if sh.sta.peek() == Stack.EMPTY then
        //Create a new sound for the stack
        set s = CreateSound(sh.fileName, sh.looping, sh.is3D, sh.stopwhenoutofrange, sh.fadeInRate, sh.fadeOutRate, sh.eaxSetting)
        //Attach the type to the sound for future reference
        call SaveInteger(ht, 0, GetHandleId(s), integer(sh))
        call SetSoundDuration(s, sh.duration)
        
        //Stuff that must be performed immediately upon creation of sounds
        call SetSoundChannel(s, 5)
        call SetSoundVolume(s, 127)
        call SetSoundPitch(s, 1.)
        if sh.is3D then
            //These are settings necessary for 3-D sounds to function properly
            //You can change them at will outside of this function
            call SetSoundDistances(s, 600., 10000.)
            call SetSoundDistanceCutoff(s, 3000.)
            call SetSoundConeAngles(s, 0., 0., 127)
            call SetSoundConeOrientation(s, 0., 0., 0.)
        endif
        
        //Start sound after a delay because it was created here
        set sr = soundrecycler.create(s, soundRef)
        call TimerStart(sr.t, 0.001, false, function Run)
    else
        //Allocate a sound from the stack
        set i = sh.sta.pop()
        if not HaveSavedHandle(st, soundRef, i) then
            debug call BJDebugMsg(SCOPE_PREFIX+"Error: No sound in given stack member")
            return null
        endif
        set s = LoadSoundHandle(st, soundRef, i)
        call RemoveSavedInteger(st, soundRef, i)
        call SetSoundVolume(s, 127) //Start volume at max
        
        //Start it here since it wasn't created here
        call StartSound(s)
        //Recycle the sound in a timer callback after it's finished if nonlooping
        if not sh.looping then
            set sr = soundrecycler.create(s, soundRef)
            call TimerStart(sr.t, sh.duration*0.001, false, function Recycle)
        endif
    endif
    return s
endfunction

function RunSoundOnUnit takes integer soundRef, unit whichUnit returns sound
    local sound s = RunSound(soundRef)
    call AttachSoundToUnit(s, whichUnit)
    return s
endfunction

function RunSoundAtPoint takes integer soundRef, real x, real y, real z returns sound
    local sound s = RunSound(soundRef)
    call SetSoundPosition(s, x, y, z)
    return s
endfunction

function RunSoundForPlayer takes integer soundRef, player p returns sound
    local sound s = RunSound(soundRef)
    if GetLocalPlayer() != p then
        call SetSoundVolume(s, 0)
    else
        call SetSoundVolume(s, 127)
    endif
    return s
endfunction
endlibrary

//TESH.scrollpos=285
//TESH.alwaysfold=0
library Stack

//*****************************************************************
//*  STACK
//*
//*  written by: Anitarf
//*
//*  This is an efficient implementation of a stack in vJass. Since
//*  it is based on a linked list, I decided to add common list
//*  methods to the data structure so it can function both as
//*  a stack and a simple linked list.
//*
//*  As a linked list, it has less functionality than Ammorth's
//*  LinkedList, but is considerably faster. Note only that most of
//*  the list methods have O(n) time complexity so they may not be
//*  suitable for operations on very large lists, however due to
//*  their simplicity the list would need to be really large for
//*  this to become a problem.
//*
//*  All stack methods are of course O(1) and as fast as possible.
//*  If you just need a stack, this is definitely the best choice.
//*
//*   set s=Stack.create()  - Instanceates a new Stack object.
//*   call s.destroy()      - Destroys the Stack.
//*
//*  Stack syntax:
//*   call s.push(123)      - Pushes the value 123 on the stack.
//*                           A stack may contain multiple
//*                           instances of the same value.
//*   set i=s.peek()        - Reads the top value of the stack
//*                           and stores it to the variable i.
//*   set i=s.pop()         - Removes the top value from the stack
//*                           and stores it to the variable i.
//*   s.peek()==Stack.EMPTY - Checks if the stack is empty.
//*
//*  List syntax:
//*   call s.add(123)       - Adds the value 123 to the list.
//*                           A list may contain multiple
//*                           instances of the same value.
//*   s.size                - The total number of values on the list.
//*   s.contains(123)       - Checks if the value 123 is on the list.
//*   set n=s.count(123)    - Stores the number of times the value
//*                           123 is on the list to the variable n.
//*   call s.remove(123)    - Removes one instance of the value 123
//*                           from the list. Returns false if
//*                           the value was not found on the list.
//*   call s.purge(123)     - Removes all instances of the value 123
//*                           from the list. Returns the number of
//*                           values that were removed.
//*   set i=s.first         - Reads the first value from the list
//*                           and stores it to the variable i.
//*   set i=s.random        - Reads a random value from the list
//*                           and stores it to the variable i.
//*   set s2=s.copy()       - Makes a copy of the list and stores
//*                           it to the variable s2.
//*   call s.enum(Func,b)   - Calls function Func for all values
//*                           on the list. The function must follow
//*                           the Enum function interface.
//*                           b is a boolean value, if it is true
//*                           then the values will be enumerated
//*                           top to bottom, if false then bottom
//*                           to top.
//*****************************************************************

    public function interface Enum takes integer value returns nothing

    struct Stack
        // Use a totally random number here, the more improbable someone uses it, the better.
        // This is the value that is returned by .pop and .peek methods and .first and .random operators when called on an empty stack.
        public static constant integer EMPTY=0x28829022

        // End of calibration.

        readonly integer size = 0
        private integer top = 0
        private static integer free = 1
        private static integer array next
        private static integer array value
        
        method push takes integer i returns nothing
            // Get an index from the list of free indexes.
            local integer n=Stack.free
            set Stack.free=Stack.next[n]
            // Extend the list of free indexes if needed.
            if Stack.free==0 then
                set Stack.free=n+1
            endif
            // Store the value to the index.
            set Stack.value[n]=i
            // Add index to the top of the stack.
            set Stack.next[n]=.top
            set .top=n
            set .size=.size+1
        endmethod
        method pop takes nothing returns integer
            // Get the top index of stack.
            local integer n=.top
            // Safety check in case a user pops an empty stack.
            if n==0 then
                debug call BJDebugMsg("stack warning: .pop called on an empty stack!")
                return Stack.EMPTY
            endif
            // Remove the top index from stack.
            set .top=Stack.next[n]
            set .size=.size-1
            // Add the index to the list of free indexes.
            set Stack.next[n]=Stack.free
            set Stack.free=n
            // Return the value.
            return Stack.value[n]
        endmethod
        method peek takes nothing returns integer
            // Read the value of the top index.
            return Stack.value[.top]
        endmethod


        method add takes integer value returns nothing
            call .push(value)
        endmethod
        method contains takes integer value returns boolean
            // Get the first index of the list.
            local integer i=.top
            // Search through the list.
            loop
                // Stop the search when the end of the list is reached.
                exitwhen i==0
                // Stop the search if the value is found.
                if Stack.value[i]==value then
                    return true
                endif
                // Get the next index of the list.
                set i=Stack.next[i]
            endloop
            return false
        endmethod
        method count takes integer value returns integer
            local integer count=0
            // Get the first index of the list.
            local integer i=.top
            // Search through the list.
            loop
                // Stop the search when the end of the list is reached.
                exitwhen i==0
                // Increase the count if the value is found.
                if Stack.value[i]==value then
                    set count=count+1
                endif
                // Get the next index of the list.
                set i=Stack.next[i]
            endloop
            return count
        endmethod
        method operator first takes nothing returns integer
            return .peek()
        endmethod
        method operator random takes nothing returns integer
            local integer r=GetRandomInt(1,.size)
            // Get the first index of the list.
            local integer i=.top
            // Loop through the list.
            loop
                // Stop the loop after a random amount of repeats.
                set r=r-1
                exitwhen r==0 or i==0
                // Get the next index of the list.
                set i=Stack.next[i]
            endloop
            return Stack.value[i]
        endmethod
        method remove takes integer value returns boolean
            // Get the first index of the list.
            local integer i1=.top
            local integer i2
            // Check if the first index holds the value.
            if Stack.value[i1]==value then
                call .pop()
                return true
            endif
            // Search through the rest of the list.
            loop
                set i2=Stack.next[i1]
                // Stop the search when the end of the list is reached.
                exitwhen i2==0
                // Check if the next index holds the value.
                if Stack.value[i2]==value then
                    // Remove the index from the stack.
                    set Stack.next[i1]=Stack.next[i2]
                    // Add the removed index to the list of free indexes.
                    set Stack.next[i2]=Stack.free
                    set Stack.free=i2
                    set .size=.size-1
                    return true
                endif
                set i1=i2
            endloop
            return false
        endmethod
        method purge takes integer value returns integer
            local integer count=0
            local integer i1
            local integer i2
            // If the first index holds the value, pop it.
            loop
                // If the list is empty, return.
                if .top==0 then
                    return count
                endif
                // Repeat until the first index doesn't hold the value.
                exitwhen Stack.value[.top]!=value
                call .pop()
                set count=count+1
            endloop
            // Get the first index of the list.
            set i1=.top
            // Search through the rest of the list.
            loop
                set i2=Stack.next[i1]
                // Stop the search when the end of the list is reached.
                exitwhen i2==0
                // Check if the next index holds the value.
                if Stack.value[i2]==value then
                    // Remove the index from the stack.
                    set Stack.next[i1]=Stack.next[i2]
                    // Add the removed index to the list of free indexes.
                    set Stack.next[i2]=Stack.free
                    set Stack.free=i2
                    set .size=.size-1
                    set count=count+1
                else
                    set i1=i2
                endif
            endloop
            return count
        endmethod
        method enum takes Enum f, boolean top2bottom returns nothing
            local integer array value
            // Get the first index of the list.
            local integer i1=.top
            local integer i2=0
            // Populate the array.
            loop
                exitwhen i1==0
                set value[i2]=Stack.value[i1]
                set i2=i2+1
                set i1=Stack.next[i1]
            endloop
            // Call the Enum function for each value in the array.
            set i1=i2-1
            loop
                exitwhen i2==0
                set i2=i2-1
                // Enumerate in which direction?
                if top2bottom then
                    call f.evaluate(value[i1-i2])
                else
                    call f.evaluate(value[i2])
                endif
            endloop
        endmethod
        method copy takes nothing returns Stack
            local Stack that=Stack.create()
            // Get the first index of the list.
            local integer i1=.top
            local integer i2
            // Add a dummy index to the top of the new list.
            call that.push(0)
            set i2=that.top
            loop
                exitwhen i1==0
                // Get an index from the list of free indexes and add it at the end of the list.
                set Stack.next[i2]=Stack.free
                set i2=Stack.next[i2]
                set Stack.free=Stack.next[i2]
                // Extend the list of free indexes if needed.
                if Stack.free==0 then
                    set Stack.free=i2+1
                endif
                // Copy the value to the new index.
                set Stack.value[i2]=Stack.value[i1]
                set i1=Stack.next[i1]
            endloop
            // End the new list correctly.
            set Stack.next[i2]=0
            // Remove the dummy index.
            call that.pop()
            // Copy the size value to the new list.
            set that.size=this.size
            return that
        endmethod


        method onDestroy takes nothing returns nothing
            local integer n
            // Remove all remaining indexes from the stack.
            loop
                // Get the top index.
                set n=.top
                exitwhen n==0
                // Remove it from the stack.
                set .top=Stack.next[n]
                // Add it to the list of free indexes.
                set Stack.next[n]=Stack.free
                set Stack.free=n
            endloop
        endmethod
        static method onInit takes nothing returns nothing
            // Store the EMPTY value to index 0 to make .peek inline friendly.
            set Stack.value[0]=Stack.EMPTY
        endmethod
    endstruct
endlibrary

//TESH.scrollpos=22
//TESH.alwaysfold=0
library Table
//***************************************************************
//* Table object 3.0
//* ------------
//*
//*   set t=Table.create() - instanceates a new table object
//*   call t.destroy()     - destroys it
//*   t[1234567]           - Get value for key 1234567
//*                          (zero if not assigned previously)
//*   set t[12341]=32      - Assigning it.
//*   call t.flush(12341)  - Flushes the stored value, so it
//*                          doesn't use any more memory
//*   t.exists(32)         - Was key 32 assigned? Notice
//*                          that flush() unassigns values.
//*   call t.reset()       - Flushes the whole contents of the
//*                          Table.
//*
//*   call t.destroy()     - Does reset() and also recycles the id.
//*
//*   If you use HandleTable instead of Table, it is the same
//* but it uses handles as keys, the same with StringTable.
//*
//*  You can use Table on structs' onInit  if the struct is
//* placed in a library that requires Table or outside a library.
//*
//*  You can also do 2D array syntax if you want to touch
//* mission keys directly, however, since this is shared space
//* you may want to prefix your mission keys accordingly:
//*
//*  set Table["thisstring"][ 7 ] = 2
//*  set Table["thisstring"][ 5 ] = Table["thisstring"][7]
//*
//***************************************************************

//=============================================================
    globals
        private constant integer MAX_INSTANCES=8100 //400000
        //Feel free to change max instances if necessary, it will only affect allocation
        //speed which shouldn't matter that much.

    //=========================================================
        private hashtable ht
    endglobals

    private struct GTable[MAX_INSTANCES]

        method reset takes nothing returns nothing
            call FlushChildHashtable(ht, integer(this) )
        endmethod

        private method onDestroy takes nothing returns nothing
            call this.reset()
        endmethod

        //=============================================================
        // initialize it all.
        //
        private static method onInit takes nothing returns nothing
            set ht = InitHashtable()
        endmethod

    endstruct

    //Hey: Don't instanciate other people's textmacros that you are not supposed to, thanks.
    //! textmacro Table__make takes name, type, key
    struct $name$ extends GTable

        method operator [] takes $type$ key returns integer
            return LoadInteger(ht, integer(this), $key$)
        endmethod

        method operator []= takes $type$ key, integer value returns nothing
            call SaveInteger(ht,  integer(this)  ,$key$, value)
        endmethod

        method flush takes $type$ key returns nothing
            call RemoveSavedInteger(ht, integer(this), $key$)
        endmethod

        method exists takes $type$ key returns boolean
            return HaveSavedInteger( ht,  integer(this)  ,$key$)
        endmethod

        static method flush2D takes string firstkey returns nothing
            call $name$(- StringHash(firstkey)).reset()
        endmethod

        static method operator [] takes string firstkey returns $name$
            return $name$(- StringHash(firstkey) )
        endmethod

    endstruct
    //! endtextmacro

    //! runtextmacro Table__make("Table","integer","key" )
    //! runtextmacro Table__make("StringTable","string", "StringHash(key)" )
    //! runtextmacro Table__make("HandleTable","handle","GetHandleId(key)" )

endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library TimerUtils initializer init
//*********************************************************************
//* TimerUtils (red+blue+orange flavors for 1.24b+)
//* ----------
//*
//*  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)
//* 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.
    endglobals

    //==========================================================================================
    function NewTimer takes nothing returns timer
        if (tN==0) then
            //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")
            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")
                set tT[0]=CreateTimer()
                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
        else
            set tN=tN-1
        endif
        call SetTimerData(tT[tN],0)
     return tT[tN]
    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
     
        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 xebasic
//**************************************************************************
//
// xebasic 0.4
// =======
// XE_DUMMY_UNITID : Rawcode of the dummy unit in your map. It should
//                   use the dummy.mdx model, so remember to import it as
//                   well, just use copy&paste to copy the dummy from the
//                   xe map to yours, then change the rawcode.
//
// XE_HEIGHT_ENABLER: Medivh's raven form ability, you may need to change
//                    this rawcode to another spell that morphs into a flier
//                    in case you modified medivh's spell in your map.
//
// XE_TREE_RECOGNITION: The ancients' Eat tree ability, same as with medivh
//                      raven form, you might have to change it.
//
// XE_ANIMATION_PERIOD: The global period of animation used by whatever
//                      timer that depends on it, if you put a low value
//                      the movement will look good but it may hurt your
//                      performance, if instead you use a high value it
//                      will not lag but will be fast.
//
// XE_MAX_COLLISION_SIZE: The maximum unit collision size in your map, if
//                        you got a unit bigger than 197.0 it would be
//                        a good idea to update this constant, since some
//                        enums will not find it. Likewise, if none of
//                        your units can go bellow X and X is much smaller
//                        than 197.0, it would be a good idea to update
//                        as well, since it will improve the performance
//                        those enums.
//
// Notice you probably don't have to update this library, unless I specify
// there are new constants which would be unlikely. 
//
//**************************************************************************

//===========================================================================
globals
   constant integer XE_DUMMY_UNITID       = 'e000'
   constant integer XE_HEIGHT_ENABLER     = 'Amrf'
   constant integer XE_TREE_RECOGNITION   = 'Aeat'
   constant real    XE_ANIMATION_PERIOD   =  0.025
   constant real    XE_MAX_COLLISION_SIZE =  197.0
endglobals

endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library xefx initializer init requires xebasic
//**************************************************
// xefx 0.7
// --------
//  Recommended: ARGB (adds ARGBrecolor method)
//  For your movable fx needs
//
//**************************************************

//==================================================
 globals
    private constant integer MAX_INSTANCES = 8190 //change accordingly.
    private constant real    RECYCLE_DELAY = 4.0

    //recycling, in order to show the effect correctly, must wait some time before
    //removing the unit.
    private timer    recycler
    private timer    NOW

 endglobals

   private struct recyclebin extends array
       unit u
       real schedule
       static recyclebin end=0
       static recyclebin begin=0

       static method Recycle takes nothing returns nothing
            call RemoveUnit(.begin.u) //this unit is private, systems shouldn't mess with it.
            set .begin.u=null
            set .begin=recyclebin(integer(.begin)+1)
            if(.begin==.end) then
                set .begin=0
                set .end=0
            else
                call TimerStart(recycler, .begin.schedule-TimerGetElapsed(NOW), false, function recyclebin.Recycle)
            endif

       endmethod
   endstruct

   private function init takes nothing returns nothing
       set recycler=CreateTimer()
       set NOW=CreateTimer()
       call TimerStart(NOW,43200,true,null)
   endfunction

   struct xefx[MAX_INSTANCES]
       public integer tag=0
       private unit   dummy
       private effect fx=null
       private real   zang=0.0
       private integer r=255
       private integer g=255
       private integer b=255
       private integer a=255

       private integer abil=0

       static method create takes real x, real y, real facing returns xefx
        local xefx this=xefx.allocate()
           set this.dummy= CreateUnit(Player(15), XE_DUMMY_UNITID, x,y, facing*bj_RADTODEG)
           call UnitAddAbility(this.dummy,XE_HEIGHT_ENABLER)
           call UnitAddAbility(this.dummy,'Aloc')
           call UnitRemoveAbility(this.dummy,XE_HEIGHT_ENABLER)
           call SetUnitX(this.dummy,x)
           call SetUnitY(this.dummy,y)
        return this
       endmethod

       method operator owner takes nothing returns player
           return GetOwningPlayer(this.dummy)
       endmethod

       method operator owner= takes player p returns nothing
           call SetUnitOwner(this.dummy,p,false)
       endmethod

       method operator teamcolor= takes playercolor c returns nothing
           call SetUnitColor(this.dummy,c)
       endmethod

       method operator scale= takes real value returns nothing
           call SetUnitScale(this.dummy,value,value,value)
       endmethod

       //! textmacro XEFX_colorstuff takes colorname, colorvar
       method operator $colorname$ takes nothing returns integer
           return this.$colorvar$
       endmethod
       method operator $colorname$= takes integer value returns nothing
           set this.$colorvar$=value
           call SetUnitVertexColor(this.dummy,this.r,this.g,this.b,this.a)
       endmethod
       //! endtextmacro
       //! runtextmacro XEFX_colorstuff("red","r")
       //! runtextmacro XEFX_colorstuff("green","g")
       //! runtextmacro XEFX_colorstuff("blue","b")
       //! runtextmacro XEFX_colorstuff("alpha","a")

       method recolor takes integer r, integer g , integer b, integer a returns nothing
           set this.r=r
           set this.g=g
           set this.b=b
           set this.a=a
           call SetUnitVertexColor(this.dummy,this.r,this.g,this.b,this.a)
       endmethod

       implement optional ARGBrecolor

       method operator abilityid takes nothing returns integer
           return this.abil
       endmethod

       method operator abilityid= takes integer a returns nothing
           if(this.abil!=0) then
               call UnitRemoveAbility(this.dummy,this.abil)
           endif

           if(a!=0) then
               call UnitAddAbility(this.dummy,a)
           endif
           set this.abil=a
       endmethod
       
       method operator abilityLevel takes nothing returns integer
           return GetUnitAbilityLevel( this.dummy, this.abil)
       endmethod
       
       method operator abilityLevel= takes integer newLevel returns nothing
           call SetUnitAbilityLevel(this.dummy, this.abil, newLevel)
       endmethod

       method flash takes string fx returns nothing
           call DestroyEffect(AddSpecialEffectTarget(fx,this.dummy,"origin"))
       endmethod

       method operator xyangle takes nothing returns real
           return GetUnitFacing(this.dummy)*bj_DEGTORAD
       endmethod
       method operator xyangle= takes real value returns nothing
           call SetUnitFacing(this.dummy,value*bj_RADTODEG)
       endmethod

       method operator zangle takes nothing returns real
           return this.zang
       endmethod

       method operator zangle= takes real value returns nothing
        local integer i=R2I(value*bj_RADTODEG+90.5)
           set this.zang=value
           if(i>=180) then
               set i=179
           elseif(i<0) then
               set i=0
           endif
               
           call SetUnitAnimationByIndex(this.dummy, i  )
       endmethod


       method operator x takes nothing returns real
           return GetUnitX(this.dummy)
       endmethod
       method operator y takes nothing returns real
           return GetUnitY(this.dummy)
       endmethod
       method operator z takes nothing returns real
           return GetUnitFlyHeight(this.dummy)
       endmethod

       method operator z= takes real value returns nothing
           call SetUnitFlyHeight(this.dummy,value,0)
       endmethod

       method operator x= takes real value returns nothing
           call SetUnitX(this.dummy,value)
       endmethod

       method operator y= takes real value returns nothing
           call SetUnitY(this.dummy,value)
       endmethod

       method operator fxpath= takes string newpath returns nothing
           if (this.fx!=null) then
               call DestroyEffect(this.fx)
           endif
           if (newpath=="") then
               set this.fx=null
           else
               set this.fx=AddSpecialEffectTarget(newpath,this.dummy,"origin")
           endif

       endmethod
       
       method hiddenReset takes string newfxpath, real newfacing returns nothing
        local real x = GetUnitX(this.dummy)
        local real y = GetUnitY(this.dummy)
        local real z = this.z
        local real za = this.zangle
        local integer level = this.abilityLevel
           set fxpath=null
           call RemoveUnit(this.dummy)
           set this.dummy= CreateUnit(Player(15), XE_DUMMY_UNITID, x,y, newfacing*bj_RADTODEG)
           if(level != 0) then
               call UnitAddAbility(this.dummy, abilityid) 
           endif
           call UnitAddAbility(this.dummy,XE_HEIGHT_ENABLER)
           call UnitAddAbility(this.dummy,'Aloc')
           call UnitRemoveAbility(this.dummy,XE_HEIGHT_ENABLER)
           call SetUnitX(this.dummy,x)
           call SetUnitY(this.dummy,y)
           set this.z = z
           set zangle = za
       endmethod
       
 
       private method onDestroy takes nothing returns nothing
           if(this.abil!=0) then
               call UnitRemoveAbility(this.dummy,this.abil)
           endif
           if(this.fx!=null) then
               call DestroyEffect(this.fx)
               set this.fx=null
           endif
           if (recyclebin.end==MAX_INSTANCES) then
               //I'd like to see this happen...
               call TimerStart(recycler,0,false,function recyclebin.Recycle)
               call ExplodeUnitBJ(this.dummy)
           else
               set recyclebin.end.u=this.dummy
               set recyclebin.end.schedule=TimerGetElapsed(NOW)+RECYCLE_DELAY
               set recyclebin.end= recyclebin( integer(recyclebin.end)+1)
               if( recyclebin.end==1) then
                   call TimerStart(recycler, RECYCLE_DELAY, false, function recyclebin.Recycle)
               endif
               call SetUnitOwner(this.dummy,Player(15),false)
           endif
           set this.dummy=null
       endmethod

       method hiddenDestroy takes nothing returns nothing           
           call ShowUnit(dummy,false)
           call destroy()
       endmethod
       
   endstruct

endlibrary

//TESH.scrollpos=35
//TESH.alwaysfold=0
library xecast initializer init requires xebasic
//******************************************************************************
// xecast 0.7
// ------
//  Because dummy casters REALLY ARE this complicated!
//
//******************************************************************************

//==============================================================================
 globals
    private constant integer MAXINSTANCES         = 8190
    //this is a lot, unless you leak xecast objects (which is a bad thing)
    
    private constant integer INITIAL_DUMMY_COUNT  = 12
    
    //don't allow to keep more than DUMMY_STACK_LIMIT innactive dummy units :
    private constant integer DUMMY_STACK_LIMIT    = 50
    
    // If your map does not give visibility to all players, or
    // for other reasons, you might want xecast to work on
    // units that are not visible to the player, in that case
    // change this to true, else it is just a performance loss.
    private constant boolean FORCE_INVISIBLE_CAST = false

    //When AUTO_RESET_MANA_COOLDOWN is set to true, xecast will reset
    // the dummy unit's cooldown and mana before casting every spell.
    // it is a performance penalty, so if you are sure that all dummy spells
    // in your map got 0 mana and cooldown cost, you may set it to false.    
    private constant boolean AUTO_RESET_MANA_COOLDOWN = true 
 endglobals

//=========================================================================
// Please notice all textmacros in this library are considered private.
//  in other words: DON'T RUN THOSE TEXTMACROS!
//
private keyword structinit

globals
    private real EPSILON=0.001 //noticed in war3 this is the sort of precision we want...
endglobals

struct xecast[MAXINSTANCES]

    public integer abilityid    = 0    //ID (rawcode) of the ability to cast
    public integer level        = 1    //Level of the ability to cast

    public real    recycledelay = 0.0  //Please notice, some spells need a recycle delay
                                       // This is, a time period before they get recycle.
                                       // For example, some spells are not instant, there is
                                       // also the problem with damaging spells, this recycle
                                       // delay must be large enough to contain all the time
                                       // in which the spell can do damage.


    public player  owningplayer=Player(15)  //which player to credit for the ability cast?
                                            //notice this can also affect what units are targeteable

    //==================================================================================================
    // You need an order id for the ability so the dummy unit is able to cast it, two ways to assign it
    //   set instance.orderid     = 288883            //would assign an integer orderid
    //   set instance.orderstring = "chainlightning"  //would assign an orderstring
    //                                                 (as those in the object editor)
    //
    method operator orderid= takes integer v returns nothing 
        set .oid=v
    endmethod
    method operator orderstring= takes string s returns nothing
        set .oid=OrderId(s)
    endmethod

    //=================================================================================================
    // Finally, you can determine from which point to cast the ability: z is the height coordinate.
    //
    public boolean customsource=false //Use a custom casting source?

    public real    sourcex     // Determine the casting source for the dummy spell, require customsource =true
    public real    sourcey     // You might prefer to use the setSourcePoint method
    public real    sourcez=0.0 //

    method setSourcePoint takes real x, real y, real z returns nothing
       set .sourcex=x
       set .sourcey=y
       set .sourcez=z
       set .customsource=true
    endmethod

    method setSourceLoc takes  location loc, real z returns nothing
       set .sourcex=GetLocationX(loc)
       set .sourcey=GetLocationY(loc)
       set .sourcez=z
       set .customsource=true
    endmethod


    private boolean autodestroy  = false
    //========================================================================================================
    // you are always allowed to use .create() but you can also use createBasic which sets some things that
    // are usually necessary up.
    //
    public static method createBasic takes integer abilityID, integer orderid, player owner returns xecast
     local xecast r=xecast.allocate()
        if(r==0) then
            debug call BJDebugMsg("Warning: unbelievable but you actually used all xecast instances in your map! Please make sure you are not forgetting to destroy those what you create intensively, if that's not the case, then you'll have to increase xecast MAXINSTANCES")
        endif
        set r.oid=orderid
        set r.abilityid=abilityID
        set r.owningplayer=owner
     return r
    endmethod

    //========================================================================================================
    // Just like the above one, but the instance will self destruct after a call to any cast method
    // (recommended)
    //
    public static method createBasicA takes integer abilityID, integer orderid, player owner returns xecast
     local xecast r=xecast.allocate()
        if(r==0) then
            debug call BJDebugMsg("Warning: unbelievable but you actually used all xecast instances in your map! Please make sure you are not forgetting to destroy those what you create intensively, if that's not the case, then you'll have to increase xecast MAXINSTANCES")
        endif
        set r.oid=orderid
        set r.abilityid=abilityID
        set r.owningplayer=owner
        set r.autodestroy=true
     return r
    endmethod

    //==========================================================================================================
    // Just like create, but the struct instance self destructs after a call to any cast method
    // (Recommended)
    //
    public static method createA takes nothing returns xecast
     local xecast r=xecast.allocate()
        set r.autodestroy=true
     return r
    endmethod

    //==========================================================================================================
    // So, create the dummy, assign options and cast the skill!
    // .castOnTarget(w)       : If you want to hit a widget w with the ability
    // .castOnPoint(x,y)      : If you want to hit a point (x,y) with the ability
    // .castInPoint(x,y)      : For spells like warstomp which do not have a target.
    // .castOnAOE(x,y,radius) : Classic area of effect cast. Considers collision size
    // .castOnGroup(g)        : Cast unit the unit group g, notice it will empty the group yet not destroy it.
    //

    //**********************************************************************************************************
    // The implementation of such methods follows: 

    private static  unit array dummystack
    private static  integer    top=0
    private static  unit       instantdummy

    private integer oid=0

    private static timer       gametime
    private static timer       T
    private static unit array  recycle
    private static real array  expiretime
    private static integer     rn=0

    //==========================================================================================================
    // private dorecycle method, sorry but I need this up here.
    //
    private static method dorecycle takes nothing returns nothing
     local unit u =.recycle[0]
     local integer l
     local integer r
     local integer p
     local real    lt
        call UnitRemoveAbility(u,GetUnitUserData(u))
        call SetUnitUserData(u,0)
        call SetUnitFlyHeight(u,0,0)
        call PauseUnit(u,false)
        if(.top==DUMMY_STACK_LIMIT) then
            call RemoveUnit(u)
        else
            set .dummystack[.top]=u
            set .top=.top+1
        endif
        set .rn=.rn-1
        if(.rn==0) then
            return
        endif
        set p=0
        set lt=.expiretime[.rn]
        loop
            set l=p*2+1
            exitwhen l>=.rn
            set r=p*2+2
            if(r>=.rn)then
                if(.expiretime[l]<lt) then
                    set .expiretime[p]=.expiretime[l]
                    set .recycle[p]=.recycle[l]
                    set p=l
                else
                    exitwhen true
                endif
            elseif (lt<=.expiretime[l]) and (lt<=.expiretime[r]) then
                exitwhen true
            elseif (.expiretime[l]<.expiretime[r]) then
                set .expiretime[p]=.expiretime[l]
                set .recycle[p]=.recycle[l]
                set p=l
            else
                set .expiretime[p]=.expiretime[r]
                set .recycle[p]=.recycle[r]
                set p=r
            endif
        endloop
        set .recycle[p]=.recycle[.rn]
        set .expiretime[p]=lt
        call TimerStart(.T, .expiretime[0]-TimerGetElapsed(.gametime), false, function xecast.dorecycle)
    endmethod

    private static trigger abilityRemove


    // Repetitive process and no inline implemented for large functions, so for now it is a textmacro:
    //! textmacro xecast_allocdummy
        if(.recycledelay<EPSILON) then
            set dummy=.instantdummy
            call SetUnitOwner(dummy,.owningplayer,false)
        elseif (.top>0) then
            set .top=.top-1
            set dummy=.dummystack[.top]
            call SetUnitOwner(dummy,.owningplayer,false)
        else
            set dummy=CreateUnit(.owningplayer,XE_DUMMY_UNITID,0,0,0)
            call TriggerRegisterUnitEvent(.abilityRemove,dummy,EVENT_UNIT_SPELL_ENDCAST)
            call UnitAddAbility(dummy,'Aloc')
            call UnitAddAbility(dummy,XE_HEIGHT_ENABLER)
            call UnitRemoveAbility(dummy,XE_HEIGHT_ENABLER)
        endif
        call UnitAddAbility(dummy, abilityid)
        static if AUTO_RESET_MANA_COOLDOWN then
            call UnitResetCooldown(dummy)
            call SetUnitState(dummy, UNIT_STATE_MANA, 10000.0)
        endif
        if(level>1) then
            call SetUnitAbilityLevel(dummy, abilityid, level)
        endif
    //! endtextmacro
    private static integer cparent
    private static integer current
    private static real    cexpire
    //! textmacro xecast_deallocdummy
        if(.recycledelay>=EPSILON) then
            set .cexpire=TimerGetElapsed(.gametime)+.recycledelay
            set .current=.rn
            set .rn=.rn+1
            loop
                exitwhen (.current==0)
                set .cparent=(.current-1)/2
                exitwhen (.expiretime[.cparent]<=.cexpire)
                set .recycle[.current]=.recycle[.cparent]
                set .expiretime[.current]=.expiretime[.cparent]
                set .current=.cparent
            endloop
            set .expiretime[.current]=.cexpire
            set .recycle[.current]=dummy
            call SetUnitUserData(dummy,.abilityid)
            call TimerStart(.T, .expiretime[0]-TimerGetElapsed(.gametime), false, function xecast.dorecycle)
        else
            call SetUnitUserData(dummy,0)
            call SetUnitFlyHeight(dummy,0,0)
            call UnitRemoveAbility(dummy,.abilityid)
        endif
    //! endtextmacro

    method castOnTarget takes unit target returns nothing
     local unit dummy
     local unit tar
        //! runtextmacro xecast_allocdummy()
        if (.customsource) then
            call SetUnitX(dummy,.sourcex)
            call SetUnitY(dummy,.sourcey)
            call SetUnitFlyHeight(dummy,.sourcez,0.0)
        else
            call SetUnitX(dummy,GetWidgetX(target))
            call SetUnitY(dummy,GetWidgetY(target))
        endif
        if (FORCE_INVISIBLE_CAST) then
            call UnitShareVision(target, .owningplayer, true)
            call IssueTargetOrderById(dummy,this.oid,target)
            call UnitShareVision(target, .owningplayer, false)
        else
            call IssueTargetOrderById(dummy,this.oid,target)
        endif

        //! runtextmacro xecast_deallocdummy()
        if(.autodestroy ) then
            call this.destroy()
        endif
    endmethod

    //accepts units, items and destructables, if you know it is
    // a unit it is better to use castOnTarget since that would
    // be able to use FORCE_INVISIBLE_CAST if necessary.
    //
    method castOnWidgetTarget takes widget target returns nothing
     local unit dummy
     local unit tar
        //! runtextmacro xecast_allocdummy()
        if (.customsource) then
            call SetUnitX(dummy,.sourcex)
            call SetUnitY(dummy,.sourcey)
            call SetUnitFlyHeight(dummy,.sourcez,0.0)
        else
            call SetUnitX(dummy,GetWidgetX(target))
            call SetUnitY(dummy,GetWidgetY(target))
        endif
        call IssueTargetOrderById(dummy,this.oid,target)

        //! runtextmacro xecast_deallocdummy()
        if(.autodestroy ) then
            call this.destroy()
        endif
    endmethod



    method castOnPoint takes real x, real y returns nothing
     local unit dummy
        //! runtextmacro xecast_allocdummy()
        if (.customsource) then
            call SetUnitX(dummy,.sourcex)
            call SetUnitY(dummy,.sourcey)
            call SetUnitFlyHeight(dummy,.sourcez,0.0)
        else
            call SetUnitX(dummy,x)
            call SetUnitY(dummy,y)
        endif
        call IssuePointOrderById(dummy,this.oid,x,y)
        //! runtextmacro xecast_deallocdummy()
        if(.autodestroy ) then
            call this.destroy()
        endif
    endmethod
    method castOnLoc takes location loc returns nothing
        //debug call BJDebugMsg("Warning: Locations are in use")
        //nah but I should 
        call .castOnPoint(GetLocationX(loc),GetLocationY(loc))
    endmethod

    //ignores custom source x and y (for obvious reasons)
    method castInPoint takes real x, real y returns nothing
     local unit dummy
        //! runtextmacro xecast_allocdummy()
        if (.customsource) then
            call SetUnitFlyHeight(dummy,.sourcez,0.0)
        endif
        call SetUnitX(dummy, x)
        call SetUnitY(dummy, y)
        call IssueImmediateOrderById(dummy,this.oid)
        //! runtextmacro xecast_deallocdummy()
        if(.autodestroy ) then
            call this.destroy()
        endif
    endmethod
    method castInLoc takes location loc returns nothing
        //debug call BJDebugMsg("Warning: Locations are in use")
        //nah but I should 
        call .castInPoint(GetLocationX(loc),GetLocationY(loc))
    endmethod


    //===================================================================================================
    // For method castOnAOE:
    //
    private static group    enumgroup
    private static real     aoex
    private static real     aoey
    private static real     aoeradius
    private static xecast   cinstance
    private static boolexpr aoefunc

    // Might look wrong, but this is the way to make it consider collision size, a spell that
    // got a target circle and uses this method will let the user know which units it will
    // hit with the mass cast.
    static method filterAOE takes nothing returns boolean
     local unit u=GetFilterUnit()
        if IsUnitInRangeXY(u, .aoex, .aoey, .aoeradius) then
            call .cinstance.castOnTarget(u)
        endif
     set u=null
     return false
    endmethod

    //
    method castOnAOE takes real x, real y, real radius returns nothing
     local boolean ad=this.autodestroy

        if(ad) then
            set this.autodestroy=false
        endif
        set .aoex=x
        set .aoey=y
        set .aoeradius=radius
        set .cinstance=this
        call GroupEnumUnitsInRange(.enumgroup,x,y,radius + XE_MAX_COLLISION_SIZE , .aoefunc)
        if(ad) then
            call this.destroy()
        endif
    endmethod

    method castOnAOELoc takes location loc,real radius returns nothing
        call .castOnAOE(GetLocationX(loc),GetLocationY(loc),radius)
    endmethod

    //==================================================================================================
    // A quick and dirt castOnGroup method, perhaps it'll later have castOntarget inlined, but not now
    //
    method castOnGroup takes group g returns nothing
     local boolean ad=this.autodestroy    
     local unit t
        if(ad) then
            set this.autodestroy=false
        endif

        loop
            set t=FirstOfGroup(g)
            exitwhen(t==null)
            call GroupRemoveUnit(g,t)
            call .castOnTarget(t)
        endloop
        if(ad) then
            call this.destroy()
        endif
    endmethod

    private static method removeAbility takes nothing returns boolean
     local unit u=GetTriggerUnit()
         if(GetUnitUserData(u)!=0) then
             call PauseUnit(u,true)
         endif
        //This is necessary, picture a value for recycle delay that's higher than the casting time,
        //for example if the spell does dps, if you leave the dummy caster with the ability and it 
        //is owned by an AI player it will start casting the ability on player units, so it is
        // a good idea to pause it...

     set u=null
     return true
    endmethod

    //===================================================================================================
    // structinit is a scope private keyword.
    //
    static method structinit takes nothing returns nothing
     local integer i=INITIAL_DUMMY_COUNT+1
     local unit u
        set .aoefunc=Condition(function xecast.filterAOE)
        set .enumgroup=CreateGroup()
        set .abilityRemove = CreateTrigger()
        loop
            exitwhen (i==0)
            set u=CreateUnit(Player(15),XE_DUMMY_UNITID,0,0,0)
            call TriggerRegisterUnitEvent(.abilityRemove,u,EVENT_UNIT_SPELL_ENDCAST)
            call UnitAddAbility(u,'Aloc')
            call UnitAddAbility(u,XE_HEIGHT_ENABLER)
            call UnitRemoveAbility(u,XE_HEIGHT_ENABLER)
            set .dummystack[.top]=u
            set .top=.top+1
            set i=i-1
        endloop
        call TriggerAddCondition(.abilityRemove, Condition(function xecast.removeAbility ) )
        set .top=.top-1
        set .instantdummy=.dummystack[.top]
        set .T=CreateTimer()
        set .gametime=CreateTimer()
        call TimerStart(.gametime,12*60*60,false,null)
    endmethod


endstruct


private function init takes nothing returns nothing
    call xecast.structinit()
endfunction

endlibrary

//TESH.scrollpos=548
//TESH.alwaysfold=0
library xedamage initializer init requires xebasic
//************************************************************************
// xedamage 0.8
// --------
//  For all your damage and targetting needs.
//
//************************************************************************

//===========================================================================================================
    globals
        private constant integer   MAX_SUB_OPTIONS = 3
        
        private constant real      FACTOR_TEST_DAMAGE = 0.01 
        // a low damage to do on units to test their damage factors for specific
        // attacktype/damagetype combos.
        // You'll need something as high as 20.0 to make it work well with armor resistances.
        // (Yes, you read it correctly, 20 ...
        //
        // If you use such a large value, there may be conflicts with some things relying on damage
        // (ie they are not away of the isDummyDamage tag that xedamage posseses.) which may be quite bad if you think about it...
        // then maybe it is better to change it to 0.01 ... then will work fine, just fine - but it will generally ignore armor - 
        // I am leaving it as 0.01 by default, because honestly, I'd rather make it ignore armor than have a lot of people sending me
        // rants about how they detect 20.0 damage where none is visible...
        private constant real      MAX_DAMAGE_FACTOR = 3.00
        // The maximum damage factor in the map. I think 3 is fine.
       

        //=======================================================
        private constant real      EPSILON = 0.000000001
        private unit     dmger
        private constant integer   MAX_SPACE = 8190 // MAX_SPACE/MAX_SUB_OPTIONS is the instance limit for xedamage, usually big enough...
    endglobals

    private keyword structInit

    struct xedamage[MAX_SPACE]

        //----
        // fields and methods for a xedamage object, they aid determining valid targets and special
        // damage factor conditions.
        //
        // Notice the default values.
        //
        boolean damageSelf    = false  // the damage and factor methods  usually have a source unit parameter
                                       // xedamage would consider this unit as immune unless you set damageSelf to true

        boolean damageAllies  = false  // Alliance dependent target options.
        boolean damageEnemies = true   // *
        boolean damageNeutral = true   // *
        boolean ranged        = true   // Is the attack ranged? This has some effect on the AI of the affected units
                                       // true by default, you may not really need to modify this.

        boolean visibleOnly   = false  // Should only units that are visible for source unit's owner be affected?
        boolean deadOnly      = false  // Should only corpses be affected by "the damage"? (useful when using xedamage as a target selector)
        boolean alsoDead      = false  // Should even corpses and alive units be considered?

        boolean damageTrees   = false  //Also damage destructables? Notice this is used only in certain methods.
                                       //AOE for example targets a circle, so it can affect the destructables
                                       //in that circle, a custom spell using xedamage for targetting configuration
                                       //could also have an if-then-else implemented so it can verify if it is true
                                       //then affect trees manually.

        //
        // Damage type stuff:
        //    .dtype : the "damagetype" , determines if the spell is physical, magical or ultimate.
        //    .atype : the "attacktype" , deals with armor.
        //    .wtype : the "weapontype" , determines the sound effect to be played when damage is done.
        //
        //  Please use common.j/blizzard.j/ some guide to know what damage/attack/weapon types can be used
        //
        damagetype dtype  = DAMAGE_TYPE_UNIVERSAL
        attacktype atype  = ATTACK_TYPE_NORMAL
        weapontype wtype  = WEAPON_TYPE_WHOKNOWS

        //
        // Damage type 'tag' people might use xedamage.isInUse() to detect xedamage usage, there are other static
        //  variables like xedamage.CurrentDamageType and xedamage.CurrentDamageTag. The tag allows you to specify
        //  a custom id for the damage type ** Notice the tag would aid you for some spell stuff, for example,
        //  you can use it in a way similar to Rising_Dusk's damage system.
        //
        integer    tag    = 0

        //
        // if true, forceDamage will make xedamage ignore dtype and atype and try as hard as possible to deal 100%
        // damage.
        boolean    forceDamage = false


        //
        // Ally factor! Certain spells probably have double purposes and heal allies while harming enemies. This
        // field allows you to do such thing.
        //
        real     allyfactor = 1.0

        //
        // field: .exception = SOME_UNIT_TYPE
        // This field adds an exception unittype (classification), if the unit belongs to this unittype it will
        // be ignored.
        //
        method operator exception= takes unittype ut returns nothing
            set this.use_ex=true
            set this.ex_ut=ut
        endmethod

        //
        // field: .required = SOME_UNIT_TYPE
        // This field adds a required unittype (classification), if the unit does not belong to this unittype
        //  it will be ignored.
        //
        method operator required= takes unittype ut returns nothing
            set this.use_req=true
            set this.req_ut=ut
        endmethod
        private boolean  use_ex    =  false
        private unittype ex_ut = null

        private boolean  use_req   = false
        private unittype req_ut  = null


        private unittype array fct[MAX_SUB_OPTIONS]
        private real     array fc[MAX_SUB_OPTIONS]
        private integer  fcn=0

        //
        // method .factor(SOME_UNIT_TYPE, factor)
        //  You might call factor() if you wish to specify a special damage factor for a certain classification,
        // for example call d.factor(UNIT_TYPE_STRUCTURE, 0.5) makes xedamage do half damage to structures.
        //
        method factor takes unittype ut, real fc returns nothing
            if(this.fcn==MAX_SUB_OPTIONS) then
                debug call BJDebugMsg("In one instance of xedamage, you are doing too much calls to factor(), please increase MAX_SUB_OPTIONS to allow more, or cut the number of factor() calls")
                return
            endif
            set this.fct[this.fcn] = ut
            set this.fc[this.fcn] = fc
            set this.fcn = this.fcn+1
        endmethod

        private integer  array abifct[MAX_SUB_OPTIONS]
        private real     array abifc[MAX_SUB_OPTIONS]
        private integer  abifcn=0

        //
        // method .abilityFactor('abil', factor)
        //  You might call abilityFactor() if you wish to specify a special damage factor for units that have a
        // certain ability/buff.
        // for example call d.abilityFactor('A000', 1.5 ) makes units that have the A000 ability take 50% more
        // damage than usual.
        //
        
        method abilityFactor takes integer abilityId, real fc returns nothing
            if(this.abifcn==MAX_SUB_OPTIONS) then
                debug call BJDebugMsg("In one instance of xedamage, you are doing too much calls to abilityFactor(), please increase MAX_SUB_OPTIONS to allow more, or cut the number of abilityFactor() calls")
                return
            endif
            set this.abifct[this.abifcn] = abilityId
            set this.abifc[this.abifcn] = fc
            set this.abifcn = this.abifcn+1
        endmethod

        private boolean  usefx  = false
        private string   fxpath
        private string   fxattach

        //
        // method .useSpecialEffect("effect\\path.mdl", "origin")
        // Makes it add (and destroy) an effect when damage is performed.
        //
        method useSpecialEffect takes string path, string attach returns nothing
            set this.usefx = true
            set this.fxpath=path
            set this.fxattach=attach
        endmethod


        //********************************************************************
        //* Now, the usage stuff:
        //*

        //================================================================================
        // static method xedamage.isInUse()  will return true during a unit damaged
        // event in case this damage was caused by xedamage, in this case, you can
        // read variables like CurrentDamageType, CurrentAttackType and CurrentDamageTag
        // to be able to recognize what sort of damage was done.
        //
        readonly static damagetype CurrentDamageType=null
        readonly static attacktype CurrentAttackType=null
        readonly static integer    CurrentDamageTag =0

        private static integer    inUse = 0
        static method isInUse takes nothing returns boolean 
            return (inUse>0) //inline friendly.
        endmethod
        
        readonly static boolean isDummyDamage = false

        //========================================================================================================
        // This function calculates the damage factor caused by a certain attack and damage
        // type, it is static : xedamage.getDamageTypeFactor(someunit, ATTAcK_TYPE_NORMAL, DAMAGE_TYPE_FIRE, 100)
        //
        static method getDamageTypeFactor takes unit u, attacktype a, damagetype d returns real
         local real hp=GetWidgetLife(u)
         local real mana=GetUnitState(u,UNIT_STATE_MANA)
         local real r
         local real fc = FACTOR_TEST_DAMAGE

            //Since a unit is in that point, we don't need checks.
            call SetUnitX(dmger,GetUnitX(u))
            call SetUnitY(dmger,GetUnitY(u))

            call SetUnitOwner(dmger,GetOwningPlayer(u),false)
            set r=hp
            if (hp< FACTOR_TEST_DAMAGE*MAX_DAMAGE_FACTOR) then
                 call SetWidgetLife(u, hp + FACTOR_TEST_DAMAGE*MAX_DAMAGE_FACTOR )
                 set r = hp + FACTOR_TEST_DAMAGE*MAX_DAMAGE_FACTOR
                 set fc = GetWidgetLife(u)-hp + EPSILON
            endif
            set isDummyDamage = true
            call UnitDamageTarget(dmger,u, fc ,false,false,a,d,null)
            static if DEBUG_MODE then
                if IsUnitType(u, UNIT_TYPE_DEAD) and (hp>0.405) then
                    call BJDebugMsg("xedamage: For some reason, the unit being tested by getDamageTypeFactor has died. Verify MAX_DAMAGE_FACTOR is set to a correct value. ") 
                endif
            endif
            
            set isDummyDamage = false
            call SetUnitOwner(dmger,Player(15),false)
            if (mana>GetUnitState(u,UNIT_STATE_MANA)) then
                //Unit had mana shield, return 1 and restore mana too.
                call SetUnitState(u,UNIT_STATE_MANA,mana)
                set r=1
            else
                set r= (r-GetWidgetLife(u)) / fc
            endif
            call SetWidgetLife(u,hp)
         return r
        endmethod


        private method getTargetFactorCore takes unit source, unit target, boolean usetypes returns real
         local player p=GetOwningPlayer(source)
         local boolean allied=IsUnitAlly(target,p)
         local boolean enemy =IsUnitEnemy(target,p)
         local boolean neutral=allied
         local real   f
         local real   negf=1.0
         local integer i

            if(this.damageAllies != this.damageNeutral) then
                set neutral= allied and not (GetPlayerAlliance(GetOwningPlayer(target),p, ALLIANCE_HELP_REQUEST ))
                //I thought accuracy was not as important as speed , I think that REQUEST is false is enough to consider
                // it neutral.
                //set neutral= allied and not (GetPlayerAlliance(GetOwningPlayer(target),p, ALLIANCE_HELP_RESPONSE ))
                //set neutral= allied and not (GetPlayerAlliance(GetOwningPlayer(target),p, ALLIANCE_SHARED_XP ))
                //set neutral= allied and not (GetPlayerAlliance(GetOwningPlayer(target),p, ALLIANCE_SHARED_SPELLS ))
                set allied= allied and not(neutral)
            endif

            if (not this.damageAllies) and allied then
                return 0.0
            elseif (not this.damageEnemies) and enemy then
                return 0.0
            elseif( (not this.damageSelf) and (source==target) ) then
                return 0.0
            elseif (not this.damageNeutral) and neutral  then
                return 0.0
            elseif( this.use_ex and IsUnitType(target, this.ex_ut) ) then
                return 0.0
            elseif( this.visibleOnly and not IsUnitVisible(target,p) ) then
                return 0.0
            elseif ( this.deadOnly and not IsUnitType(target,UNIT_TYPE_DEAD) ) then
                return 0.0
            elseif ( not(this.alsoDead) and IsUnitType(target,UNIT_TYPE_DEAD) ) then
                return 0.0               
            endif

            set f=1.0
            
            if ( IsUnitAlly(target,p) ) then
                set f=f*this.allyfactor
                if(f<=-EPSILON) then
                    set f=-f
                    set negf=-1.0
                endif
            endif
            if (this.use_req and not IsUnitType(target,this.req_ut)) then
                return 0.0
            endif

            set i=.fcn-1
            loop
                exitwhen (i<0)
                if( IsUnitType(target, this.fct[i] ) ) then
                    set f=f*this.fc[i]
                    if(f<=-EPSILON) then
                        set f=-f
                        set negf=-1.0
                    endif
                endif
                set i=i-1
            endloop
            set i=.abifcn-1
            loop
                exitwhen (i<0)
                if( GetUnitAbilityLevel(target,this.abifct[i] )>0 ) then
                    set f=f*this.abifc[i]
                    if(f<=-EPSILON) then
                        set f=-f
                        set negf=-1.0
                    endif
                endif
                set i=i-1
            endloop
            set f=f*negf

            if ( f<EPSILON) and (f>-EPSILON) then
                return 0.0
            endif
            if( this.forceDamage or not usetypes ) then
                return f
            endif
            set f=f*xedamage.getDamageTypeFactor(target,this.atype,this.dtype)

            if ( f<EPSILON) and (f>-EPSILON) then
                return 0.0
            endif

            return f
        endmethod

        //====================================================================
        // With this you might decide if a unit is a valid target for a spell.
        //
        method getTargetFactor takes unit source, unit target returns real
            return this.getTargetFactorCore(source,target,true)
        endmethod

        //======================================================================
        // a little better, I guess
        //
        method allowedTarget takes unit source, unit target returns boolean
            return (this.getTargetFactorCore(source,target,false)!=0.0)
        endmethod


        //=======================================================================
        // performs damage to the target unit, for unit 'source'. 
        //
        method damageTarget takes unit source, unit target, real damage returns boolean
         local damagetype dt=.CurrentDamageType
         local attacktype at=.CurrentAttackType
         local integer    tg=.CurrentDamageTag
         local real       f = this.getTargetFactorCore(source,target,false)
         local real       pl

            if(f!=0.0) then
                set .CurrentDamageType = .dtype
                set .CurrentAttackType = .atype
                set .CurrentDamageTag  = .tag

                
                set .inUse = .inUse +1
                set pl=GetWidgetLife(target)
                call UnitDamageTarget(source,target,  f*damage, true, .ranged, .atype, .dtype, .wtype )
                set .inUse = .inUse -1
                set .CurrentDamageTag = tg
                set .CurrentDamageType = dt
                set .CurrentAttackType = at
                if(pl != GetWidgetLife(target) ) then
                    if(usefx) then
                         call DestroyEffect(  AddSpecialEffectTarget(this.fxpath, target, this.fxattach) )
                    endif
                    return true
                endif
            endif
            return false
        endmethod

        //=======================================================================================
        // The same as damageTarget, but it forces a specific damage value, good if you already
        // know the target.
        //
        method damageTargetForceValue takes unit source, unit target, real damage returns nothing
         local damagetype dt=.CurrentDamageType
         local attacktype at=.CurrentAttackType
         local integer    tg=.CurrentDamageTag

                set .CurrentDamageType = .dtype
                set .CurrentAttackType = .atype
                set .CurrentDamageTag  = .tag

                if( usefx) then
                    call DestroyEffect(  AddSpecialEffectTarget(this.fxpath, target, this.fxattach) )
                endif
                
                set .inUse = .inUse +1
                call UnitDamageTarget(source,target,  damage, true, .ranged, null, null, .wtype )
                set .inUse = .inUse -1
                set .CurrentDamageTag  = tg
                set .CurrentDamageType = dt
                set .CurrentAttackType = at
        endmethod

        //=====================================================================================
        // Notice: this will not Destroy the group, but it will certainly empty the group.
        //
        method damageGroup takes unit source, group targetGroup, real damage returns integer
         local damagetype dt=.CurrentDamageType
         local attacktype at=.CurrentAttackType
         local integer    tg=.CurrentDamageTag
         local unit       target
         local real       f
         local integer    count=0
         local real hp

            set .CurrentDamageType = .dtype
            set .CurrentAttackType = .atype
            set .CurrentDamageTag  = .tag
            set .inUse = .inUse +1
            loop
                set target=FirstOfGroup(targetGroup)
                exitwhen (target==null)
                call GroupRemoveUnit(targetGroup,target)
                set f= this.getTargetFactorCore(source,target,false)
                if (f!=0.0) then
                    set count=count+1
                    if(usefx) then
                        set hp = GetWidgetLife(target)
                    endif

                    call UnitDamageTarget(source,target, f*damage, true, .ranged, .atype, .dtype, .wtype )
                    if(usefx and (hp > GetWidgetLife(target)) ) then
                        call DestroyEffect(  AddSpecialEffectTarget(this.fxpath, target, this.fxattach) )
                    endif                 

                endif
            endloop


            set .inUse = .inUse -1
            set .CurrentDamageTag=tg
            set .CurrentDamageType = dt
            set .CurrentAttackType = at
         return count
        endmethod

        private static xedamage instance
        private integer countAOE
        private unit    sourceAOE
        private real    AOEx
        private real    AOEy
        private real    AOEradius
        private real    AOEdamage
        private static boolexpr filterAOE
        private static boolexpr filterDestAOE
        private static group    enumgroup
        private static rect     AOERect

        private static method damageAOE_Enum takes nothing returns boolean
         local unit target=GetFilterUnit()
         local xedamage this=.instance //adopting a instance.
         local real f
         local real hp
         
             if( not IsUnitInRangeXY(target,.AOEx, .AOEy, .AOEradius) ) then
                 set target=null
                 return false
             endif
             set f=.getTargetFactorCore(.sourceAOE, target, false)
             if(f!=0.0) then
                 set .countAOE=.countAOE+1
                 if(this.usefx) then
                      set hp =GetWidgetLife(target)
                 endif
                 call UnitDamageTarget(.sourceAOE,target, f*this.AOEdamage, true, .ranged, .atype, .dtype, .wtype )
                 if(this.usefx and (hp > GetWidgetLife(target) ) ) then
                     call DestroyEffect(  AddSpecialEffectTarget(this.fxpath, target, this.fxattach) )
                 endif                                  
             endif

          set .instance= this //better restore, nesting IS possible!
          set target=null
          return false
        endmethod

        private static method damageAOE_DestructablesEnum takes nothing returns boolean
         local destructable target=GetFilterDestructable()
         local xedamage this=.instance //adopting a instance.
         local real     dx=.AOEx-GetDestructableX(target)
         local real     dy=.AOEy-GetDestructableY(target)

             if( dx*dx + dy*dy >= .AOEradius+EPSILON )  then
                 set target=null
                 return false
             endif
             set .countAOE=.countAOE+1
             if(.usefx) then
                 call DestroyEffect(  AddSpecialEffectTarget(this.fxpath, target, this.fxattach) )
             endif             
             call UnitDamageTarget(.sourceAOE,target, this.AOEdamage, true, .ranged, .atype, .dtype, .wtype )

          set .instance= this //better restore, nesting IS possible!
          set target=null
          return false
        endmethod
        //==========================================================================================
        // will affect trees if damageTrees is true!
        // 
        method damageAOE takes unit source, real x, real y, real radius, real damage returns integer
         local damagetype dt=.CurrentDamageType
         local attacktype at=.CurrentAttackType
         local integer    tg=.CurrentDamageTag

            set .CurrentDamageType = .dtype
            set .CurrentAttackType = .atype
            set .CurrentDamageTag  = .tag
            set .inUse = .inUse +1
            set .instance=this
            set .countAOE=0
            set .sourceAOE=source
            set .AOEx=x
            set .AOEradius=radius
            set .AOEy=y
            set .AOEdamage=damage
            call GroupEnumUnitsInRange(.enumgroup,x,y,radius+XE_MAX_COLLISION_SIZE, .filterAOE)
            if(.damageTrees) then
                call SetRect(.AOERect, x-radius, y-radius, x+radius, y+radius)
                set .AOEradius=.AOEradius*.AOEradius
                call EnumDestructablesInRect(.AOERect, .filterDestAOE, null)
            endif
            set .inUse = .inUse -1
            set .CurrentDamageTag  = tg
            set .CurrentDamageType = dt
            set .CurrentAttackType = at
         return .countAOE
        endmethod

        method damageAOELoc takes unit source, location loc, real radius, real damage returns integer
            return .damageAOE(source, GetLocationX(loc), GetLocationY(loc), radius, damage)
        endmethod

        //==========================================================================================
        // only affects trees, ignores damageTrees
        // 
        method damageDestructablesAOE takes unit source, real x, real y, real radius, real damage returns integer
            set .instance=this
            set .countAOE=0
            set .sourceAOE=source
            set .AOEx=x
            set .AOEradius=radius*radius
            set .AOEy=y
            set .AOEdamage=damage
            //if(.damageTrees) then
                call SetRect(.AOERect, x-radius, y-radius, x+radius, y+radius)
                call EnumDestructablesInRect(.AOERect, .filterDestAOE, null)
            //endif
         return .countAOE
        endmethod
        method damageDestructablesAOELoc takes unit source, location loc, real radius, real damage returns integer
            return .damageDestructablesAOE(source,GetLocationX(loc), GetLocationY(loc), radius, damage)
        endmethod

        //'friend' with the library init
        static method structInit takes nothing returns nothing
            set .AOERect= Rect(0,0,0,0)
            set .filterAOE= Condition(function xedamage.damageAOE_Enum)
            set .filterDestAOE = Condition( function xedamage.damageAOE_DestructablesEnum)
            set .enumgroup = CreateGroup()
        endmethod
    endstruct

    private function init takes nothing returns nothing
        set dmger=CreateUnit(Player(15), XE_DUMMY_UNITID , 0.,0.,0.)
        call UnitAddAbility(dmger,'Aloc')
        call xedamage.structInit()
    endfunction




endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library ZUtils


    globals
        private location loc = Location(0.00, 0.00)
    endglobals
    
    
    function GetTerrainZ takes real x, real y returns real
        call MoveLocation(loc, x, y)
        return GetLocationZ(loc)
    endfunction
    
    
    function GetUnitZ takes unit u returns real
        return GetUnitFlyHeight(u)
    endfunction
    
    
    function SetUnitZ takes unit u, real height returns nothing
        call SetUnitFlyHeight(u, height, 0.00)
    endfunction


endlibrary

//TESH.scrollpos=0
//TESH.alwaysfold=0
library AutoFly requires AutoIndex, xebasic, Table


    private function UnitFlyFilter takes unit u returns boolean
        return GetUnitTypeId(u) != XE_DUMMY_UNITID
    endfunction

    private struct AutoFly extends array
        
        static HandleTable t = 0
        
        static method enableFly takes unit u returns nothing
            if UnitFlyFilter(u) and t[u] == 0 then
                call UnitAddAbility(u, XE_HEIGHT_ENABLER)
                call UnitRemoveAbility(u, XE_HEIGHT_ENABLER)
                set t[u] = 1
            endif
        endmethod
            


        static method onInit takes nothing returns nothing
            call OnUnitIndexed(thistype.enableFly)
            set t = HandleTable.create()
        endmethod

    endstruct

endlibrary

//TESH.scrollpos=296
//TESH.alwaysfold=0
library AutoIndex
//===========================================================================
// Information:
//==============
//
//     AutoIndex is a very simple script to utilize. Just call GetUnitId(unit)
// to get get the unique value assigned to a particular unit. The GetUnitId
// function is extremely fast because it inlines directly to a GetUnitUserData
// call. AutoIndex automatically assigns an ID to each unit as it enters the
// map, and instantly frees that ID as the unit leaves the map. Detection of
// leaving units is accomplished in constant time without a periodic scan.
//
//     AutoIndex uses UnitUserData by default. If something else in your map
// would conflict with that, you can set the UseUnitUserData configuration
// constant to false, and a hashtable will be used instead. Note that hash-
// tables are about 60% slower.
//
//     If you turn on debug mode, AutoIndex will be able to display several
// helpful error messages. The following issues will be detected:
//   -Passing a removed or decayed unit to GetUnitId
//   -Code outside of AutoIndex has overwritten a unit's UserData value.
//   -GetUnitId was used on a filtered unit (a unit you don't want indexed).
//
//     AutoIndex provides events upon indexing or deindexing units. This
// effectively allows you to notice when units enter or leave the game. Also
// included are the AutoData, AutoCreate, and AutoDestroy modules, which allow
// you to fully utilize AutoIndex's enter/leave detection capabilities in
// conjunction with your structs.
//
//===========================================================================
// How to install AutoIndex:
//===========================
//
// 1.) Copy and paste this script into your map.
// 2.) Save it to allow the ObjectMerger macro to generate the "Leave Detect"
//     ability for you. Close and re-open the map. After that, disable the macro
//     to prevent the delay while saving.
//
//===========================================================================
// How to use AutoIndex:
//=======================
//
//     So you can get a unique integer for each unit, but how do you use that to
// attach data to a unit? GetUnitId will always return a number in the range of
// 1-8190. This means it can be used as an array index, as demonstrated below:
/*
    globals
        integer array IntegerData
        real array RealData
        SomeStruct array SomeStructData
    englobals

    function Example takes nothing returns nothing
        local unit u = CreateUnit(Player(0), 'hpea', 0., 0., 0.)
        local integer id = GetUnitId(u)
            //You now have a unique index for the unit, so you can
            //attach or retrieve data about the unit using arrays.
            set IntegerData[id] = 5
            set RealData[id] = 25.0
            set SomeStructData[id] = SomeStruct.create()
            //If you have access to the same unit in another function, you can
            //retrieve the data by using GetUnitId() and reading the arrays.
    endfunction
*/
//     The UnitFilter function in the configuration section is provided so that
// you can make AutoIndex completely ignore certain unit-types. Ignored units
// won't be indexed or fire indexed/deindexed events. You may want to filter out
// dummy casters or system-private units, especially ones that use UnitUserData
// internally. xe dummy units are automatically filtered.
//
//===========================================================================
// How to use OnUnitIndexed / OnUnitDeindexed:
//=============================================
//
//     AutoIndex will fire the OnUnitIndexed event when a unit enters the map,
// and the OnUnitDeindexed event when a unit leaves the map. Functions used
// as events must take a unit and return nothing. An example is given below:
/*
    function UnitEntersMap takes unit u returns nothing
        call BJDebugMsg(GetUnitName(u)+" with ID "+I2S(GetUnitId(u))+" entered the map.")
    endfunction //Using GetUnitId() during Indexed events works fine...

    function UnitLeavesMap takes unit u returns nothing
        call BJDebugMsg(GetUnitName(u)+" with ID "+I2S(GetUnitId(u))+" left the map.")
    endfunction  //So does using GetUnitId() during Deindexed events.

    function Init takes nothing returns nothing
        call OnUnitIndexed(UnitEntersMap)
        call OnUnitDeindexed(UnitLeavesMap)
    endfunction
*/
//     If you call OnUnitIndexed during map initialization, every existing
// unit will be considered as entering the map. This saves you from the need
// to manually enumerate preplaced units (or units created by initialization
// code that ran before OnUnitIndexed was called).
//
//     OnUnitDeindexed runs while a unit still exists, which means you can
// still do things such as destroy special effects attached to the unit.
// The unit will cease to exist immediately after the event is over.
//
//===========================================================================
// AutoIndex API:
//================
//
// GetUnitId(unit) -> integer
//   This function returns a unique ID in the range of 1-8190 for the
//   specified unit. Returns 0 if a null unit was passed. This function
//   inlines directly to GetUnitUserData or LoadInteger if debug mode
//   is disabled. If debug mode is enabled, this function will print
//   an error message when passed a decayed or filtered unit.
//
// IsUnitIndexed(unit) -> boolean
//   This function returns a boolean indicating whether the specified
//   unit has been indexed. The only time this will return false is
//   for units you have filtered using the UnitFilter function, or
//   for xe dummy units. You can use this function to easily detect
//   dummy units and avoid performing certain actions on them.
//
// OnUnitIndexed(IndexFunc)
//   This function accepts an IndexFunc, which must take a unit and
//   return nothing. The IndexFunc will be fired instantly whenever
//   a unit enters the map. You may use GetUnitId on the unit. When
//   you call this function during map initialization, every existing
//   unit will be considered as entering the map.
//
// OnUnitDeindexed(IndexFunc)
//   Same as above, but runs whenever a unit is leaving the map. When
//   this event runs, the unit still exists, but it will cease to exist
//   as soon as the event ends. You may use GetUnitId on the unit.
//
//===========================================================================
// How to use AutoData:
//======================
//
//     The AutoData module allows you to associate one or more instances
// of the implementing struct with units, as well as iterate through all
// of the instances associated with each unit.
//
//     This association is accomplished through the "me" instance member,
// which the module will place in the implementing struct. Whichever unit
// you assign to "me" becomes the owner of that instance. You may change
// ownership by reassigning "me" to another unit at any time, or you may
// make the instance unowned by assigning "me" to null.
//
//     AutoData implements the static method operator [] in your struct
// to allow you to access instances from their owning units. For example,
// you may type: local StructName s = StructName[u]. If u has been set
// to own an instance of StructName, s will be set to that instance.
//
//     So, what happens if you assign the same owning unit to multiple
// instances? You may use 2D array syntax to access instances assigned to
// the same unit: local StructName s = StructName[u][n], where u is the
// owning unit, and n is the index beginning with 0 for each unit. You
// can access the size of a unit's instance list (i.e. the number of
// instances belonging to the unit) by using the .size instance member.
/*
    struct Example
        implement AutoData
        static method create takes unit u returns Example
            local Example this = allocate()
                set me = u //Assigning the "me" member from AutoData.
            return this
        endmethod
    endstruct
    function Test takes nothing returns nothing
        local unit u = CreateUnit(Player(0), 'hpea', 0., 0., 0.)
        local Example e1 = Example.create(u)
        local Example e2 = Example.create(u)
        local Example e3 = Example.create(u)
        local Example e
            call BJDebugMsg(I2S(Example[u].size)) //Prints 3 because u owns e1, e2, and e3.
            set e = Example[u][GetRandomInt(0, Example[u].size - 1)] //Random instance belonging to u.
            set e = Example[u]  //This is the fastest way to iterate the instances belonging
            loop                //to a specific unit, starting with the first instance.
                exitwhen e == 0 //e will be assigned to 0 when no instances remain.
                call BJDebugMsg(I2S(e)) //Prints the values of e1, e2, e3.
                set e = e[e.index + 1] //"e.index" refers to the e's position in u's instance list.
            endloop                    //Thus, index + 1 is next, and index - 1 is previous.
    endfunction                        //This trick allows you to avoid a local counter.
*/
//   AutoData restrictions:
//   -You may not implement AutoData in any struct which has already
//    declared static or non-static method operator [].
//   -AutoData will conflict with anything named "me", "size", or
//    "index" in the implementing struct.
//   -AutoData may not be implemented in structs that extend array.
//   -You may not declare your own destroy method. (This restriction
//    can be dropped as soon as JassHelper supports module onDestroy).
//
//   AutoData information:
//   -You do not need to null the "me" member when destroying an
//    instance. That is done for you automatically during destroy().
//    (But if you use deallocate(), you must null "me" manually.)
//   -StructName[u] and StructName[u][0] refer to the same instance,
//    which is the first instance that was associated with unit u.
//   -StructName[u][StructName[u].size - 1] refers to the instance that
//    was most recently associated with unit u.
//   -Instances keep their relative order in the list when one is removed.
//
//===========================================================================
// How to use AutoCreate:
//=======================
//
//     The AutoCreate module allows you to automatically create instances
// of the implementing struct for units as they enter the game. AutoCreate
// automatically implements AutoData into your struct. Any time an instance
// is automatically created for a unit, that instance's "me" member will be
// assigned to the entering unit.
//
//   AutoCreate restrictions:
//   -All of the same restrictions as AutoData.
//   -If your struct's allocate() method takes parameters (i.e. the parent
//    type's create method takes parameters), you must declare a create
//    method and pass those extra parameters to allocate yourself.
//
//   AutoCreate information:
//   -You may optionally declare the createFilter method, which specifies
//    which units should recieve an instance as they enter the game. If
//    you do not declare it, all entering units will recieve an instance.
//   -You may optionally declare the onCreate method, which will run when
//    AutoCreate automatically creates an instance. (This is just a stand-
//    in until JassHelper supports the onCreate method.)
//   -You may declare your own create method, but it must take a single
//    unit parameter (the entering unit) if you do so.
/*
    struct Example
        private static method createFilter takes unit u returns boolean
            return GetUnitTypeId(u) == 'hfoo' //Created only for Footmen.
        endmethod
        private method onCreate takes nothing returns nothing
            call BJDebugMsg(GetUnitName(me)+" entered the game!")
        endmethod
        implement AutoCreate
    endstruct
*/
//===========================================================================
// How to use AutoDestroy:
//=========================
// 
//     The AutoDestroy module allows you to automatically destroy instances
// of the implementing struct when their "me" unit leaves the game. AutoDestroy
// automatically implements AutoData into your struct. You must assign a unit
// to the "me" member of an instance for this module to have any effect.
//
//   AutoDestroy restrictions:
//   -All of the same restrictions as AutoData.
//
//   AutoDestroy information:
//   -If you also implement AutoCreate in the same struct, remember that it
//    assigns the "me" unit automatically. That means you can have fully
//    automatic creation and destruction.
/*
    struct Example
        static method create takes unit u returns Example
            local Example this = allocate()
                set me = u //You should assign a unit to "me",
            return this    //otherwise AutoDestroy does nothing.
        endmethod          //Not necessary if using AutoCreate.
        private method onDestroy takes nothing returns nothing
            call BJDebugMsg(GetUnitName(me)+" left the game!")
        endmethod
        implement AutoDestroy
    endstruct
*/
//===========================================================================
// Configuration:
//================

////! external ObjectMerger w3a Adef lvdt anam "Leave Detect" aart "" arac 0
//Save your map with this Object Merger call enabled, then close and reopen your
//map. Disable it by removing the exclamation to remove the delay while saving.

globals
    private constant integer LeaveDetectAbilityID = 'lvdt'
    //This rawcode must match the parameter after "Adef" in the
    //ObjectMerger macro above. You may change both if you want.
    
    private constant boolean UseUnitUserData = true
    //If this is set to true, UnitUserData will be used. You should only set
    //this to false if something else in your map already uses UnitUserData.
    //A hashtable will be used instead, but it is about 60% slower.
    
    private constant boolean SafeMode = true
    //This is set to true by default so that GetUnitId() will ALWAYS work.
    //If if this is set to false, GetUnitId() may fail to work in a very
    //rare circumstance: creating a unit that has a default-on autocast
    //ability, and using GetUnitId() on that unit as it enters the game,
    //within a trigger that detects any order. Set this to false for a
    //performance boost only if you think you can avoid this issue.
    
    private constant boolean AutoDataFastMode = true
    //If this is set to true, AutoData will utilize one hashtable per time
    //it is implemented. If this is set to false, all AutoDatas will share
    //a single hashtable, but iterating through the instances belonging to
    //a unit will become about 12.5% slower. Your map will break if you
    //use more than 255 hashtables simultaneously. Only set this to false
    //if you suspect you will run out of hashtable instances.
endglobals

private function UnitFilter takes unit u returns boolean
    return GetUnitTypeId(u) != XE_DUMMY_UNITID
endfunction
//Make this function return false for any unit-types you want to ignore.
//Ignored units won't be indexed or fire OnUnitIndexed/OnUnitDeindexed
//events. The unit parameter "u" to refers to the unit being filtered.
//Do not filter out xe dummy units; they are automatically filtered.

//===========================================================================
// AutoData / AutoCreate / AutoDestroy modules:
//==============================================

function interface AutoCreator takes unit u returns nothing
function interface AutoDestroyer takes unit u returns nothing

globals                
    hashtable AutoData = null //If AutoDataFastMode is disabled, this hashtable will be
endglobals                    //initialized and shared between all AutoData implementations.

module AutoData
    private static hashtable ht
    private static thistype array data
    private static integer array listsize
    private static key typeid //Good thing keys exist to identify each implementing struct.
    private unit meunit
    private integer id
    
    readonly integer index //The user can avoid using a local counter because this is accessable.
    
    static method operator [] takes unit u returns thistype
        return data[GetUnitId(u)]
    endmethod //This is as fast as retrieving an instance from a unit gets.
    
    method operator [] takes integer index returns thistype
        static if AutoDataFastMode then //If fast mode is enabled...
            return LoadInteger(ht, id, index)
        else //Each instance has its own hashtable to associate unit and index.
            return LoadInteger(AutoData, id, index*8190+typeid)
        endif //Otherwise, simulate a 3D array associating unit, struct-type ID, and index.
    endmethod //Somehow, this version is 12.5% slower just because of the math.
    
    private method setIndex takes integer index, thistype data returns nothing
        static if AutoDataFastMode then //Too bad you can't have a module-private operator []=.
            call SaveInteger(ht, id, index, data)
        else
            call SaveInteger(AutoData, id, index*8190+typeid, data)
        endif
    endmethod
    
    private method remove takes nothing returns nothing
        if meunit == null then //If the struct doesn't have an owner...
            return             //Nothing needs to be done.
        endif
        loop
            exitwhen index == listsize[id]        //The last value gets overwritten by 0.
            call setIndex(index, this[index + 1]) //Shift each element down by one.
            set this[index].index = index         //Update the shifted instance's index.
            set index = index + 1
        endloop 
        set listsize[id] = listsize[id] - 1
        set data[id] = this[0] //Ensure thistype[u] returns the same value as thistype[u][0].
        set meunit = null
    endmethod
    
    private method add takes unit u returns nothing
        if meunit != null then     //If the struct has an owner...
            call remove()          //remove it first.
        endif
        set meunit = u
        set id = GetUnitId(u)      //Cache GetUnitId for slight performance boost.
        if data[id] == 0 then      //If this is the first instance for this unit...
            set data[id] = this    //Update the value that thistype[u] returns.
        endif
        set index = listsize[id]   //Remember the index for removal.
        call setIndex(index, this) //Add to the array.
        set listsize[id] = index + 1
    endmethod
    
    method operator me takes nothing returns unit
        return meunit
    endmethod
    
    method operator me= takes unit u returns nothing
        if u != null then //If assigning "me" a non-null value...
            call add(u)   //Add this instance to that unit's array.
        else              //If assigning "me" a null value...
            call remove() //Remove this instance from that unit's array.
        endif
    endmethod
    
    method operator size takes nothing returns integer
        return listsize[id]
    endmethod
    
    method destroy takes nothing returns nothing
        call deallocate()
        call remove() //This makes removal automatic when an instance is destroyed.
    endmethod
    
    private static method onInit takes nothing returns nothing
        static if AutoDataFastMode then        //If fast mode is enabled...
            set ht = InitHashtable()           //Initialize one hashtable per instance.
        else                                   //If fast mode is disabled...
            if AutoData == null then           //If the hashtable hasn't been initialized yet...
                set AutoData = InitHashtable() //Initialize the shared hashtable.
            endif
        endif
    endmethod
endmodule

module AutoCreate
    implement AutoData //AutoData is necessary for AutoCreate.

    private static method creator takes unit u returns nothing
        local thistype this
        local boolean b = true                          //Assume that the instance will be created.
            static if thistype.createFilter.exists then //If createFilter exists...
                set b = createFilter(u)                 //evaluate it and update b.
            endif
            if b then                                   //If the instance should be created...
                static if thistype.create.exists then   //If the create method exists...
                    set this = create(u)                //Create the instance, passing the entering unit.
                else                                    //If the create method doesn't exist...
                    set this = allocate()               //Just allocate the instance.
                endif
                set me = u                              //Assign the instance's owner as the entering unit.
                static if thistype.onCreate.exists then //If onCreate exists...
                    call onCreate()                     //Call it, because JassHelper should do this anyway.
                endif
            endif
    endmethod

    private static method onInit takes nothing returns nothing
        call AutoIndex.addAutoCreate(thistype.creator)
    endmethod //During module initialization, pass the creator function to AutoIndex.
endmodule

module AutoDestroy
    implement AutoData //AutoData is necessary for AutoDestroy.
    
    static method destroyer takes unit u returns nothing
        loop
            exitwhen thistype[u] == 0
            call thistype[u].destroy()
        endloop
    endmethod //Destroy each instance owned by the unit until none are left.

    private static method onInit takes nothing returns nothing
        call AutoIndex.addAutoDestroy(thistype.destroyer)
    endmethod //During module initialization, pass the destroyer function to AutoIndex.
endmodule

//===========================================================================
// AutoIndex struct:
//===================

function interface IndexFunc takes unit u returns nothing

hook RemoveUnit AutoIndex.hook_RemoveUnit
hook ReplaceUnitBJ AutoIndex.hook_ReplaceUnitBJ
debug hook SetUnitUserData AutoIndex.hook_SetUnitUserData

private keyword getIndex
private keyword getIndexDebug
private keyword isUnitIndexed
private keyword onUnitIndexed
private keyword onUnitDeindexed

struct AutoIndex
    private static trigger   enter      = CreateTrigger()
    private static trigger   order      = CreateTrigger()
    private static trigger   creepdeath = CreateTrigger()
    private static group     preplaced  = CreateGroup()
    private static timer     allowdecay = CreateTimer()
    private static hashtable ht

    private static boolean array dead
    private static boolean array summoned
    private static boolean array animated
    private static boolean array nodecay
    private static boolean array removing
    
    private static IndexFunc array indexfuncs
    private static integer indexfuncs_n = -1
    private static IndexFunc array deindexfuncs
    private static integer deindexfuncs_n = -1
    private static IndexFunc indexfunc
    
    private static AutoCreator array creators
    private static integer creators_n = -1
    private static AutoDestroyer array destroyers
    private static integer destroyers_n = -1
    
    private static unit array allowdecayunit
    private static integer allowdecay_n = -1
    
    private static boolean duringinit = true
    private static boolean array altered
    private static unit array idunit
    
    //===========================================================================

    static method getIndex takes unit u returns integer
        static if UseUnitUserData then
            return GetUnitUserData(u)
        else
            return LoadInteger(ht, 0, GetHandleId(u))
        endif
    endmethod //Resolves to an inlinable one-liner after the static if.
    
    static method getIndexDebug takes unit u returns integer
            if u == null then
                return 0
            elseif GetUnitTypeId(u) == 0 then
                call BJDebugMsg("AutoIndex error: Removed or decayed unit passed to GetUnitId.")
            elseif idunit[getIndex(u)] != u and GetIssuedOrderId() != 852056 then
                call BJDebugMsg("AutoIndex error: "+GetUnitName(u)+" is a filtered unit.")
            endif
        return getIndex(u)
    endmethod //If debug mode is enabled, use the getIndex method that shows errors.
    
    private static method setIndex takes unit u, integer index returns nothing
        static if UseUnitUserData then
            call SetUnitUserData(u, index)
        else
            call SaveInteger(ht, 0, GetHandleId(u), index)
        endif
    endmethod //Resolves to an inlinable one-liner after the static if.
    
    static method isUnitIndexed takes unit u returns boolean
        return u != null and idunit[getIndex(u)] == u
    endmethod
    
    static method isUnitAnimateDead takes unit u returns boolean
        return animated[getIndex(u)]
    endmethod //Don't use this; use IsUnitAnimateDead from AutoEvents instead.
    
    //===========================================================================
    
    private static method onUnitIndexed_sub takes nothing returns nothing
        call indexfunc.evaluate(GetEnumUnit())
    endmethod
    static method onUnitIndexed takes IndexFunc func returns nothing
        set indexfuncs_n = indexfuncs_n + 1
        set indexfuncs[indexfuncs_n] = func
        if duringinit then //During initialization, evaluate the indexfunc for every preplaced unit.
            set indexfunc = func
            call ForGroup(preplaced, function AutoIndex.onUnitIndexed_sub)
        endif
    endmethod
    
    static method onUnitDeindexed takes IndexFunc func returns nothing
        set deindexfuncs_n = deindexfuncs_n + 1
        set deindexfuncs[deindexfuncs_n] = func
    endmethod
    
    static method addAutoCreate takes AutoCreator func returns nothing
        set creators_n = creators_n + 1
        set creators[creators_n] = func
    endmethod
    
    static method addAutoDestroy takes AutoDestroyer func returns nothing
        set destroyers_n = destroyers_n + 1
        set destroyers[destroyers_n] = func
    endmethod
    
    //===========================================================================
    
    private static method hook_RemoveUnit takes unit whichUnit returns nothing
        set removing[getIndex(whichUnit)] = true
    endmethod //Intercepts whenever RemoveUnit is called and sets a flag.
    private static method hook_ReplaceUnitBJ takes unit whichUnit, integer newUnitId, integer unitStateMethod returns nothing
        set removing[getIndex(whichUnit)] = true
    endmethod //Intercepts whenever ReplaceUnitBJ is called and sets a flag.
    
    private static method hook_SetUnitUserData takes unit whichUnit, integer data returns nothing
        static if UseUnitUserData then
            if idunit[getIndex(whichUnit)] == whichUnit then
                if getIndex(whichUnit) == data then
                    call BJDebugMsg("AutoIndex error: Code outside AutoIndex attempted to alter "+GetUnitName(whichUnit)+"'s index.")
                else
                    call BJDebugMsg("AutoIndex error: Code outside AutoIndex altered "+GetUnitName(whichUnit)+"'s index.")
                    if idunit[data] != null then
                        call BJDebugMsg("AutoIndex error: "+GetUnitName(whichUnit)+" and "+GetUnitName(idunit[data])+" now have the same index.")
                    endif
                    set altered[data] = true
                endif
            endif
        endif //In debug mode, intercepts whenever SetUnitUserData is used on an indexed unit.
    endmethod //Displays an error message if outside code tries to alter a unit's index.
    
    //===========================================================================
    
    private static method allowDecay takes nothing returns nothing
        local integer n = allowdecay_n
            loop
                exitwhen n < 0
                set nodecay[getIndex(allowdecayunit[n])] = false
                set allowdecayunit[n] = null
                set n = n - 1
            endloop
            set allowdecay_n = -1
    endmethod //Iterate through all the units in the stack and allow them to decay again.
    
    private static method detectStatus takes nothing returns boolean
        local unit u = GetTriggerUnit()
        local integer index = getIndex(u)
        local integer n
            
            if idunit[index] == u then //Ignore non-indexed units.
                if not IsUnitType(u, UNIT_TYPE_DEAD) then
                
                    if dead[index] then         //The unit was dead, but now it's alive.
                        set dead[index] = false //The unit has been resurrected.
                        //! runtextmacro optional RunAutoEvent("Resurrect")
                        //If AutoEvents is in the map, run the resurrection events.
                        
                        if IsUnitType(u, UNIT_TYPE_SUMMONED) and not summoned[index] then
                            set summoned[index] = true //If the unit gained the summoned flag,
                            set animated[index] = true //it's been raised with Animate Dead.
                            //! runtextmacro optional RunAutoEvent("AnimateDead")
                            //If AutoEvents is in the map, run the Animate Dead events.
                        endif
                    endif
                else
                
                    if not removing[index] and not dead[index] and not animated[index] then
                        set dead[index] = true               //The unit was alive, but now it's dead.
                        set nodecay[index] = true            //A dead unit can't decay for at least 0. seconds.
                        set allowdecay_n = allowdecay_n + 1  //Add the unit to a stack. After the timer
                        set allowdecayunit[allowdecay_n] = u //expires, allow the unit to decay again.
                        call TimerStart(allowdecay, 0., false, function AutoIndex.allowDecay)
                        //! runtextmacro optional RunAutoEvent("Death")
                        //If AutoEvents is in the map, run the Death events.
                        
                    elseif removing[index] or (dead[index] and not nodecay[index]) or (not dead[index] and animated[index]) then
                        //If .nodecay was false and the unit is dead and was previously dead, the unit decayed.
                        //If .animated was true and the unit is dead, the unit died and exploded.
                        //If .removing was true, the unit is being removed or replaced.
                        set n = deindexfuncs_n
                        loop //Run the OnUnitDeindexed events.
                            exitwhen n < 0
                            call deindexfuncs[n].evaluate(u)
                            set n = n - 1
                        endloop
                        set n = destroyers_n
                        loop //Destroy AutoDestroy structs for the leaving unit.
                            exitwhen n < 0
                            call destroyers[n].evaluate(u)
                            set n = n - 1
                        endloop
                        call AutoIndex(index).destroy() //Free the index by destroying the AutoIndex struct.
                        set idunit[index] = null        //Null this unit reference to prevent a leak.
                    endif
                endif
            endif
        set u = null
        return false
    endmethod

    //===========================================================================
    
    private static method unitEntersMap takes unit u returns nothing
        local integer index
        local integer n = 0
            if getIndex(u) != 0 then
                return //Don't index a unit that already has an ID.
            endif
            static if LIBRARY_xebasic then
                if GetUnitTypeId(u) == XE_DUMMY_UNITID then
                    return //Don't index xe dummy units.
                endif
            endif
            if not UnitFilter(u) then
                return //Don't index units that fail the unit filter.
            endif
            set index = create()
            call setIndex(u, index) //Assign an index to the entering unit.
            
            call UnitAddAbility(u, LeaveDetectAbilityID)                 //Add the leave detect ability to the entering unit.
            call UnitMakeAbilityPermanent(u, true, LeaveDetectAbilityID) //Prevent it from disappearing on morph.
            set dead[index] = IsUnitType(u, UNIT_TYPE_DEAD)              //Reset all of the flags for the entering unit.
            set summoned[index] = IsUnitType(u, UNIT_TYPE_SUMMONED)      //Each of these flags are necessary to detect
            set animated[index] = false                                  //when a unit leaves the map.
            set nodecay[index] = false
            set removing[index] = false
            debug set altered[index] = false    //In debug mode, this flag tracks wheter a unit's index was altered.
            set idunit[index] = u               //Attach the unit that is supposed to have this index to the index.
            
            if duringinit then                  //If a unit enters the map during initialization...
                call GroupAddUnit(preplaced, u) //Add the unit to the preplaced units group. This ensures that
            endif                               //all units are noticed by OnUnitIndexed during initialization.
            loop //Create AutoCreate structs for the entering unit.
                exitwhen n > creators_n
                call creators[n].evaluate(u)
                set n = n + 1
            endloop
            set n = 0
            loop //Run the OnUnitIndexed events.
                exitwhen n > indexfuncs_n
                call indexfuncs[n].evaluate(u)
                set n = n + 1
            endloop
    endmethod
    
    private static method onIssuedOrder takes nothing returns boolean
            static if SafeMode then     //If SafeMode is enabled, perform this extra check.
                if getIndex(GetTriggerUnit()) == 0 then  //If the unit doesn't already have
                    call unitEntersMap(GetTriggerUnit()) //an index, then assign it one.
                endif
            endif
        return GetIssuedOrderId() == 852056 //If the order is Undefend, allow detectStatus to run.
    endmethod
    
    private static method initEnteringUnit takes nothing returns boolean
            call unitEntersMap(GetFilterUnit())
        return false
    endmethod
    
    //===========================================================================
    
    private static method afterInit takes nothing returns nothing
        set duringinit = false               //Initialization is over; set a flag.
        call DestroyTimer(GetExpiredTimer()) //Destroy the timer.
        call GroupClear(preplaced)           //The preplaced units group is
        call DestroyGroup(preplaced)         //no longer needed, so clean it.
        set preplaced = null
    endmethod
    
    private static method onInit takes nothing returns nothing
        local region maparea = CreateRegion()
        local rect bounds = GetWorldBounds()
        local group g = CreateGroup()
        local integer i = 15
            static if not UseUnitUserData then
                set ht = InitHashtable() //Only create a hashtable if it will be used.
            endif
            loop
                exitwhen i < 0
                call SetPlayerAbilityAvailable(Player(i), LeaveDetectAbilityID, false)
                //Make the LeaveDetect ability unavailable so that it doesn't show up on the command card of every unit.
                call TriggerRegisterPlayerUnitEvent(order, Player(i), EVENT_PLAYER_UNIT_ISSUED_ORDER, null)
                //Register the "EVENT_PLAYER_UNIT_ISSUED_ORDER" event for each player.
                call GroupEnumUnitsOfPlayer(g, Player(i), function AutoIndex.initEnteringUnit)
                //Enum every non-filtered unit on the map during initialization and assign it a unique
                //index. By using GroupEnumUnitsOfPlayer, even units with Locust can be detected.
                set i = i - 1
            endloop
            call TriggerAddCondition(order, And(function AutoIndex.onIssuedOrder, function AutoIndex.detectStatus))
            //The detectStatus method will fire every time a non-filtered unit recieves an undefend order.
            //And() is used here to avoid using a trigger action, which starts a new thread and is slower.
            call TriggerRegisterPlayerUnitEvent(creepdeath, Player(12), EVENT_PLAYER_UNIT_DEATH, null)
            call TriggerAddCondition(creepdeath, function AutoIndex.detectStatus)
            //The detectStatus method must also fire when a neutral hostile creep dies, in case it was
            //sleeping. Sleeping creeps don't fire undefend orders on non-damaging deaths.
            call RegionAddRect(maparea, bounds) //GetWorldBounds() includes the shaded boundry areas.
            call TriggerRegisterEnterRegion(enter, maparea, function AutoIndex.initEnteringUnit)
            //The filter function of an EnterRegion trigger runs instantly when a unit is created.
            call TimerStart(CreateTimer(), 0., false, function AutoIndex.afterInit)
            //After any time elapses, perform after-initialization actions.
        call GroupClear(g)
        call DestroyGroup(g)
        call RemoveRect(bounds)
        set g = null
        set bounds = null
    endmethod
    
endstruct

//===========================================================================
// User functions:
//=================

function GetUnitId takes unit u returns integer
    static if DEBUG_MODE then             //If debug mode is enabled...
        return AutoIndex.getIndexDebug(u) //call the debug version of GetUnitId.
    else                                  //If debug mode is disabled...
        return AutoIndex.getIndex(u)      //call the normal, inlinable version.
    endif
endfunction

function IsUnitIndexed takes unit u returns boolean
    return AutoIndex.isUnitIndexed(u)
endfunction

function OnUnitIndexed takes IndexFunc func returns nothing
    call AutoIndex.onUnitIndexed(func)
endfunction

function OnUnitDeindexed takes IndexFunc func returns nothing
    call AutoIndex.onUnitDeindexed(func)
endfunction

endlibrary

//TESH.scrollpos=746
//TESH.alwaysfold=0
 /*=====================================================================*\
//======                      SUICIDE SQUAD                        =====*\\
\\======                       Version 1.0b                        ======//
 \\======                        by Kricz                         ======//
 ||                                                                     ||
 ||                                                                     ||
 ||                              Requires:                              ||
 \\                          Table [Vexorian]                          //  
  \\                       ListModule [grim001]                       //
   \\              xebasic, xedamage & xefx [Vexorian]               //
    \\                       ARGB [Vexorian]                        //
    ||                  SoundUtils [Rising_Dusk]                   ||
    ||                  GroupUtils [Rising_Dusk]                   ||
    ||                       Z-Utils [Kricz]                       ||
   //                                                              \\
  //                           Optional:                            \\
  ||              AutoFly [Kricz] (requires AutoIndex)              ||
  ||                    AbilityPreload [grim001]                    ||
  ||                                                                ||
  ||    Please give credits if you use this spell in your map.      ||
  ||                                                                ||
  \*==============================================================?=*/
                    
scope SuicideSquad initializer onInit

    /*Main Setup*/
    globals
        
        //The Spell-Id of the SuicideSquad Ability
        private constant integer SPELL_ID                       = 'A000'
        
        //The Timer-Interval of timers for movements and checks
        //Default Value: 0.05
        private constant real TIMER_INTERVAL                    = 0.05
        
        //If true, the system will use sounds using Rising_Dusk's SoundUtils Library.
        //You can manually disable specific sounds, by setting their path to "".
        private constant boolean USE_SOUNDS                     = true         

    endglobals
    
    /*Sapper Setup*/
    globals
    
        //The Unit-Id of the Sapper
        private constant integer SAPPER_UNIT_ID                     = 'sapp'
        
        //The speed of the down-falling sappers
        //Default Value: 375.00
        private constant real SAPPER_DROP_SPEED                     = 375.00
        
        //The radius, in where sappers search valid targets
        //Default Value: 700.00
        private constant real SAPPER_TARGET_SEARCH_AREA             = 700.00
        
        //If this is true, the sapper will walk to the position of the target unit once it dies
        //and search for new targets while walking. If false, the sapper will stop walking and
        //then search for new targets
        //Default Value: false
        private constant boolean SAPPER_STOP_WHEN_TARGET_DIES       = false
        
        //This is the distance a sapper has to be with its target to make suicide.
        //Default Value: 150.00
        private constant real SAPPER_SUICIDE_RANGE                  = 150.00
        
        //If true, the sappers are invulnerable while falling down and become normal once reaching the gorund
        //Default Value: true
        private constant boolean SAPPER_INVULNERABLE_WHILE_FALLING  = true
        
        //This is the animation-id which is played indstead of the normal death-animation.
        //Information: 3 is the "spell death" animation, which shows, that the sapper does suicide
        //4 is the normal death animation. Ofcourse you could use any other number, if you are funny :D
        //Default Value: 3
        private constant integer SAPPER_SUICIDE_ANIMATION_ID        = 3
        
        //This is the effect that is created when a sapper is dropped by a zeppeling and falling down
        //Use "" for no effect.
        //Default Value: "Abilities\\Spells\\Other\\Tornado\\Tornado_Target.mdl"
        private constant string SAPPER_DROP_EFFECT                  = "Abilities\\Spells\\Other\\Tornado\\Tornado_Target.mdl"
        
        //This is the attachment point of the drop effect above.
        //Default Value: "chest"
        private constant string SAPPER_DROP_EFFECT_ATTACHPOINT          = "chest"
        
        //This is the effect that is created once a sapper reaches the ground and kindles himself
        //Default Value: "Abilities\\Spells\\Other\\BreathOfFire\\BreathOfFireDamage.mdl"
        private constant string SAPPER_BURN_EFFECT                  = "Abilities\\Spells\\Other\\BreathOfFire\\BreathOfFireDamage.mdl"
        
        //This is the attachment point of the burn effect above
        //Default Value: "chest"
        private constant string SAPPER_BURN_EFFECT_ATTACHPOINT          = "chest"
        
        //This is the effect that is displayed, when a sapper found a target
        //Set it to "" if you want no effect.
        //Default Value: "Abilities\\Spells\\Other\\TalkToMe\\TalkToMe.mdl"
        private constant string SAPPER_TARGET_FOUND_EFFECT          = "Abilities\\Spells\\Other\\TalkToMe\\TalkToMe.mdl"
        
        //This is the attachment point of the target-found effect above
        //Default Value: "overhead"
        private constant string SAPPER_TARGET_FOUND_EFFECT_ATTACHPOINT  = "overhead"
        
        //The effect created by the explosion. Set it to "" for no effect
        //Default Value: "Objects\\Spawnmodels\\Other\\NeutralBuildingExplosion\\NeutralBuildingExplosion.mdl"
        private constant string SAPPER_EXPLOSION_EFFECT             = "Objects\\Spawnmodels\\Other\\NeutralBuildingExplosion\\NeutralBuildingExplosion.mdl"
        
        
        //This boolean decides, whether the movespeed of a sapper should be changed using
        //the native SetUnitMoveSpeed or not. In some maps, changing the movespeed via trigger
        //may cause some bugs with other systems/spells.
        //If you dont want, that the movespeed is changed using SetUnitMoveSpeed, change it in the OE.
        //Default Value: true
        private constant boolean SAPPER_ENABLE_MOVESPEED_CHANGE     = true
        
        //This is the movespeed of sappers. It's only used, if the value above is set to true
        //Default Value: 250.00
        private constant real SAPPER_MOVEMENT_SPEED                     = 250.00
        
        //If this boolean is set a true, a texttag is created above each sapper, showing when it will
        //explode. Please note, that you can only have max. 100 Texttags active at the same time, so
        //disable it, when you think you could reach more than 100.
        //Default Value: true
        private constant boolean SAPPER_SHOW_EXPLOSION_INDICATOR    = true
        
        //This is the color of the texttag. Read the ARGB Readme for mroe information about how to use it.
        //Default Value: 0xFFFF0000 (red)
        private ARGB SAPPER_EXPLOSION_TIME_INDICATOR_COLOR              = 0xFFFF0000
            
        //This is the size of the texttag.
        //Default Value: 10.00
        private constant real SAPPER_EXPLOSION_TIME_INDICATOR_SIZE      = 10.00
            
        //This is the height of the texttag.
        //Default Value: 75.00
        private constant real SAPPER_EXPLOSION_TIME_INDICATOR_HEIGHT    = 75.00
        
        //If this boolean is set to true, the damage will be done by the caster, not by the sapper
        //that exploded. Result of that is, the each unit, that received damage through the explosion
        //will attack the caster. If false, they will just do like nothing, cause they cannnot attack
        //dead units (the sapper).
        //Default Value: true
        private constant boolean SAPPER_EXPLOSION_USE_CASTER_AS_SOURCE  = true
        
        //This is the attack type which xedamage uses once a sapper does suicide or explodes
        //Default Value: ATTACK_TYPE_MAGIC
        private constant attacktype SAPPER_EXPLOSION_ATTACK_TYPE    = ATTACK_TYPE_MAGIC
        
        //This is the damage type which xedamage uses once a sapper does suicide or explodes
        //Default Value: DAMAGE_TYPE_FIRE
        private constant damagetype SAPPER_EXPLOSION_DAMAGE_TYPE    = DAMAGE_TYPE_FIRE
        
        //This is the radius of the explosion.
        //Default Value: 250.00
        private constant real SAPPER_EXPLOSION_RADIUS               = 250.00
        
        //If true, the explosion will also deal damage to destructables in the explosion area
        //Default Value: true
        private constant boolean SAPPER_EXPLOSION_DAMAGE_DESTRUCTS  = true
        
        //If this boolean is set to true, the explosion will also damage allied unit.
        //Default Value: false
        private constant boolean SAPPER_EXPLOSION_DAMAGE_ALLIED     = false
        
        //If this boolean is true, sappers will play a random sound, 
        //which you can add/remove/change in the SAPPER_INIT_SOUNDS textmacro below
        //Default Value: true
        private constant boolean SAPPER_ENABLE_FUNNY_SOUNDS         = true
        
        //This value is only important, if funny sounds of sappers are enabled.
        //Because it may sounds stupid, when 5 sappers speak at the same time, 
        //there is this possibility to give each sapper only a chance to tell something
        //which you can setup with this value.
        //Default Value: 0.33 (33%)
        private constant real SAPPER_FUNNY_SOUND_CHANCE             = 0.30
        
        
    endglobals
    
    
    //in this macro, you can add funny sounds for sappers. 
    //the function you have to call is:
    //call addSapperSound(string soundHandle, real duration)
    //soundHandle is the path of the sound, you can get them i.e from the SoundEditor (F5)
    //duration is the duration of the sound, you can also get this information in the SoundEditor
    //Example: call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperYes1.wav", 1.463)
    //! textmacro SAPPER_INIT_SOUNDS
        
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperYes1.wav", 1.463)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperYes5.wav", 1.434)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperWhat2.wav", 1.694)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperYesAttack3.wav", 2.026)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperYesAttack4.wav", 1.091)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed1.wav", 1.515)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed2.wav", 2.776)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed4.wav", 2.554)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed5.wav", 0.592)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed6.wav", 2.201)
        call addSapperSound("Units\\Creeps\\GoblinSapper\\GoblinSapperPissed7.wav", 2.374)
    
    //! endtextmacro
    
    //This is the amount of sappers dropped each level.
    //Default Value: 3 + lvl
    private constant function SAPPER_AMOUNT takes integer lvl returns integer
        return 3 + lvl
    endfunction
    
    //This is the time, a sapper has until it will explode
    //Default Value: 6.00 + lvl
    private constant function SAPPER_EXPLOSION_TIMER takes integer lvl returns real
        return 6.00 + lvl
    endfunction
    
    //This is the damage a explosion deals.
    //Default Value: 25.00 + 25.00 * lvl
    private constant function SAPPER_EXPLOSION_DAMAGE takes integer lvl returns real
        return 15.00 * lvl
    endfunction
    
    //This is the filter used to get valid targets for sappers.
    //Default Value: not IsUnitType(u, UNIT_TYPE_DEAD) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and IsUnitType(u, UNIT_TYPE_GROUND) and not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE) and IsUnitVisible(u, GetOwningPlayer(sapper)) and IsUnitEnemy(u, GetOwningPlayer(sapper)) 
    private constant function SAPPER_TARGET_SEARCH_FILTER takes unit u, unit sapper returns boolean
        return not IsUnitType(u, UNIT_TYPE_DEAD) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and IsUnitType(u, UNIT_TYPE_GROUND) and not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE) and IsUnitVisible(u, GetOwningPlayer(sapper)) and IsUnitEnemy(u, GetOwningPlayer(sapper)) 
    endfunction
    
    
    /*Zeppelin Setup*/
    globals
    
        //The model of the zeppelin that drops the sappers
        //Default Value: "units\\creeps\\GoblinZeppelin\\GoblinZeppelin.mdl"
        private constant string ZEPPELIN_MODEL                  = "units\\creeps\\GoblinZeppelin\\GoblinZeppelin.mdl"
        
        //The height of the zeppelin. Please note, that the higher this value is, the longer a sapper requires
        //to reach the ground. If you change this value, you may should change the drop speed of the sappers too.
        //Default Value: 500.00
        private constant real ZEPPELIN_HEIGHT                   = 500.00
        
        //The model-size of the zeppelin.
        //Default Value: 0.80
        private constant real ZEPPELIN_SIZE                     = 0.80
        
        //The speed the zeppelin is moving with. This does not effect the distance, when a sapper is dropped
        //The formula for the distance for a sapper drop is:
        //ZEPPELIN_MOVE_DISTANCE / (SAPPER_DROP_AMOUNT(lvl) + 1)
        //Default Value: 400.00
        private constant real ZEPPELIN_SPEED                    = 400.00
        
        //This is the distance the zeppelin moves until is expires.
        //Default Value: 1000.00
        private constant real ZEPPELIN_MOVE_DISTANCE            = 1000.00
        
        //If this boolean is set to true, the zeppelin will display its death animation
        //If false, it will be just removed without any animation
        //Default Value: false
        private constant boolean ZEPPELIN_DESTROY_ON_END        = false
        
        //Zeppelin Sounds
        //This is the sound which is played when the spell is cast. Set this to "" if you want no sound.
        //Default Value: "Units\\Creeps\\GoblinZeppelin\\GoblinZeppelinWhat3.wav"
        private constant string ZEPPELIN_SUMMON_SOUND           = "Units\\Creeps\\GoblinZeppelin\\GoblinZeppelinWhat3.wav"
    
        //This is the duration of the sound above
        //Default Value: 1.838
        private constant real ZEPPELIN_SUMMON_SOUND_DUR         = 1.838
        
        //This sound is played whenever a zeppelin drops a sapper. Set it to "" if you want no sound.
        //Default Value: "Abilities\\Spells\\Other\\LoadUnload\\Loading.wav"
        private constant string ZEPPELIN_SAPPER_DROP_SOUND      = "Abilities\\Spells\\Other\\LoadUnload\\Loading.wav"
    
        //This is the duration of the sound above
        //Default Value: 0.74
        private constant real ZEPPELIN_SAPPER_DROP_SOUND_DUR    = 0.74
    
    endglobals
    
  //=================================================================//
 // Do not touch anything below unless you know what you are doing! //
//=================================================================//
    
    private keyword Main
    private keyword Zeppelin
    private keyword Sapper
    
    private struct Sapper
        unit caster = null
        unit target = null
        unit sapper = null
        
        real time = 0.00
        real x = 0.00
        real y = 0.00
        real tx = 0.00
        real ty = 0.00
        real z = 0.00
        real explosion = 0.00
        
        texttag explosionIndicator = null
        
        integer lvl = 0
        
        effect dropEffect = null
        effect burnEffect = null
        
        player owner = null
        
        boolean onGround = false
        boolean oldTargetDied = false
        
        static trigger onDeath = CreateTrigger()
        static trigger onOrder = CreateTrigger()
        static timer ticker = CreateTimer()
        static thistype temp = 0
        static HandleTable sapperTable = 0
        static HandleTable targetTable = 0
        static delegate xedamage dmg = 0
        static boolean ignoreOrders = false
        static real dropSpeed = SAPPER_DROP_SPEED * TIMER_INTERVAL
        
        static integer array sapperSound
        static integer sapperSoundAmount = 0
        
        implement List
        
        static method addSapperSound takes string soundHandle, real duration returns nothing
            set sapperSound[sapperSoundAmount] = DefineSound(soundHandle, R2I(duration * 1000), false, true)
            set sapperSoundAmount = sapperSoundAmount + 1
        endmethod
        
        static method unitFilter takes nothing returns boolean
            return SAPPER_TARGET_SEARCH_FILTER(GetFilterUnit(), temp.sapper)
        endmethod
        
        method onDestroy takes nothing returns nothing
            call sapperTable.flush(sapper)
        
            call listRemove()
            if count == 0 then
                call PauseTimer(ticker)
            endif
            
            static if SAPPER_SHOW_EXPLOSION_INDICATOR then
                call DestroyTextTag(explosionIndicator)
            endif
        endmethod
        
        method searchForTarget takes nothing returns boolean
            set temp = this
            call GroupEnumUnitsInArea(ENUM_GROUP, x, y, SAPPER_TARGET_SEARCH_AREA, Condition(function thistype.unitFilter))
            //These are valid BJ's which SHOULD be used...
            if CountUnitsInGroup(ENUM_GROUP) > 0 then
                set target = GroupPickRandomUnit(ENUM_GROUP)
                //Using the table to save whether a unit is already registred to the trigger or not
                if targetTable[target] == 0 then
                    call TriggerRegisterUnitEvent(onDeath, target, EVENT_UNIT_DEATH)
                    set targetTable[target] = 1
                endif
                set tx = GetUnitX(target)
                set ty = GetUnitY(target)
                call IssueTargetOrder(sapper, "attack", target)
                            
                if SAPPER_TARGET_FOUND_EFFECT != "" then
                    call DestroyEffect(AddSpecialEffectTarget(SAPPER_TARGET_FOUND_EFFECT, sapper, SAPPER_TARGET_FOUND_EFFECT_ATTACHPOINT))
                endif
                            
                static if SAPPER_ENABLE_FUNNY_SOUNDS then
                    if GetRandomReal(0.00, 1.00) <= SAPPER_FUNNY_SOUND_CHANCE then
                        call RunSoundOnUnit(sapperSound[GetRandomInt(0, sapperSoundAmount - 1)], sapper)
                    endif
                endif
            else
                set target = null
            endif
            return target != null
        endmethod
        
        
        method moveSapper takes nothing returns nothing
            if target == null then
                static if not SAPPER_STOP_WHEN_TARGET_DIES then
                    if oldTargetDied then
                        call IssuePointOrder(sapper, "smart", tx, ty)
                    else
                        call PauseUnit(sapper, true)
                        call IssueImmediateOrder(sapper, "stop")
                        call PauseUnit(sapper, false)
                    endif
                else
                    call PauseUnit(sapper, true)
                    call IssueImmediateOrder(sapper, "stop")
                    call PauseUnit(sapper, false)
                endif
            else
                if not IsUnitVisible(target, owner) then
                        
                    if GetUnitCurrentOrder(sapper) == 851983 then
                        //if target becomes invisible or gets out of sight, the sapper will
                        //run to the position, where the target was last seen.
                        call IssuePointOrder(sapper, "smart", tx, ty)
                    endif
                            
                else                            
                    if IsUnitType(target, UNIT_TYPE_DEAD) then
                        if not searchForTarget() then
                            set oldTargetDied = true
                            static if not SAPPER_STOP_WHEN_TARGET_DIES then
                                call IssuePointOrder(sapper, "smart", tx, ty)
                            else
                                call PauseUnit(sapper, true)
                                call IssueImmediateOrder(sapper, "stop")
                                call PauseUnit(sapper, false)
                            endif
                        else
                            set oldTargetDied = false
                        endif
                    elseif GetUnitCurrentOrder(sapper) != 851983 then
                        call IssueTargetOrder(sapper, "attack", target)
                    endif
                endif
            endif
        endmethod
        
        static method onLoop takes nothing returns nothing
            local thistype this = first
            local real dx = 0.00
            local real dy = 0.00
            
            set ignoreOrders = true
            loop
                exitwhen this == 0
                if not onGround then
                    call SetUnitZ(sapper, GetUnitZ(sapper) - dropSpeed)
                    if GetUnitZ(sapper) <= 0.01 then
                    
                        static if SAPPER_INVULNERABLE_WHILE_FALLING then
                            call SetUnitInvulnerable(sapper, false)
                        endif
                        
                        if dropEffect != null then
                            call DestroyEffect(dropEffect)
                        endif
                        
                        if SAPPER_BURN_EFFECT != "" then
                            set burnEffect = AddSpecialEffectTarget(SAPPER_BURN_EFFECT, sapper, SAPPER_BURN_EFFECT_ATTACHPOINT)
                        endif
                        
                        static if SAPPER_SHOW_EXPLOSION_INDICATOR then
                            set explosionIndicator = CreateTextTag()
                            call SetTextTagVisibility(explosionIndicator, true)
                            call SetTextTagPermanent(explosionIndicator, true)
                            call SetTextTagText(explosionIndicator, I2S(R2I(explosion + 0.5)), SAPPER_EXPLOSION_TIME_INDICATOR_SIZE * 0.0023)
                            call SetTextTagColor(explosionIndicator, SAPPER_EXPLOSION_TIME_INDICATOR_COLOR.red, SAPPER_EXPLOSION_TIME_INDICATOR_COLOR.green, SAPPER_EXPLOSION_TIME_INDICATOR_COLOR.blue, SAPPER_EXPLOSION_TIME_INDICATOR_COLOR.alpha)
                            call SetTextTagPos(explosionIndicator, x, y, GetUnitZ(sapper) + SAPPER_EXPLOSION_TIME_INDICATOR_HEIGHT)
                        endif
            
                        set onGround = true
                    endif
                else
                    set x = GetUnitX(sapper)
                    set y = GetUnitY(sapper)
                    
                    set explosion = explosion - TIMER_INTERVAL
                    
                    static if SAPPER_SHOW_EXPLOSION_INDICATOR then
                        call SetTextTagPos(explosionIndicator, x, y, GetUnitZ(sapper) + SAPPER_EXPLOSION_TIME_INDICATOR_HEIGHT)
                        call SetTextTagText(explosionIndicator, I2S(R2I(explosion + 0.5)), SAPPER_EXPLOSION_TIME_INDICATOR_SIZE * 0.0023)
                    endif
                    
                    if explosion <= 0 then
                        call SetUnitExploded(sapper, true)
                        call KillUnit(sapper)
                        call SetUnitAnimationByIndex(sapper, SAPPER_SUICIDE_ANIMATION_ID)
                        call destroy()
                    endif
                    
                    if target == null then
                        call searchForTarget()
                    else
                        call moveSapper()
                        
                        if IsUnitVisible(target, owner) then
                            set tx = GetUnitX(target)
                            set ty = GetUnitY(target)
                            
                            set dx = x - tx
                            set dy = y - ty
                            if (dx * dx + dy * dy) <= SAPPER_SUICIDE_RANGE * SAPPER_SUICIDE_RANGE then
                                call SetUnitExploded(sapper, true)
                                call KillUnit(sapper)
                                call SetUnitAnimationByIndex(sapper, SAPPER_SUICIDE_ANIMATION_ID)
                                call destroy()
                            endif
                        endif
                    endif
                        
                endif
                    
                set this = next
            endloop
            set ignoreOrders = false
        endmethod
        
        static method create takes Zeppelin data returns thistype
            local thistype this = allocate()
            set caster = data.caster
            set y = data.y
            set x = data.x
            set z = data.z
            set lvl = data.lvl
            set explosion = SAPPER_EXPLOSION_TIMER(lvl)
            
            set sapper = CreateUnit(GetOwningPlayer(caster), SAPPER_UNIT_ID, x, y, data.xyangle * bj_RADTODEG)
            set owner = GetOwningPlayer(sapper)
            
            static if not LIBRARY_AutoFly then
                call UnitAddAbility(sapper, XE_HEIGHT_ENABLER)
                call UnitRemoveAbility(sapper, XE_HEIGHT_ENABLER)
            endif
            
            static if SAPPER_INVULNERABLE_WHILE_FALLING then
                call SetUnitInvulnerable(sapper, true)
            endif
            
            if SAPPER_DROP_EFFECT != "" then
                set dropEffect = AddSpecialEffectTarget(SAPPER_DROP_EFFECT, sapper, SAPPER_DROP_EFFECT_ATTACHPOINT)
            endif
            
            call SetUnitZ(sapper, z)
            call TriggerRegisterUnitEvent(onDeath, sapper, EVENT_UNIT_DEATH)
            
            set sapperTable[sapper] = integer(this)
            
            call listAdd()
            if count == 1 then
                call TimerStart(ticker, TIMER_INTERVAL, true, function thistype.onLoop)
            endif
            return this
        endmethod
        
        static method onUnitDeath takes nothing returns boolean
            local unit killed = GetDyingUnit()
            local thistype this = thistype(sapperTable[killed])
            if this != 0 then
            
                static if SAPPER_EXPLOSION_USE_CASTER_AS_SOURCE then
                    call damageAOE(caster, x, y, SAPPER_EXPLOSION_RADIUS, SAPPER_EXPLOSION_DAMAGE(lvl))
                else
                    call damageAOE(sapper, x, y, SAPPER_EXPLOSION_RADIUS, SAPPER_EXPLOSION_DAMAGE(lvl))
                endif
                    
                static if SAPPER_EXPLOSION_DAMAGE_DESTRUCTS then
                    call damageDestructablesAOE(caster, x, y, SAPPER_EXPLOSION_RADIUS, SAPPER_EXPLOSION_DAMAGE(lvl))
                endif
                if SAPPER_EXPLOSION_EFFECT != "" then
                    call DestroyEffect(AddSpecialEffect(SAPPER_EXPLOSION_EFFECT, x, y))
                endif
            else
                //loop through everything and check targets. if the dying unit is a target of any sapper, find a new one
                //or order it to move to the target's location if enabled
                set this = first
                loop
                    exitwhen this == 0
                    if killed == target then
                        set oldTargetDied = true
                        if not searchForTarget() then
                            static if not SAPPER_STOP_WHEN_TARGET_DIES then
                                set tx = GetUnitX(killed)
                                set ty = GetUnitY(killed)
                                call IssuePointOrder(sapper, "smart", tx, ty)
                            else
                                call PauseUnit(sapper, true)
                                call IssueImmediateOrder(sapper, "stop")
                                call PauseUnit(sapper, false)
                            endif
                        endif
                    endif
                    set this = next
                endloop
            endif
            set killed = null
            return false
        endmethod
        
        static method onUnitOrder takes nothing returns boolean
            local thistype this = thistype(sapperTable[GetOrderedUnit()])
            if this != 0 and not ignoreOrders then
                set ignoreOrders = true
                call moveSapper()
                set ignoreOrders = false
            endif
            return false
        endmethod
        
        static method onInit takes nothing returns nothing
            set sapperTable = HandleTable.create()
            set targetTable = HandleTable.create()
            
            set dmg = xedamage.create()
            set dtype = SAPPER_EXPLOSION_DAMAGE_TYPE
            set atype = SAPPER_EXPLOSION_ATTACK_TYPE
            set damageAllies = SAPPER_EXPLOSION_DAMAGE_ALLIED
            
            //! runtextmacro SAPPER_INIT_SOUNDS()
            
            call TriggerAddCondition(onDeath, Condition(function thistype.onUnitDeath))
            
            call TriggerRegisterAnyUnitEventBJ(onOrder, EVENT_PLAYER_UNIT_ISSUED_ORDER)
            call TriggerRegisterAnyUnitEventBJ(onOrder, EVENT_PLAYER_UNIT_ISSUED_POINT_ORDER)
            call TriggerRegisterAnyUnitEventBJ(onOrder, EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER)
            call TriggerRegisterAnyUnitEventBJ(onOrder, EVENT_PLAYER_UNIT_ISSUED_UNIT_ORDER)
            call TriggerAddCondition(onOrder, Condition(function thistype.onUnitOrder))
        endmethod
        
    endstruct
            
    private struct Zeppelin
        
        unit caster = null
        
        real cos = 0.00
        real sin = 0.00
        real moved = 0.00
        
        delegate xefx model = 0
        
        sound summonSound = null
        
        integer lvl = 0
        integer sapperDropped = 0
        integer sapperToDrop = 0
        
        real sapperDropCounter = 0.00
        
        static integer zeppelinSummonSound = 0
        static integer zeppelinDropSound = 0
        
        static timer ticker = CreateTimer()
        static real speed = TIMER_INTERVAL * ZEPPELIN_SPEED
        
        implement List
        
        
        method onDestroy takes nothing returns nothing
        
            static if not ZEPPELIN_DESTROY_ON_END then
                call model.hiddenDestroy()
            else
                call model.destroy()
            endif
        
            call listRemove()
            if count == 0 then
                call PauseTimer(ticker)
            endif
        endmethod
        
        static method onLoop takes nothing returns nothing
            local thistype this = first
            
            loop
                exitwhen this == 0
                set x = x + cos
                set y = y + sin
                
                static if USE_SOUNDS then
                    if summonSound != null then
                        call SetSoundPosition(summonSound, x, y, z)
                    endif
                endif
                
                set moved = moved + speed
                set sapperDropCounter = sapperDropCounter + speed
                
                if sapperDropCounter >= ZEPPELIN_MOVE_DISTANCE / (sapperToDrop + 1) then
                    set sapperDropCounter = 0.00
                    call Sapper.create(this)
                    
                    static if USE_SOUNDS then
                        if zeppelinDropSound != 0 then
                            call RunSoundAtPoint(zeppelinDropSound, x, y, z)
                        endif
                    endif
                endif

                if moved >= ZEPPELIN_MOVE_DISTANCE then
                    call destroy()
                endif
                
                set this = next
            endloop
            
        endmethod
        
        static method create takes nothing returns thistype
            local thistype this = allocate()
            
            set sin = ZEPPELIN_SPEED * TIMER_INTERVAL * Sin(Main.angle)
            set cos = ZEPPELIN_SPEED * TIMER_INTERVAL * Cos(Main.angle)
            set caster = Main.caster
            set lvl = GetUnitAbilityLevel(caster, SPELL_ID)
            set sapperToDrop = SAPPER_AMOUNT(lvl)
            
            set model = xefx.create(Main.cx, Main.cy, Main.angle)
            set fxpath = ZEPPELIN_MODEL
            set z = ZEPPELIN_HEIGHT
            set scale = ZEPPELIN_SIZE 
            set teamcolor = GetPlayerColor(GetOwningPlayer(caster))
            set owner = GetOwningPlayer(caster)
            
            static if USE_SOUNDS then
                if ZEPPELIN_SUMMON_SOUND != "" then
                    call RunSoundAtPoint(zeppelinSummonSound, x, y, z)
                endif
            endif
            
            call listAdd()
            if count == 1 then
                call TimerStart(ticker, TIMER_INTERVAL, true, function thistype.onLoop)
            endif
            return this
        endmethod
        
        static method onInit takes nothing returns nothing
            static if USE_SOUNDS then
                if ZEPPELIN_SUMMON_SOUND != "" then
                    set zeppelinSummonSound = DefineSound(ZEPPELIN_SUMMON_SOUND, R2I(ZEPPELIN_SUMMON_SOUND_DUR * 1000), false, true)
                endif
                
                if ZEPPELIN_SAPPER_DROP_SOUND != "" then
                    set zeppelinDropSound = DefineSound(ZEPPELIN_SAPPER_DROP_SOUND, R2I(ZEPPELIN_SAPPER_DROP_SOUND_DUR * 1000), false, true)
                endif
            endif
        endmethod
        
    endstruct
    
    private struct Main extends array
    
        static unit caster = null
        static integer lvl = 0
        static real cx = 0.00
        static real cy = 0.00
        static real angle = 0.00
        
        static method onCast takes nothing returns boolean
            if GetSpellAbilityId() != SPELL_ID then
                return false
            endif
            set caster = GetSpellAbilityUnit()
            set lvl = GetUnitAbilityLevel(caster, SPELL_ID)
            set cx = GetUnitX(caster)
            set cy = GetUnitY(caster)
            
            set angle = Atan2(GetSpellTargetY() - cy, GetSpellTargetX() - cx)
            
            call Zeppelin.create()
            return false
        endmethod
        
        private static trigger cast = CreateTrigger()
        
        static method onInit takes nothing returns nothing
            call TriggerRegisterAnyUnitEventBJ(cast, EVENT_PLAYER_UNIT_SPELL_EFFECT)
            call TriggerAddCondition(cast, Condition(function thistype.onCast))
            
            static if LIBRARY_AbilityPreload then
                call AbilityPreload(SPELL_ID)
            endif
        endmethod
        
    endstruct
    
    
endscope

//TESH.scrollpos=0
//TESH.alwaysfold=0
function Trig_Testmap_Actions takes nothing returns nothing
    if IsUnitType(gg_unit_N000_0001, UNIT_TYPE_DEAD) then
        call ReviveHero(gg_unit_N000_0001, GetUnitX(gg_unit_N000_0001), GetUnitY(gg_unit_N000_0001), true)
    endif
    call SetUnitState(gg_unit_N000_0001, UNIT_STATE_MANA, GetUnitState(gg_unit_N000_0001, UNIT_STATE_MAX_MANA))
    call SetUnitState(gg_unit_N000_0001, UNIT_STATE_LIFE, GetUnitState(gg_unit_N000_0001, UNIT_STATE_MAX_LIFE))
    call SetUnitState(gg_unit_N000_0001, UNIT_STATE_MANA, GetUnitState(gg_unit_N000_0001, UNIT_STATE_MAX_MANA))
    call UnitResetCooldown(gg_unit_N000_0001)
endfunction

function Trig_Testmap_Info takes nothing returns nothing
    call BJDebugMsg("|cffffcc00Suicide Squad Version 1.0b|r")
    call BJDebugMsg("\nMade by: |cffffcc00Kricz|r")
    call BJDebugMsg("Please give credits if you use this spell or the awesome terrain |cffffcc00:D|r")
    call BJDebugMsg("\n\nPress |cffffcc00Esc|r to revive and/or refresh your hero's cooldowns, life and mana.")
endfunction

//===========================================================================
function InitTrig_Testmap takes nothing returns nothing
    set gg_trg_Testmap = CreateTrigger()
    call TriggerRegisterPlayerEvent(gg_trg_Testmap, Player(0), EVENT_PLAYER_END_CINEMATIC)
    call TriggerAddAction(gg_trg_Testmap, function Trig_Testmap_Actions)
    call Trig_Testmap_Info()
endfunction