Simple Ward Spell, opinion/suggestion for completed code

//===========================================================================
//Summons a ward that will summon a skelly from a corpse every 2 seconds. The ward
//can also carry an ability, which allows him to summon stronger skellies, depending
//on it's level. A ward can only summon 1 unit at a time.
//
//@Requires:
// - TimedLoop
// - TimedHandles
//
//@author Flame_Phoenix 
//
//@Credits:
// - Vexorian, for TimedLoop
// - TriggerHappy187, for TimedHandles
// - Spec, for helping a lot on the making of the spell
// - 0zyx0, for a cool suggestion on how to improve speed
//
//@version 1.5.1
//===========================================================================
scope SoulWard2 initializer Init
    private keyword skelies //needed for core, do not change
//===========================================================================
//=============================SETUP START===================================
//===========================================================================
    globals
        private constant integer WARD_ID = 'o00H'   //id of the ward
        private constant integer WARD_ABI = 'A01F'  //ability that tells us the level of the ward
        private constant string BOLT = "AFOD"   //lightning effect
        private constant string SUMMON_EFF = "Abilities\\Spells\\Undead\\RaiseSkeletonWarrior\\RaiseSkeleton.mdl"   //summon effect
        private constant real COOLDOWN = 2.    //cooldown between rays of summoning
    endglobals
    
    private constant function Radius takes integer level returns real
    //the radius of the ward
        return 450.
    endfunction
    
    private constant function SkelyDuration takes integer level returns real
    //amount of time each skely lasts
        return 30.
    endfunction
    
    private function SetSkelies takes nothing returns nothing
    //skelies that can be summoned by the ward. The number in the array is the
    //level they ar asociated with
        set skelies[1] = 'nsko' //skeletal orc
        set skelies[2] = 'nsoc' //skeletal orc champion
    endfunction
    
    private function PickVictims takes unit ward, unit victim returns boolean
    //the units the ward can affect
        return (GetWidgetLife(victim) < 0.405) and (IsUnitTypeDummy(victim)==false) and (IsUnitTypeWard(victim) == false) 
    endfunction
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================
    globals
        private integer array skelies
        private group wards
        private boolexpr chooseWards
        private group dead
        private boolexpr chooseDead
        private unit tmpWard
    endglobals
//===========================================================================    
    private function PickDead takes nothing returns boolean
        return PickVictims(tmpWard, GetFilterUnit())
    endfunction
//===========================================================================
    private function PickWards takes nothing returns boolean
        return GetUnitTypeId(GetFilterUnit()) == WARD_ID
    endfunction
//===========================================================================
    private struct aSoulWard
        unit theWard
        real wardX
        real wardY
        real counter
        
        //method required by TimedLoop 
        private method onTimedLoop takes nothing returns boolean            
            local integer wardLevel
            local unit aVictim
            local real vicX
            local real vicY
            local unit skely
            
            //if the ward is dead, there is no need to go on, we just clean all mess
            //TimedLoop we call onDestroy for us!
            if GetWidgetLife(.theWard) <= 0.405 then
                return TimedLoop_STOP
            endif
            
            //If it is time to summon skelies, we summon them. If it is not time yet, we simply 
            //increase the counter!
            if .counter >= COOLDOWN then 
                //time to pick dead units near the current ward
                set wardLevel = GetUnitAbilityLevel(.theWard, WARD_ABI)
                set tmpWard = .theWard
                call GroupEnumUnitsInRange(dead, .wardX, .wardY, Radius(wardLevel), chooseDead)
                    
                //if the first unit of the group is null, then it means the group has 0 units, and 
                //it means we don't need to do anything at all xD
                if FirstOfGroup(dead) != null then
                    set aVictim = GroupPickRandomUnit(dead)
                    set vicX = GetUnitX(aVictim)
                    set vicY = GetUnitY(aVictim)
                        
                    //create the bolt and the skelie!
                    call DestroyLightningDelayed(AddLightningEx(BOLT, false, .wardX, .wardY, 50., vicX, vicY, -1.), 1.)
                    set skely = CreateUnit(GetOwningPlayer(.theWard), skelies[wardLevel], vicX, vicY, 0.)
                    call SetUnitAnimation(skely, "birth")
                    call UnitApplyTimedLife(skely, 'BTLF', SkelyDuration(wardLevel))
            
                    //a nice effect
                    call DestroyEffect(AddSpecialEffect(SUMMON_EFF, vicX, vicY))
                        
                    //remove the body of the victim
                    call ShowUnit(aVictim, false)
                    call RemoveUnit(aVictim)
                    
                    //cleaning up the group for the next ward =D
                    call GroupClear(dead)
                endif
               
                //now that we did our job in the correct time, we reset the timer, for the cooldown to start
                //again once more =D
                set .counter = 0
                
                //cleaning our skely
                set skely = null
            else
                set .counter = .counter + TimedLoop_PERIOD
            endif
            
            //if everything was Ok, we just keep going ...
            return TimedLoop_CONTINUE
        endmethod
        
        implement TimedLoop //This does the module magic

        static method create takes unit ward returns aSoulWard
            local aSoulWard sw = aSoulWard.allocate()
            
            set sw.theWard = ward
            set sw.wardX = GetUnitX(ward)
            set sw.wardY = GetUnitY(ward)
            set sw.counter = 0
            
            //The TimedLoop script works by
            // creating a startTimedLoop method that will
            // do all the dirty work and end up calling
            // .onTimedLoop...
            call sw.startTimedLoop()
            
            return sw
        endmethod
    endstruct
//===========================================================================
    private function Conditions takes nothing returns boolean
        local aSoulWard ward
        
        if GetUnitTypeId(GetSummonedUnit()) == WARD_ID then
           set ward = aSoulWard.create(GetSummonedUnit())
        endif
        
        return false
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        local trigger SoulWardTrg = CreateTrigger(  )
        call TriggerRegisterAnyUnitEventBJ(SoulWardTrg, EVENT_PLAYER_UNIT_SUMMON )
        call TriggerAddCondition(SoulWardTrg, Condition(function Conditions))

        //setting globals
        set wards = CreateGroup()
        set chooseWards = Condition(function PickWards)
        set dead = CreateGroup()
        set chooseDead = Condition(function PickDead)
        
        call SetSkelies()
        
        //Preloading effects
        call Preload(SUMMON_EFF)
    endfunction
endscope

private function PickDead takes nothing returns boolean
  if PickVictims(tmpWard, GetFilterUnit()) then
    set temp_i = temp_i + 1
    return true
  endif
  return false
endfunction
// . . .
set temp_i = 0
call GroupEnumUnitsInRange(dead, GetUnitX(aWard), GetUnitY(aWard), Radius(wardLevel), chooseDead)
if temp_i > 0 then
// . . .
endif

function filter returns boolaen
   return canUnitBeRaised
endfunction

function wardFilter returns boolean
   return isThisAWard and isItSuitable
endfunction
function raise
   local group wards = CreateGroup()
   call GroupEnumUnitsInRange(wards, *maxWardRange(cozThisMightChangePerLevelOfTheWardAbility), function filter)
   //pick which ward should raise the unit (the closest one? the oldest one? the highest-level one? etc)
   //raise the unit

   //flush
endfunction

function Init
local trigger t = CreateTrigger()
call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_DEATH)
call TriggerAddCondition(t, Condition(filter)
call TriggerAddAction(t, raise)
set t = null
endfunction

if GetWidgetLife(.theWard) < 0.405 then
    return TimedLoop_STOP
endif

    private function PickVictims takes unit ward, unit victim returns boolean
    //the units the ward can affect
        return (GetWidgetLife(victim) < 0.405) and (IsUnitTypeDummy(victim)==false) and (IsUnitTypeWard(victim)==false)
    endfunction