Anitarf's Olympic Spellpack

scope Illuminate initializer Init

//*****************************************************************
//*  spell - Illuminate
//*
//*  written by: Anitarf
//*  requires: -xebasic
//*            -xepreload
//*            -xecast
//*            -xedamage
//*            -ABuff (requires periodic events)
//*
//*            -a unit or area target or instant triggerer ability
//*            -a unit target buff ability
//*            -a buff used by the buff ability
//*
//*  description: Creates a buff on all enemy units in an area
//*               that gives you vision of those units and deals
//*               damage to them over time.
//*
//*  technical: The vision is granted by a faerie-fire based spell
//*             that is cast by dummy casters, since these casters
//*             must be owned by the player who cast the spell this
//*             spell is unable to affect units that the owner of
//*             the casting unit can't see.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A007' //the spell that applies the ABuff
        private constant integer BUFF_SPELL = 'A009' //the buff spell used by the dummy caster
        private constant string BUFF_SPELL_ORDER = "faeriefire"
        private constant integer BUFF_BUFF = 'B002' //the buff applied by the buff spell
    endglobals

    private constant function InitialDamage takes integer level returns real
        return 0.0 //the damage dealt when the spell is cast
    endfunction

    private constant function BuffApplyRadius takes integer level returns real
        return 100.0+50.0*level //the area in which the buff is applied
    endfunction
    private constant function BuffDuration takes integer level returns real
        return 30.0 //the duration of the buff
    endfunction
    
    private constant function BuffDPS takes integer level returns real
        return 1.0+2.0*level //the damage per second that the buff deals
    endfunction

    private function DamageOptions takes xedamage spellDamage returns nothing
        //useful read: [url]http://www.wc3campaigns.net/showpost.php?p=1030046&postcount=19[/url]
        set spellDamage.dtype=DAMAGE_TYPE_UNIVERSAL
        set spellDamage.atype=ATTACK_TYPE_NORMAL
        set spellDamage.tag=0 //the tag attached to the damage by xedamage
        //in this case xedamage is also used to determine which units are valid targets for the buff
        set spellDamage.exception=UNIT_TYPE_STRUCTURE //deal no damage to structures
        set spellDamage.visibleOnly=true //since dummy casters can't target invisible units, this spell can't affect them
    endfunction

// END OF CALIBRATION SECTION
// ================================================================

    globals
        private aBuffType abt
        private xecast xec
        private xedamage xed
    endglobals

    //ABuff functions
    private function CreateRefresh takes aBuff eventBuff returns nothing
        set xec.owningplayer=GetOwningPlayer(eventBuff.caster)
        set xec.level=eventBuff.level
        call xec.castOnTarget(eventBuff.target.u)
    endfunction
    private function Periodic takes aBuff eventBuff returns nothing
        call xed.damageTarget(eventBuff.caster, eventBuff.target.u, BuffDPS(eventBuff.level)*ABuff_PERIODIC_EVENT_PERIOD)
    endfunction
    private function Cleanup takes aBuff eventBuff returns nothing
        local integer i=0
        loop
            //in case the buff is destroyed immediately when it's applied, wait until the buff spell is cast
            exitwhen GetUnitAbilityLevel(eventBuff.target.u, BUFF_BUFF)>0
            //safety timeout, in case the buff spell was already cast but then the buff was removed somehow
            exitwhen i>5
            call TriggerSleepAction(0.0)
            set i=i+1
        endloop
        call UnitRemoveAbility(eventBuff.target.u, BUFF_BUFF)
    endfunction

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

    globals
        private group tempg = CreateGroup()
        private boolexpr tempbx
        private unit tempcaster
        private integer templevel
    endglobals

    private function Targets takes nothing returns boolean
        local unit u=GetFilterUnit()
        if IsUnitInRangeXY(u, GetUnitX(u), GetUnitY(u), BuffApplyRadius(templevel)) and xed.allowedTarget(tempcaster,u) then
            call xed.damageTarget(tempcaster, u, InitialDamage(templevel))
            call ABuffApply(abt, u, tempcaster, BuffDuration(templevel), templevel, 0 )
        endif
        set u=null
        return false
    endfunction

    private function SpellEffect takes nothing returns nothing
        local unit u
        local location l
        if GetSpellAbilityId() == SPELL_ABILITY then
            set tempcaster=GetTriggerUnit()
            set templevel=GetUnitAbilityLevel(tempcaster, SPELL_ABILITY)
            set u = GetSpellTargetUnit()
            if u == null then
                set l = GetSpellTargetLoc()
                if GetLocationX(l)==0.0 and GetLocationY(l)==0.0 then
                    //no-target cast
                    call GroupEnumUnitsInRange(tempg,GetUnitX(tempcaster),GetUnitY(tempcaster),BuffApplyRadius(templevel)+XE_MAX_COLLISION_SIZE,tempbx)
                else
                    //point-target cast
                    call GroupEnumUnitsInRange(tempg,GetLocationX(l),GetLocationY(l),BuffApplyRadius(templevel)+XE_MAX_COLLISION_SIZE,tempbx)
                endif
                call RemoveLocation(l)
                set l = null
            else
                //unit-target cast
                call GroupEnumUnitsInRange(tempg,GetUnitX(u),GetUnitY(u),BuffApplyRadius(templevel)+XE_MAX_COLLISION_SIZE,tempbx)
                set u = null
            endif
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )

        //init buff filter
        set tempbx=Condition(function Targets)

        //init xecast 
        set xec=xecast.create()
        set xec.abilityid=BUFF_SPELL
        set xec.orderstring=BUFF_SPELL_ORDER

        //init xedamage
        set xed=xedamage.create()
        call DamageOptions(xed)

        //init aBuffType
        call XE_PreloadAbility(BUFF_SPELL)

        set abt=aBuffType.create()
        set abt.eventCreate = ABuffEvent_Create.CreateRefresh
        set abt.eventRefresh = ABuffEvent_Refresh.CreateRefresh
        set abt.eventCleanup = ABuffEvent_Cleanup.Cleanup
        set abt.eventPeriodic = ABuffEvent_Periodic.Periodic
    endfunction

endscope

scope GlacialWall initializer Init

//*****************************************************************
//*  spell - Glacial Wall
//*
//*  written by: Anitarf
//*  requires: -xebasic
//*            -xepreload
//*            -TimerUtils
//*            -LineSegment
//*            -ABuff
//*
//*            -a point target triggerer ability
//*            -a unit to be used as the wall
//*            -a chaos ability that makes the wall unit
//*            -a self-targetting aura for displaying the buff
//*            -a buff that gets displayed by the aura
//*
//*  description: Creates a wall of ice at a target point that
//*               is perpendicular to the facing of the caster.
//*               Enemy units approaching the wall will be slowed
//*               for a short duration.
//*
//*  technical: The unit used to make the wall may be created at
//*             an offset from the intended point due to pathing.
//*             For that reason, the unit gets forcefuly moved to
//*             the intended position after it is created; for that
//*             to work, the unit must have a movement speed. Since
//*             it has a movement speed, players can order it to
//*             move. In order to prevent players from doing that,
//*             it must be made unselectable, but if we use locust
//*             to do that then the unit will no longer be treated
//*             as an obstacle. Luckily, a trick exists that allows
//*             locusted units to still be treated as obstacles
//*             (and also be attacked), it works by adding locust
//*             to a unit after it has been transformed with a
//*             chaos ability, this spell uses this trick.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A004' //the spell ability
        private constant real SPELL_PERIOD = 0.5 //how often is wall's buff applied on nearby units
        private constant integer CHAOS_ABILITY = 'S000' //the chaos transform ability that makes wall units
        private constant integer BUFF_ABILITY = 'A005' //the self-targetting aura that displays the buff and slows units
        private constant integer BUFF_BUFF = 'Bfro' //the buff applied by the self-targetting aura
      
        //Visual settings
        private constant real WALL_UNIT_MAX_OFFSET = 48.0 //adds a bit of randomness to wall unit placement
        private constant boolean WALL_UNIT_RANDOM_FACING = true //if true, will choose a random facing angle for wall units
        private constant real WALL_UNIT_FACING = 0.0 //the facing of wall units relative to the caster's (in degrees)
    endglobals

    //spell stats
    private constant function WallDuration takes integer level returns real
        return 3.0+3.0*level //how long the wall lasts; should be longer than the time it takes to spawn all the wall units
    endfunction
    private constant function WallLength takes integer level returns real
        return 250.0+level*250.0 //the distance between the two farthest wall units
    endfunction
    private constant function WallUnitInterval takes integer level returns real
        return 0.1 //the time between wall units being created
    endfunction
    private constant function WallUnitCount takes integer level returns integer
        return 5+4*level //number of units per wall, must be more than 1
    endfunction

    private function BuffTargets takes unit inRange, player wallOwner returns boolean
        return not(IsUnitType(inRange, UNIT_TYPE_FLYING)) and IsUnitEnemy(inRange, wallOwner) and GetWidgetLife(inRange)>0.405 //units affected by the buff
    endfunction
    private constant function BuffApplyRadius takes integer level returns real
        return 128.0 //the distance from the wall at which the buff is applied
    endfunction
    private constant function BuffDuration takes integer level returns real
        return 3.0 //the duration of the buff
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    private keyword instance
    globals
        private aBuffType abt
        private timer slow
        private instance array instances
        private integer instanceCount = 0

        private group tempg = CreateGroup()
        private boolexpr tempbx
        private instance tempsi
    endglobals

    //Applying the wall buff
    private function Targets takes nothing returns boolean
        return BuffTargets(GetFilterUnit(), tempsi.owner)
    endfunction

    private function Periodic takes nothing returns nothing
        local integer i=0
        local real r
        local unit u
        loop
            exitwhen i>=instanceCount
            set tempsi = instances[i]
            set r = tempsi.segments/2.0
            call GroupEnumUnitsInRangeOfSeg(tempg, tempsi.x-tempsi.dx*r,tempsi.y-tempsi.dy*r, tempsi.x+tempsi.dx*r,tempsi.y+tempsi.dy*r, BuffApplyRadius(tempsi.level), tempbx)
            loop
                set u=FirstOfGroup(tempg)
                exitwhen u==null
                call ABuffApply(abt, u, tempsi.caster, BuffDuration(tempsi.level), tempsi.level, 0 )
                call GroupRemoveUnit(tempg, u)
            endloop
            set i=i+1
        endloop
    endfunction

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

    //ABuff functions
    private function Create takes aBuff eventBuff returns nothing
        call UnitAddAbility(eventBuff.target.u, BUFF_ABILITY)
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
        call UnitMakeAbilityPermanent(eventBuff.target.u, true, BUFF_ABILITY) //prevent morphing from removing the ability
    endfunction
    private function Refresh takes aBuff eventBuff returns nothing
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
    endfunction
    private function Cleanup takes aBuff eventBuff returns nothing
        call UnitRemoveAbility(eventBuff.target.u, BUFF_ABILITY)
        call UnitRemoveAbility(eventBuff.target.u, BUFF_BUFF)
    endfunction

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

    //Wall units
    private function SpellExpire takes nothing returns nothing
        local instance si = instance(GetTimerData(GetExpiredTimer()))
        call si.destroy() //timer gets cleaned up in the onDestroy method
    endfunction

    private function SpawnUnit takes instance si, real facing, integer side returns nothing
        local real offset=GetRandomReal(-WALL_UNIT_MAX_OFFSET, WALL_UNIT_MAX_OFFSET)
        local real x=si.x+si.dx*si.segments/2.0*side+Cos(si.angle)*offset
        local real y=si.y+si.dy*si.segments/2.0*side+Sin(si.angle)*offset
        local unit u
        if WALL_UNIT_RANDOM_FACING then
            set facing=GetRandomReal(0,360)
        endif
        set u=CreateUnit(si.owner, XE_DUMMY_UNITID, x, y, facing)
        call UnitAddAbility(u, CHAOS_ABILITY) //chaos transform
        call UnitAddAbility(u, 'Aloc') //locust; makes unit unselectable, but thanks to chaos transformation it still blocks pathing
        call IssueImmediateOrder(u, "holdposition")
        call SetUnitX(u, x) //override unit's pathing to put it in position
        call SetUnitY(u, y)
        call GroupAddUnit(si.wallunits, u)
        set u = null
    endfunction
    private function SpawnSegment takes nothing returns nothing
        local instance si = instance(GetTimerData(GetExpiredTimer()))
        local real facing = si.angle*bj_RADTODEG+WALL_UNIT_FACING
        call SpawnUnit(si, facing, 1)
        if si.segments!=0 then
            call SpawnUnit(si, facing, -1)
        endif
        if si.segments>=WallUnitCount(si.level)-1 then //wait the remaining duration
            call TimerStart(si.t, WallDuration(si.level)-((si.segments/2)*WallUnitInterval(si.level)), false, function SpellExpire)
        else //wait for the next interval
            set si.segments=si.segments+2
            call TimerStart(si.t, WallUnitInterval(si.level), false, function SpawnSegment)
        endif
    endfunction

    private function DestroyWallEnum takes nothing returns nothing
        local unit u = GetEnumUnit()
        local real x = GetUnitX(u)
        local real y = GetUnitY(u)
        call KillUnit(u) //this triggers a pathing check it seems
        call SetUnitX(u, x) //override unit's pathing to put it back in position
        call SetUnitY(u, y)
        set u= null
    endfunction

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

    //Spell instance
    private struct instance
        private integer index

        real x
        real y
        real dx
        real dy
        real angle
        integer segments=0
        unit caster
        player owner
        integer level
        timer t
        group wallunits

        static method create takes unit caster, integer level, real targetx, real targety returns instance
            local instance si=instance.allocate()
            local real length=WallLength(level)
            local real count=WallUnitCount(level)
            set si.angle=Atan2(targety-GetUnitY(caster), targetx-GetUnitX(caster))
            set si.caster=caster
            set si.owner=GetOwningPlayer(caster)
            set si.level=level
            set si.x=targetx
            set si.y=targety
            set si.dx=Sin(si.angle)*length/(count-1) //offsets between units
            set si.dy=-Cos(si.angle)*length/(count-1)

            if count/2==count/2.0 then //even, start with one segment
                set si.segments=1
            endif
            if si.wallunits==null then //create a group if this is the first time this instance id is used
                set si.wallunits=CreateGroup()
            endif
            set si.t=NewTimer()
            call SetTimerData(si.t, integer(si))
            call TimerStart(si.t, 0.0, false, function SpawnSegment)

            if instanceCount==0 then //slow timer
                set slow=NewTimer()
                call TimerStart(slow, SPELL_PERIOD, true, function Periodic)
            endif

            set instances[instanceCount]=si
            set si.index=instanceCount
            set instanceCount=instanceCount+1
            return si
        endmethod
        
        method onDestroy takes nothing returns nothing
            set instanceCount=instanceCount-1
            set instances[this.index]=instances[instanceCount]
            set instances[instanceCount].index=this.index

            call ForGroup(this.wallunits, function DestroyWallEnum)
            call GroupClear(this.wallunits) //the next time this instance id is used we won't need to create a group
            call ReleaseTimer(this.t)
            if instanceCount==0 then
                call ReleaseTimer(slow)
            endif
        endmethod
    endstruct

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

    private function SpellEffect takes nothing returns nothing
        local integer lvl
        local location l
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl =GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            set l = GetSpellTargetLoc()
            call instance.create(GetTriggerUnit(), lvl, GetLocationX(l), GetLocationY(l))
            call RemoveLocation(l)
            set l = null
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )
        
        //init buff filter
        set tempbx=Condition(function Targets)

        //init aBuffType
        call XE_PreloadAbility(BUFF_ABILITY)
        call XE_PreloadAbility(CHAOS_ABILITY)
        
        set abt=aBuffType.create()
        set abt.ignoreAsBuff = true
        set abt.eventCreate = ABuffEvent_Create.Create
        set abt.eventRefresh = ABuffEvent_Refresh.Refresh
        set abt.eventCleanup = ABuffEvent_Cleanup.Cleanup
    endfunction

endscope

scope LightningBlast initializer Init

//*****************************************************************
//*  spell - Lightning Blast
//*
//*  written by: Anitarf
//*  requires: -GroupGet
//*            -xebasic
//*            -xedamage
//*            -TimerUtils
//*
//*            -a unit target triggerer ability
//*
//*  description: Summons lightning from the sky which forks until
//*               it hits all of the affected units, damaging them.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A006' //the spell ability
        private constant integer MAX_TARGETS = 7 //the maximum number of units ever affected by the spell
        
        //Visual settings
        private constant string LIGHTNING_TYPE = "CHIM" //the type of lightning used
        private constant real LIGHTNING_DURATION = 0.25 //how long the lightning effect persists
        private constant real MAX_START_OFFSET = 256.0 //how far away from the target can a lightning start
        private constant real MAX_NODE_OFFSET = 128.0 //randomization of node positions
        private constant real START_HEIGHT = 1024.0 //the height where the lightning strikes from
        // At what percentage of the height of the previous node does a node fork
        private constant real FORK_HEIGHT_FACTOR = 0.55 //should be more than 0 and less than 1
        // When lightning forks, each fork gets a random number of targets, this ensures a more even split when there are many targets
        private constant integer MAX_FORK_TARGETCOUNT_DIFFERENCE = 2 //should be greater than 0
    endglobals

    private constant function TargetRadius takes integer level returns real
        return 512.0 //The radius in which to look for targets
    endfunction
    private constant function TargetMaxCount takes integer level returns integer
        return level*2+1 //Maximum number of targets affected
    endfunction
    private constant function Damage takes integer level returns real
        return 50.0+25.0*level
    endfunction

    private function DamageOptions takes xedamage spellDamage returns nothing
        //useful read: [url]http://www.wc3campaigns.net/showpost.php?p=1030046&postcount=19[/url]
        set spellDamage.dtype=DAMAGE_TYPE_UNIVERSAL
        set spellDamage.atype=ATTACK_TYPE_NORMAL
        set spellDamage.tag=0 //the tag attached to the damage by xedamage
        set spellDamage.exception=UNIT_TYPE_STRUCTURE
        call spellDamage.useSpecialEffect(GetAbilityEffectById(SPELL_ABILITY, EFFECT_TYPE_TARGET, 0), "origin")
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    //lightning nodes
    private keyword instance

    globals
        private xedamage xed
    endglobals

    private struct node
        private node parent=0
        private node childA=0
        private node childB=0

        private real x=0.0
        private real y=0.0
        private real h=0.0

        private lightning light

        static method create takes instance si, node parent, integer start, integer end, real height returns node
            local node n=node.allocate()
            local integer i=start
            
            set n.parent=parent

            //get average target position
            loop 
                set n.x=n.x+GetUnitX(si.targets[i])
                set n.y=n.y+GetUnitY(si.targets[i])
                exitwhen i==end
                set i=i+1
            endloop
            set n.x=n.x/(end-start+1)
            set n.y=n.y/(end-start+1)
            if start!=end then //to be split further
                //correct position for starting offset
                set n.h=height*FORK_HEIGHT_FACTOR
                set n.x=n.x+(si.startx-si.hitx)*n.h/si.starth
                set n.y=n.y+(si.starty-si.hity)*n.h/si.starth
                //randomize position
                set n.h=n.h+GetRandomReal(-MAX_NODE_OFFSET, MAX_NODE_OFFSET)*n.h/si.starth
                set n.x=n.x+GetRandomReal(-MAX_NODE_OFFSET, MAX_NODE_OFFSET)*n.h/si.starth
                set n.y=n.y+GetRandomReal(-MAX_NODE_OFFSET, MAX_NODE_OFFSET)*n.h/si.starth
                //split the targets
                if MAX_FORK_TARGETCOUNT_DIFFERENCE>=(end-start+1-2) then
                    set i=GetRandomInt(start, end-1)
                else
                    set i=(end-start+1-2-MAX_FORK_TARGETCOUNT_DIFFERENCE)
                    set i=GetRandomInt(start+(i/2), end-1-(i/2))
                endif
                //create child nodes
                set n.childA=node.create(si,n, start,i, n.h )
                set n.childB=node.create(si,n, i+1,end, n.h )
            else //terminal node
                set n.h=0
                //damage target
                call xed.damageTarget(si.caster, si.targets[start], Damage(si.level))
            endif
            //create lightning
            if parent==0 then
                set n.light=AddLightningEx(LIGHTNING_TYPE, false, si.startx,si.starty,si.starth, n.x,n.y,n.h)
            else
                set n.light=AddLightningEx(LIGHTNING_TYPE, false, parent.x,parent.y,parent.h, n.x,n.y,n.h)
            endif
            
            return n
        endmethod
        
        method onDestroy takes nothing returns nothing
            if .childA!=0 then //if childA exists so must childB
                call .childA.destroy()
                call .childB.destroy()
            endif
            call DestroyLightning(.light)
        endmethod
    endstruct

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

    globals
        private group tempg = CreateGroup()
        private boolexpr tempbx
        private instance tempsi
        private GroupGet_Distance distance
    endglobals

    private function Targets takes nothing returns boolean
        local unit u=GetFilterUnit()
        if xed.allowedTarget(tempsi.caster,u) and IsUnitInRangeXY(u, tempsi.hitx, tempsi.hity, TargetRadius(tempsi.level)) then
            set u=null
            return true
        endif
        set u=null
        return false
    endfunction

    private function EndLightning takes nothing returns nothing
        call instance(GetTimerData(GetExpiredTimer())).destroy()
    endfunction
    
    private struct instance
        unit array targets[MAX_TARGETS]
        real hitx=0.0
        real hity=0.0
        real startx=0.0
        real starty=0.0
        real starth=0.0
        node first
        integer level
        unit caster
        timer t
        static method create takes unit caster, integer level, unit target returns instance
            local instance si = instance.allocate()
            local integer i = 0
            set si.hitx=GetUnitX(target)
            set si.hity=GetUnitY(target)
            set si.level=level
            set si.caster=caster
            set tempsi=si

            set si.startx=si.hitx+GetRandomReal(-MAX_START_OFFSET,MAX_START_OFFSET)
            set si.starty=si.hity+GetRandomReal(-MAX_START_OFFSET,MAX_START_OFFSET)
            set si.starth=START_HEIGHT

            call GroupEnumUnitsInRange(tempg,GetUnitX(target),GetUnitY(target),TargetRadius(level) + XE_MAX_COLLISION_SIZE , tempbx)
            call GroupRemoveUnit(tempg, target) //the target is selected by default, no need to keep it in group

            set bj_groupCountUnits = 0
            call ForGroup(tempg, function CountUnitsInGroupEnum) //Get number of units in group
            loop
                exitwhen bj_groupCountUnits<TargetMaxCount(level) //Remove random units from the group until we get to number of targets-1
                set bj_groupRandomConsidered = 0
                set bj_groupRandomCurrentPick = null
                call ForGroup(tempg, function GroupPickRandomUnitEnum)
                call GroupRemoveUnit(tempg, bj_groupRandomCurrentPick)
                set bj_groupCountUnits=bj_groupCountUnits-1
            endloop
            call GroupAddUnit(tempg, target) //readd the target to the group
            set distance.x=GetUnitX(target)
            set distance.y=GetUnitY(target)
            set si.targets[0]=GroupGetHighestEx(tempg, distance) //get the furthest unit from the target and start the array with it
            loop
                exitwhen i>=bj_groupCountUnits //sort the units into the array
                call GroupRemoveUnit(tempg, si.targets[i])
                set distance.x=GetUnitX(si.targets[i])
                set distance.y=GetUnitY(si.targets[i])
                set i=i+1
                set si.targets[i]=GroupGetLowestEx(tempg, distance)
            endloop
            set si.first=node.create(si, 0, 0,bj_groupCountUnits, si.starth) //initiate node creation sequence
            set si.t=NewTimer()
            call SetTimerData(si.t, integer(si))
            call TimerStart(si.t, LIGHTNING_DURATION, false, function EndLightning)
            return si
        endmethod
        method onDestroy takes nothing returns nothing
            call ReleaseTimer(.t)
            call .first.destroy() //initiate node destruction sequence
            set .first=0
        endmethod
    endstruct

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

    private function SpellEffect takes nothing returns nothing
        local integer lvl
        local unit u
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl =GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            set u = GetSpellTargetUnit()
            call instance.create(GetTriggerUnit(), lvl, u)
            set u = null
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )
        
        //init GroupGet comparison
        set distance=GroupGet_Distance.create()

        //init buff filter
        set tempbx=Condition(function Targets)

        //init xedamage
        set xed=xedamage.create()
        call DamageOptions(xed)
    endfunction
    
endscope

scope ThornwineArmour initializer Init

//*****************************************************************
//*  spell - Thornwine Armour
//*
//*  written by: Anitarf
//*  requires: -xepreload
//*            -xedamage
//*            -TimerUtils
//*            -ADamage
//*            -ABuff (requires damage and periodic events)
//*
//*            -a unit target triggerer ability
//*            -a self-targetting aura for displaying the buff
//*            -a buff that gets displayed by the aura
//*
//*  description: Creates a regenerative armor around a target unit
//*               that blocks incoming damage and deals damage back
//*               to melee attackers until it's time or life runs
//*               out.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A001' //the spell that applies the ABuff
        private constant integer BUFF_ABILITY = 'A002' //the self-targetting aura that displays the buff
        private constant integer BUFF_BUFF = 'B000' //the buff applied by the self-targetting aura
        private constant integer DAMAGE_SHIELD_PRIORITY = 5 //determines the order in which shields prevent damage

        //Dynamicaly timed effect parameters
        private constant string EFFECT = "Objects\\Spawnmodels\\NightElf\\EntBirthTarget\\EntBirthTarget.mdl"
        private constant real EFFECT_PERIOD_MINLIFE = 0.8 //slowest effect spawning
        private constant real EFFECT_PERIOD_MAXLIFE = 0.2 //fastest effect spawning
        private constant real EFFECT_MAXLIFE = 500.0 //at what life is fastest effect spawning reached
    endglobals
    
    //spell stats
    private constant function ShieldStartLife takes integer level returns real
        return 100.0 //starting shield life
    endfunction
    private constant function ShieldMaxLife takes integer level returns real
        return 200.0 + 100.0*level //how far the shield will regenerate
    endfunction
    private constant function ShieldRegeneration takes integer level returns real
        return 1.0+3.0*level //shield life regeneration per second
    endfunction
    private constant function ShieldRefreshLife takes integer level, real remainingLife returns real
        return remainingLife+ShieldStartLife(level) //what the life of a shield will be after it's applied on a unit that already has it
    endfunction
    private constant function ShieldDuration takes integer level returns real
        return 0.0 //the duration of the shield, use 0.0 to make it permanent (it will still be removed if it's life runs out)
    endfunction
    
    private constant function DamagePrevented takes integer level, real damage, real shieldLife returns real
        return 20.0 //don't worry if the returned value is higher than actual damage, spell code will reduce it in that case
    endfunction
    private constant function ReturnDamage takes boolean triggered, integer tag returns boolean
        return not(triggered) //does the shield return damage, this is a good way to avoid recursion
    endfunction
    private constant function DamageReturned takes integer level, real shieldLife, real prevented returns real
        return shieldLife*0.1 //how much damage does the shield return
    endfunction
    private function DamageOptions takes xedamage returnedDamage returns nothing
        //useful read: [url]http://www.wc3campaigns.net/showpost.php?p=1030046&postcount=19[/url]
        set returnedDamage.dtype=DAMAGE_TYPE_UNIVERSAL
        set returnedDamage.atype=ATTACK_TYPE_NORMAL
        set returnedDamage.tag=0 //the tag attached to the damage by xedamage
        set returnedDamage.damageAllies=true
        set returnedDamage.required=UNIT_TYPE_MELEE_ATTACKER //this example only returns melee damage
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    //Variable timed effect
    private keyword shd
    private function TimedEffect takes nothing returns nothing
        local shd s = shd(GetTimerData(GetExpiredTimer()))
        local real r = s.shdlife/EFFECT_MAXLIFE //factor between 0 and 1
        if r>1.0 then
            set r=1.0 //safety check due to unreliable user input
        endif
        set r=EFFECT_PERIOD_MINLIFE/((EFFECT_PERIOD_MINLIFE/EFFECT_PERIOD_MAXLIFE)*r + 1*(1-r))
        call DestroyEffect( AddSpecialEffectTarget(EFFECT, s.u, "origin"))
        call TimerStart(s.t, r, false, function TimedEffect)
    endfunction

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

    //ADamage shield struct
    private struct shd extends ADamage_shield //shield that doubles as a data struct
        timer t
        unit u
    
        integer level=0
        real shdlife=0
        real prevented=0
        static method create takes unit u, integer level returns shd
            local shd s = shd.allocate(u, DAMAGE_SHIELD_PRIORITY)
            set s.shdlife=ShieldStartLife(level)
            set s.level = level
            set s.u=u
            set s.t=NewTimer()
            call SetTimerData(s.t, integer(s))
            call TimerStart(s.t, 0.0, false, function TimedEffect)
            return s
        endmethod
        method refresh takes integer level returns nothing
            set .level=level
            set .shdlife=ShieldRefreshLife(level, .shdlife)
            if .shdlife>ShieldMaxLife(level) then
               set .shdlife=ShieldMaxLife(level)
            endif
        endmethod
        method regen takes integer level returns nothing
            set .shdlife=.shdlife+ShieldRegeneration(level)*ABuff_PERIODIC_EVENT_PERIOD
            if .shdlife>ShieldMaxLife(level) then
               set .shdlife=ShieldMaxLife(level)
            endif
        endmethod
        method damaged takes unit damageSource, real damage returns real
            set .prevented = DamagePrevented(.level, damage, .shdlife)
            if .prevented > damage then
                set .prevented = damage
            endif
            if .prevented > .shdlife then
                set .prevented = .shdlife
            endif
            set .shdlife=.shdlife-.prevented
            return .prevented
        endmethod
        method onDestroy takes nothing returns nothing
            call PauseTimer(.t)
            call ReleaseTimer(this.t)
        endmethod
    endstruct

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

    //Delayed damage return
        //we delay it so all damage triggers finish running before we deal new damage
        //all triggered spells that deal damage in response to damage being dealt should do this
    globals
        private xedamage xed
    endglobals

    private struct damageUnit
        unit target
        unit source
        real damage
    endstruct
    
    private function DelayedDamage takes nothing returns nothing 
        local damageUnit d = damageUnit(GetTimerData(GetExpiredTimer()))
        call ReleaseTimer(GetExpiredTimer())
        call xed.damageTarget(d.source, d.target, d.damage)
        call d.destroy()
    endfunction

// ================================================================
    
    //ABuff functions
    globals
        private aBuffType abt
    endglobals

    private function Create takes aBuff eventBuff returns nothing
        set eventBuff.data=integer(shd.create(eventBuff.target.u, eventBuff.level))
        call UnitAddAbility(eventBuff.target.u, BUFF_ABILITY)
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
        call UnitMakeAbilityPermanent(eventBuff.target.u, true, BUFF_ABILITY) //prevent morphing from removing the ability
    endfunction
    private function Refresh takes aBuff eventBuff returns nothing
        set eventBuff.data=eventBuff.olddata
        call shd(eventBuff.data).refresh(eventBuff.level)
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
    endfunction
    private function Cleanup takes aBuff eventBuff returns nothing
        call shd(eventBuff.data).destroy()
        call UnitRemoveAbility(eventBuff.target.u, BUFF_ABILITY)
        call UnitRemoveAbility(eventBuff.target.u, BUFF_BUFF)
    endfunction
    private function Periodic takes aBuff eventBuff returns nothing
        call shd(eventBuff.data).regen(eventBuff.level)
    endfunction
    
    private function Damaged takes aBuff eventBuff, real damage, unit damageSource returns nothing
        local shd s = shd(eventBuff.data)
        local damageUnit d
        local timer t
        if s.prevented>0.0 and xed.allowedTarget(eventBuff.target.u, damageSource) and ReturnDamage(xedamage.isInUse(), xedamage.CurrentDamageTag) then
            set t = NewTimer()
            set d = damageUnit.create()
            set d.damage = DamageReturned(eventBuff.level, s.shdlife+s.prevented, s.prevented)
            set d.target = damageSource
            set d.source = s.u
            call SetTimerData(t, integer(d))
            call TimerStart(t, 0.0, false, function DelayedDamage)
        endif
        if s.shdlife<=0.0 then
            call ABuffDestroy(eventBuff)
        endif
    endfunction

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

    private function SpellEffect takes nothing returns nothing
        local integer lvl
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl = GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            call ABuffApply(abt, GetSpellTargetUnit(), GetTriggerUnit(), ShieldDuration(lvl), lvl, 0 )
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )

        //init xedamage
        set xed=xedamage.create()
        call DamageOptions(xed)

        //init aBuffType
        call XE_PreloadAbility(BUFF_ABILITY)
        
        set abt=aBuffType.create()
        set abt.ignoreAsBuff = true
        set abt.eventCreate = ABuffEvent_Create.Create
        set abt.eventRefresh = ABuffEvent_Refresh.Refresh
        set abt.eventCleanup = ABuffEvent_Cleanup.Cleanup
        set abt.eventPeriodic = ABuffEvent_Periodic.Periodic
        set abt.eventDamaged = ABuffEvent_BUnitDamaged.Damaged
    endfunction

endscope

scope RazorGale initializer Init

//*****************************************************************
//*  spell - Razor Gale
//*
//*  written by: Anitarf
//*  requires: -xebasic
//*            -xedamage
//*            -TimerUtils
//*
//*            -a point and/or unit target channeling triggerer ability
//*
//*  description: The casting unit glides towards a target point as
//*               long as it continues channeling or until it
//*               reaches the target point or max distance and
//*               deals damage to enemy units along the way.
//*
//*  technical: The spell is designed specifically for the Warden
//*             model. It also disables spell sounds for the
//*             duration of the spell because the sound attached to
//*             the Warden's spell slam animation is too annoying
//*             otherwise. If a custom warden model is used with
//*             this sound removed, then the sound disabling
//*             feature of this spell may be turned off.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A003' //the spell ability
        private constant real SPELL_PERIOD = XE_ANIMATION_PERIOD //the speed of the periodic timer that moves the caster
        private constant integer DAMAGE_PERIOD_FACTOR = 3 //optimization option, every how many periods are new targets affected

        //Animation options
        private constant real ANIM_SPEED_START = 1.2 //the animation speed at the start of the spell
        private constant real ANIM_SPEED_END = 0.9 //the animation speed at the end of the spell
        private constant boolean DISABLE_SPELL_SOUND = true //may be set to false with a custom warden model
    endglobals

    //spell stats
    private constant function GlideSpeed takes integer level returns real
        return 750.0 //the distance that the caster travles per second
    endfunction
    private constant function GlideMaxDistance takes integer level returns real
        return 1000.0 //what is the furthest the caster can glide
    endfunction
    private constant function GlideMinDistance takes integer level returns real
        return 1000.0 //if the target point is closer than this, the caster will still glide this far
    endfunction

    private constant function Damage takes integer level returns real
        return 50.0+50.0*level
    endfunction
    private constant function DamageRadius takes integer level returns real
        return 128.0
    endfunction
    private function DamageOptions takes xedamage spellDamage returns nothing
        //useful read: [url]http://www.wc3campaigns.net/showpost.php?p=1030046&postcount=19[/url]
        set spellDamage.dtype=DAMAGE_TYPE_UNIVERSAL
        set spellDamage.atype=ATTACK_TYPE_NORMAL
        set spellDamage.tag=0 //the tag attached to the damage by xedamage
        set spellDamage.exception=UNIT_TYPE_STRUCTURE //deal no damage to structures
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    //Sliding and damage
    private keyword instance
    globals
        private xedamage xed
        private timer slide
        private instance array instances
        private integer instanceCount = 0

        private group tempg = CreateGroup()
        private boolexpr tempbx
        private real tempx
        private real tempy
        private instance tempsi
    endglobals

    private function Targets takes nothing returns boolean
        local unit u=GetFilterUnit()
        if not(IsUnitInGroup(u, tempsi.affected)) and IsUnitInRangeXY(u, tempx, tempy, DamageRadius(tempsi.level)) then
            call GroupAddUnit(tempsi.affected, u)
            set u=null
            return true
        endif
        set u=null
        return false
    endfunction

    private function Periodic takes nothing returns nothing
        local integer i=0
        loop
            exitwhen i>=instanceCount
            set tempsi = instances[i]
            set tempx = GetUnitX(tempsi.caster)+tempsi.dx
            set tempy = GetUnitY(tempsi.caster)+tempsi.dy
            set tempsi.time=tempsi.time-SPELL_PERIOD
            if tempsi.time>0.0 and IsTerrainWalkable(tempx,tempy) then
                call SetUnitX(tempsi.caster, tempx)
                call SetUnitY(tempsi.caster, tempy)
                if tempsi.whenToDamage <= 0 then
                    set tempsi.whenToDamage=DAMAGE_PERIOD_FACTOR
                    call GroupEnumUnitsInRange(tempg,tempx,tempy,DamageRadius(tempsi.level) + XE_MAX_COLLISION_SIZE , tempbx)
                    call xed.damageGroup(tempsi.caster, tempg, Damage(tempsi.level)) //empties the group
                endif
                set tempsi.whenToDamage=tempsi.whenToDamage-1
                set i=i+1
            else //if instance is on the list it should still be active so it's safe to call finish
                call  tempsi.finish()
            endif
        endloop
    endfunction

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

    //Animations
    private function Animation_Finish takes nothing returns nothing
        local instance si=instance(GetTimerData(GetExpiredTimer()))
        call SetUnitTimeScale(si.caster, 1.0)
        call si.destroy() //this will release the expired timer, so no need to do it here 
    endfunction
    private function Animation_Child takes nothing returns nothing
        local instance si=instance(GetTimerData(GetExpiredTimer()))
        call SetUnitFlyHeight(si.caster, 0.0, 48.0/0.125*si.timescale)
        call ReleaseTimer(GetExpiredTimer())
    endfunction
    private function Animation takes nothing returns nothing
        local instance si=instance(GetTimerData(GetExpiredTimer()))
        local timer t
        if si.active then //go into next animation cycle
            set t = NewTimer()
            call SetTimerData(t, integer(si))
            call SetUnitTimeScale(si.caster, si.timescale)
            call SetUnitAnimationByIndex(si.caster, 6)
            call SetUnitFlyHeight(si.caster, 48.0, 48.0/0.125*si.timescale)
            call TimerStart(t, 0.125/si.timescale, false, function Animation_Child) //run secondary function in this interval
            call TimerStart(GetExpiredTimer(), 0.35/si.timescale, false, function Animation) //run next interval
            set si.timescale=si.timescale+si.dtimescale*0.35/si.timescale //how the time scale changes during the interval
        else //let the animation finish
            call SetUnitTimeScale(si.caster, 1.5)
            call TimerStart(GetExpiredTimer(), 0.45, false, function Animation_Finish) //allow animation to finish
        endif
    endfunction
    
// ================================================================

    //Spell instance
    private struct instance
        private integer index

        private timer t //this timer needs to be on a per-caster basis
        real timescale
        real dtimescale

        boolean active = true
        boolean interrupted = false
        integer whenToDamage = DAMAGE_PERIOD_FACTOR
        unit caster
        integer level
        real dx
        real dy
        group affected
        real time
        
        static method create takes unit caster, integer level, real targetx, real targety returns instance
            local instance si=instance.allocate()
            local real distance
            local real factor=1.0

            call UnitAddAbility(caster, XE_HEIGHT_ENABLER)
            call UnitRemoveAbility(caster, XE_HEIGHT_ENABLER)
            set si.caster=caster
            set si.level=level
            set si.dx=targetx-GetUnitX(caster)
            set si.dy=targety-GetUnitY(caster)
            set distance = SquareRoot(si.dx*si.dx+si.dy*si.dy)+1.0 //to avoid division by zero later

            if distance>GlideMaxDistance(level) then
                set factor = GlideMaxDistance(level)/distance
            elseif distance<GlideMinDistance(level) then
                set factor = GlideMinDistance(level)/distance
            endif
            set si.time = factor*distance/GlideSpeed(level) //duration of the spell
            set factor = factor/si.time*SPELL_PERIOD
            set si.dx=si.dx*factor //distance traveled per interval
            set si.dy=si.dy*factor

            set si.timescale=ANIM_SPEED_START
            set si.dtimescale=(ANIM_SPEED_END-ANIM_SPEED_START)/(GlideMaxDistance(level)/GlideSpeed(level)) //animation speed change per second

            if si.affected == null then //create a group if this is the first time this instance id is used
                set si.affected=CreateGroup()
            endif

            set si.t=NewTimer() //animation timer
            call SetTimerData(si.t, integer(si))
            call TimerStart(si.t, 0.0, false, function Animation)

            //neccessary evil, the spell sounds like crap if the warden's animation sounds are allowed to play
            if DISABLE_SPELL_SOUND then
                call VolumeGroupSetVolume(SOUND_VOLUMEGROUP_SPELLS, 0.0)
            endif

            if instanceCount==0 then //slide timer
                set slide=NewTimer()
                call TimerStart(slide, SPELL_PERIOD, true, function Periodic)
            endif

            set instances[instanceCount]=si
            set si.index=instanceCount
            set instanceCount=instanceCount+1
            return si
        endmethod
        
        static method get takes unit u returns instance
            local integer i=0
            loop
                exitwhen i==instanceCount
                if instances[i].caster==u then
                    return instances[i]
                endif
                set i=i+1
            endloop
            return 0
        endmethod
        
        method finish takes nothing returns nothing
            set this.active=false //spell stopped, wait for animation to finish and then end it
            set instanceCount=instanceCount-1
            set instances[this.index]=instances[instanceCount]
            set instances[instanceCount].index=this.index

            if instanceCount==0 then
                call ReleaseTimer(slide)
                //end of evil
                if DISABLE_SPELL_SOUND then
                    call VolumeGroupReset()
                endif
            endif
        endmethod
        
        method onDestroy takes nothing returns nothing
            if not(this.interrupted) then //if the channeling wasn't interrupted by the player...
                call IssueImmediateOrder(this.caster, "stop") //...then stop it now
            endif
            call ReleaseTimer(this.t)
            call GroupClear(this.affected) //the next time this instance id is used we won't need to create a group
        endmethod
    endstruct

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

    private function SpellEffect takes nothing returns nothing
        local integer lvl
        local unit u
        local location l
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl =GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            set u = GetSpellTargetUnit()
            if u == null then
                //point-target cast
                set l = GetSpellTargetLoc()
                call instance.create(GetTriggerUnit(), lvl, GetLocationX(l), GetLocationY(l))
                call RemoveLocation(l)
                set l = null
            else
                //unit-target cast
                call instance.create(GetTriggerUnit(), lvl, GetUnitX(u), GetUnitY(u))
                set u = null
            endif
        endif
    endfunction
    private function SpellStop takes nothing returns nothing
        local instance si
        if GetSpellAbilityId() == SPELL_ABILITY then
            set si = instance.get(GetTriggerUnit())
            if si != 0 then
                call si.finish()
                set si.interrupted=true
            endif
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )

        set tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_ENDCAST )
        call TriggerAddAction( tr, function SpellStop )
        
        //init damage filter
        set tempbx=Condition(function Targets)
        
        //init xedamage
        set xed=xedamage.create()
        call DamageOptions(xed)
    endfunction

endscope

scope LurkingShadow initializer Init

//*****************************************************************
//*  spell - Lurking Shadow
//*
//*  written by: Anitarf
//*  requires: -xepreload
//*            -xedamage
//*            -ABuff
//*
//*            -a unit target triggerer ability
//*            -a self-targetting aura for displaying the buff
//*            -a buff that gets displayed by the aura
//*
//*  description: Creates a buff on the targeted unit that deals
//*               damage to enemy units in an area around the
//*               target whenever it casts a spell or is
//*               targeted by a spell.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A00A' //the spell that applies the ABuff
        private constant integer BUFF_ABILITY = 'A008' //the self-targetting aura that displays the buff
        private constant integer BUFF_BUFF = 'B001' //the buff applied by the self-targetting aura
        
        private constant boolean DAMAGE_WHEN_CASTING = true //if true, damage is dealt whenever the buffed unit casts a spell
        private constant boolean DAMAGE_WHEN_TARGETED = true //if true, damage is dealt whenever the buffed unit is targeted by a spell

        //Visual settings
        private constant string DAMAGE_EFFECT_MAIN = "Abilities\\Spells\\Undead\\OrbOfDeath\\OrbOfDeathMissile.mdl" //the effect on the buffed unit when the spell deals damage
        private constant string DAMAGE_EFFECT_MAIN_AP = "origin" //the attachment point for the effect
        private constant string DAMAGE_EFFECT_UNIT = "Abilities\\Spells\\Undead\\CarrionSwarm\\CarrionSwarmDamage.mdl" //the effect on the units the spell damages
        private constant string DAMAGE_EFFECT_UNIT_AP = "origin" //the attachment point for the effect
    endglobals

    private constant function BuffDuration takes integer level returns real
        return 30.0 //the duration of the buff
    endfunction

    private constant function Damage takes integer level returns real
        return 25.0+25.0*level
    endfunction
    private constant function DamageRadius takes integer level returns real
        return 100.0+50.0*level
    endfunction
    private function DamageOptions takes xedamage spellDamage returns nothing
        //useful read: [url]http://www.wc3campaigns.net/showpost.php?p=1030046&postcount=19[/url]
        set spellDamage.dtype=DAMAGE_TYPE_UNIVERSAL
        set spellDamage.atype=ATTACK_TYPE_NORMAL
        set spellDamage.tag=0 //the tag attached to the damage by xedamage
        set spellDamage.exception=UNIT_TYPE_STRUCTURE //deal no damage to structures
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    globals
        private aBuffType abt
        private xedamage xed
    endglobals

    //ABuff functions
    private function Create takes aBuff eventBuff returns nothing
        call UnitAddAbility(eventBuff.target.u, BUFF_ABILITY)
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
        call UnitMakeAbilityPermanent(eventBuff.target.u, true, BUFF_ABILITY) //prevent morphing from removing the ability
    endfunction
    private function Refresh takes aBuff eventBuff returns nothing
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
    endfunction
    private function Cleanup takes aBuff eventBuff returns nothing
        call UnitRemoveAbility(eventBuff.target.u, BUFF_ABILITY)
        call UnitRemoveAbility(eventBuff.target.u, BUFF_BUFF)
    endfunction
    private function SpellCast takes aBuff eventBuff, integer spellId, unit target returns nothing
        call DestroyEffect(AddSpecialEffectTarget(DAMAGE_EFFECT_MAIN, eventBuff.target.u, DAMAGE_EFFECT_MAIN_AP))
        call xed.damageAOE(eventBuff.caster, GetUnitX(eventBuff.target.u),GetUnitY(eventBuff.target.u),DamageRadius(eventBuff.level),Damage(eventBuff.level) )
    endfunction
    private function SpellTargeted takes aBuff eventBuff, integer spellId, unit caster returns nothing
        call DestroyEffect(AddSpecialEffectTarget(DAMAGE_EFFECT_MAIN, eventBuff.target.u, DAMAGE_EFFECT_MAIN_AP))
        call xed.damageAOE(eventBuff.caster, GetUnitX(eventBuff.target.u),GetUnitY(eventBuff.target.u),DamageRadius(eventBuff.level),Damage(eventBuff.level) )
    endfunction

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

    private function SpellEffect takes nothing returns nothing
        local integer lvl
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl = GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            call ABuffApply(abt, GetSpellTargetUnit(), GetTriggerUnit(), BuffDuration(lvl), lvl, 0 )
        endif
    endfunction

    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )

        //init xedamage
        set xed=xedamage.create()
        call DamageOptions(xed)
        call xed.useSpecialEffect(DAMAGE_EFFECT_UNIT,DAMAGE_EFFECT_UNIT_AP)

        //init aBuffType
        call XE_PreloadAbility(BUFF_ABILITY)
        
        set abt=aBuffType.create()
        set abt.eventCreate = ABuffEvent_Create.Create
        set abt.eventRefresh = ABuffEvent_Refresh.Refresh
        set abt.eventCleanup = ABuffEvent_Cleanup.Cleanup
        if DAMAGE_WHEN_CASTING then
            set abt.eventSpellCast = ABuffEvent_BUnitSpellCast.SpellCast
        endif
        if DAMAGE_WHEN_TARGETED then
            set abt.eventSpellTargeted = ABuffEvent_BUnitSpellTargeted.SpellTargeted
        endif
    endfunction

endscope

scope SacredGround initializer Init

//*****************************************************************
//*  spell - Sacred Ground
//*
//*  written by: Anitarf
//*  requires: -xepreload
//*            -TimerUtils
//*            -ADamage
//*            -ABuff (requires damage events)
//*            -ABuffAuras
//*
//*            -an instant (no-target) channeling triggerer ability
//*            -a self-targetting aura for displaying the buff
//*            -a buff that gets displayed by the aura
//*
//*  description: As long as the spell is being channeled, all
//*               damage dealt to nearby friendly units will be
//*               reduced by a percentage and those units will
//*               regenerate mana equal to a percentage of damage
//*               prevented.
//*
//*  technical: The spell is designed with the Demon Hunter model
//*             in mind, but the animation code is calibratable
//*             so it might be possible to get interesting results
//*             with other model animations as well. The channeling
//*             spell should have a duration equal or greater than
//*             the duration set in the calibration functions.
//*
//*****************************************************************

    globals
        //Spell settings
        private constant integer SPELL_ABILITY = 'A000' //the spell ability
        private constant integer BUFF_ABILITY = 'A00C' //the self-targetting aura that displays the buff
        private constant integer BUFF_BUFF = 'B003' //the buff applied by the self-targetting aura
        private constant integer DAMAGE_SHIELD_PRIORITY = 10

        //Animation options
        private constant integer ANIM_ID = 3 //the id of the animation to play during the spell
        private constant real ANIM_SPEED_START = 1.25 //the animation speed at the start of the spell
        private constant real ANIM_DURATION_START = 2.0 //how long the starting phase should last
        private constant real ANIM_SPEED_LOOP = 0.25 //the animation speed while the spell is looping
        private constant real ANIM_DURATION_LOOP = 0.75 //how quickly to switch between positive and negative animation speed while looping
        private constant real ANIM_SPEED_END = 2.25 //the animation speed at the end of the spell
        private constant real ANIM_DURATION_END = 1.0 //how long the ending phase should last
    endglobals
    
    private constant function SpellDuration takes integer level returns real
        return 10.0
    endfunction
    private constant function DamagePreventedFactor takes integer level returns real
        return 0.05+0.15*level //0.2, 0.35, 0.5
    endfunction
    private constant function PreventedToManaFactor takes integer level returns real
        return 0.5
    endfunction
    private constant function AuraRange takes integer level returns real
        return 500.0
    endfunction

    private function AuraTargets takes unit affected, unit auraGiver returns boolean
        return IsUnitAlly(affected, GetOwningPlayer(auraGiver))
    endfunction


// END OF CALIBRATION SECTION
// ================================================================

    //ADamage shield struct
    private struct shd extends ADamage_shield
        integer level
        real prevented
        static method create takes unit u, integer level returns shd
            local shd s = shd.allocate(u, DAMAGE_SHIELD_PRIORITY)
            set s.level = level
            return s
        endmethod
        method damaged takes unit damageSource, real damage returns real
            set .prevented = damage*DamagePreventedFactor(.level)
            return .prevented
        endmethod
    endstruct
    
// ================================================================

    //ABuff functions
    globals
        private aBuffType abt
    endglobals

    private function Create takes aBuff eventBuff returns nothing
        set eventBuff.data=shd.create(eventBuff.target.u, eventBuff.level)
        call UnitAddAbility(eventBuff.target.u, BUFF_ABILITY)
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
        call UnitMakeAbilityPermanent(eventBuff.target.u, true, BUFF_ABILITY) //prevent morphing from removing the ability
    endfunction
    private function Refresh takes aBuff eventBuff returns nothing
        set eventBuff.data=eventBuff.olddata
        set shd(eventBuff.data).level=eventBuff.level
        call SetUnitAbilityLevel(eventBuff.target.u, BUFF_ABILITY, eventBuff.level)
    endfunction
    private function Cleanup takes aBuff eventBuff returns nothing
        call shd(eventBuff.data).destroy()
        call UnitRemoveAbility(eventBuff.target.u, BUFF_ABILITY)
        call UnitRemoveAbility(eventBuff.target.u, BUFF_BUFF)
    endfunction
    private function Damaged takes aBuff eventBuff, real damage, unit damageSource returns nothing
        local real restore = shd(eventBuff.data).prevented*PreventedToManaFactor(eventBuff.level)
        call SetUnitState(eventBuff.target.u, UNIT_STATE_MANA, GetUnitState(eventBuff.target.u, UNIT_STATE_MANA)+restore)
    endfunction

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

    //Animations
    private keyword instance
    globals
        private instance array instances
        private integer instanceCount = 0
    endglobals

    private function Animation_Finish takes nothing returns nothing
        local instance si = GetTimerData(GetExpiredTimer())
        call si.destroy()
    endfunction
    private function Animation takes nothing returns nothing
        local instance si = GetTimerData(GetExpiredTimer())
        set si.time=si.time-ANIM_DURATION_LOOP
        if si.time>ANIM_DURATION_END then
            call SetUnitTimeScale(si.caster, si.timescale)
            set si.timescale=-si.timescale
            call TimerStart(GetExpiredTimer(), ANIM_DURATION_LOOP, false, function Animation)
        else
            set si.time=si.time+ANIM_DURATION_LOOP
            call SetUnitTimeScale(si.caster, ANIM_SPEED_END*(ANIM_DURATION_END/si.time))
            call TimerStart(GetExpiredTimer(), si.time, false, function Animation_Finish)
        endif
    endfunction

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

    //Spell instance
    private struct instance
        private integer index

        private timer t //this timer needs to be on a per-caster basis

        boolean interrupted = false
        unit caster
        integer level
        real time
        real timescale
        
        static method create takes unit caster, integer level returns instance
            local instance si=instance.allocate()

            set si.caster=caster
            set si.level=level
            set si.time=SpellDuration(level)-ANIM_DURATION_START
            set si.timescale=ANIM_SPEED_LOOP

            set si.t=NewTimer() //animation timer
            call SetTimerData(si.t, integer(si))
            call SetUnitTimeScale(caster, ANIM_SPEED_START)
            call SetUnitAnimationByIndex(caster, ANIM_ID)
            call TimerStart(si.t, ANIM_DURATION_START, false, function Animation)

            call UnitSetABuffAura(caster, abt, level, ABuffAuraTargets.AuraTargets, AuraRange(level))

            set instances[instanceCount]=si
            set si.index=instanceCount
            set instanceCount=instanceCount+1
            return si
        endmethod
        
        static method get takes unit u returns instance
            local integer i=0
            loop
                exitwhen i==instanceCount
                if instances[i].caster==u then
                    return instances[i]
                endif
                set i=i+1
            endloop
            return 0
        endmethod
        
        method onDestroy takes nothing returns nothing
            set instanceCount=instanceCount-1
            set instances[this.index]=instances[instanceCount]
            set instances[instanceCount].index=this.index

            call UnitRemoveABuffAura(this.caster, abt)

            call ReleaseTimer(this.t)
            call SetUnitTimeScale(this.caster, 1.0)
            if not(this.interrupted) then //if the channeling wasn't interrupted by the player...
                call IssueImmediateOrder(this.caster, "stop") //...then stop it now
            endif
        endmethod
    endstruct

// ================================================================
    
    private function SpellEffect takes nothing returns nothing
        local integer lvl
        if GetSpellAbilityId() == SPELL_ABILITY then
            set lvl =GetUnitAbilityLevel(GetTriggerUnit(), SPELL_ABILITY)
            call instance.create(GetTriggerUnit(), lvl)
        endif
    endfunction
    private function SpellStop takes nothing returns nothing
        local instance si
        if GetSpellAbilityId() == SPELL_ABILITY then
            set si = instance.get(GetTriggerUnit())
            if si != 0 then
                set si.interrupted=true
                call si.destroy()
            endif
        endif
    endfunction
    
    private function Init takes nothing returns nothing
        //init spellcast trigger
        local trigger tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddAction( tr, function SpellEffect )

        set tr = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ( tr, EVENT_PLAYER_UNIT_SPELL_ENDCAST )
        call TriggerAddAction( tr, function SpellStop )

        //init aBuffType
        set abt=aBuffType.create()
        set abt.ignoreAsBuff = true //since this is an aura buff, we can't have other spells destroy it
        set abt.eventCreate = ABuffEvent_Create.Create
        set abt.eventRefresh = ABuffEvent_Refresh.Refresh
        set abt.eventCleanup = ABuffEvent_Cleanup.Cleanup
        set abt.eventDamaged = ABuffEvent_BUnitDamaged.Damaged
    endfunction

endscope