Opinion about simple Dota spell 2 !

//===========================================================================
//Sends an arrow that will travel and damage enemy units in a line.
//
//@Requires:
// - TimedLoop
// - GroupUtils
//
//@author Flame_Phoenix 
//
//@Credits:
// - Vexorian, for TimedLoop
// - Rising_Dusk, for GroupUtils
//
//@version 1.2.0
//===========================================================================
scope ForestArrowThree initializer Init
//===========================================================================
//=============================SETUP START===================================
//===========================================================================
    globals
        private constant integer AID = 'A001'  //id of the hero ability
        private constant integer ARROW_ID = 'h000' //id of the arrow unit
        private constant real ARROW_COLLISION = 40. //collision size of the arrow
        private constant real ARROW_SPEED = 30. //the speed of the arrow
        private constant attacktype ATT_TYPE = ATTACK_TYPE_MAGIC    //attack type of arrow
        private constant damagetype DAM_TYPE = DAMAGE_TYPE_NORMAL   //damage type of arrow
    endglobals
    
    private constant function DamageReduction takes integer level returns real
    //the damage reduction the arrow will suffer after hiting a target
        return 30. //+ level * 0
    endfunction
    
    private constant function Damage takes integer level returns real
    //the damage the arrow will make to each target
        return 60. * level
    endfunction
    
    private constant function Distance takes integer level returns real
    //the distance the arrow will run before dying
        return 750. * level
    endfunction
    
    private function Targets takes unit caster, unit target returns boolean
    //the targets the arrow will affect
        return IsUnitEnemy(target, GetOwningPlayer(caster)) and (GetWidgetLife(target) > .405) and (IsUnitType(target, UNIT_TYPE_MAGIC_IMMUNE) == false) and (IsUnitType(target, UNIT_TYPE_STRUCTURE) == false) and (IsUnitType(target, UNIT_TYPE_MECHANICAL) == false)
    endfunction
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================
    globals
        private boolexpr chooseVictims
        private group victims
        private unit tmpCaster
        private real mapXmin
        private real mapXmax
        private real mapYmin
        private real mapYmax
    endglobals
    
    private function PickVictims takes nothing returns boolean
        return Targets(tmpCaster, GetFilterUnit())
    endfunction
    
    private struct anArrow
        unit caster
        unit arrow
        real x_constant
        real y_constant
        integer level
        group oldVictims
        real distanceMade = 0.
        integer unitsHit = 0
        
        //method required by TimedLoop 
        private method onTimedLoop takes nothing returns boolean
            //we get the structure from the timer
            local real newX = GetUnitX(.arrow) + .x_constant
            local real newY = GetUnitY(.arrow) + .y_constant
            local unit f
            
            //if the arrow is outside the map, we simple kill it !
            if (newX > mapXmax) or (newY > mapYmax) or (newX < mapXmin) or (newY < mapYmin) then
                return TimedLoop_STOP   
            endif
            
            //moveArrow
            call SetUnitX(.arrow, newX)
            call SetUnitY(.arrow, newY)
            
            //increment the distance
            set .distanceMade = .distanceMade + ARROW_SPEED
            
            //cause the damage
            set tmpCaster = .caster
            call GroupEnumUnitsInRange(victims, newX, newY, ARROW_COLLISION, chooseVictims)
            loop
                set f = FirstOfGroup(victims)
                exitwhen(f == null)
                call GroupRemoveUnit(victims, f)
                
                //we only damage the target if it is the first time we meet him
                if (IsUnitInGroup(f, .oldVictims)==false) then
                    //damage the bad guy! xD
                    call UnitDamageTarget(.caster, f, Damage(.level) - .unitsHit * DamageReduction(.level), true, false, ATT_TYPE, DAM_TYPE, null)
                    
                    set .unitsHit = .unitsHit + 1 
                    
                    //add the bad guy to the .oldVictims group so we don't damage him again 0.03 seconds after
                    call GroupAddUnit(.oldVictims, f)
                endif
            
            endloop
            
            
            //if the distance made by the arrow is greater then the distance the arrow needs to run, we kill it!
            if .distanceMade >= Distance(.level) then
                return TimedLoop_STOP
            endif
            
            return TimedLoop_CONTINUE
        endmethod
     
        implement TimedLoop //This does the module magic
        
        static method create takes unit aCaster, location spellLoc returns anArrow
            local anArrow this = anArrow.allocate()
            local real casterX = GetUnitX(aCaster)
            local real casterY = GetUnitY(aCaster)
            local real angle = Atan2(GetLocationY(spellLoc) - casterY, GetLocationX(spellLoc) - casterX)
            
            
            //set some members
            set .caster = aCaster
            set .level = GetUnitAbilityLevel(.caster, AID)
            set .arrow = CreateUnit(GetOwningPlayer(.caster), ARROW_ID, casterX, casterY, bj_RADTODEG * angle)
            
            //Instead of saving the angle and the targets position
            //use the difference from A to B, since the movement's
            //velocity is constant, so is it's increments per 
            //interval. Only works for linear movement though.   
            set .x_constant = ( casterX + ARROW_SPEED * Cos(angle) ) - casterX
            set .y_constant = ( casterY + ARROW_SPEED * Sin(angle) ) - casterY

    
            //now we create the group to save teh old victims
            set .oldVictims = NewGroup()
            
            //The TimedLoop script works by
            // creating a startTimedLoop method that will
            // do all the dirty work and end up calling
            // .onTimedLoop...
            call .startTimedLoop()
            
            return this
        endmethod
        
        method onDestroy takes nothing returns nothing
            //Kill the arrow 
            call KillUnit(.arrow)
        
            //we recycle the group!
            call ReleaseGroup(.oldVictims)
        endmethod
    endstruct
//===========================================================================
    private function Conditions takes nothing returns boolean
        local location spellLoc
        
        if GetSpellAbilityId() == AID then
            //to prevent a leak
            set spellLoc = GetSpellTargetLoc()
            
            //we create our arrow and we are done !
            call anArrow.create(GetTriggerUnit(), spellLoc)
            
            call RemoveLocation(spellLoc)
        endif
        
        set spellLoc = null
        return false
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        local trigger ForestArrowThreeTrg = CreateTrigger(  )
        call TriggerRegisterAnyUnitEventBJ(ForestArrowThreeTrg, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddCondition(ForestArrowThreeTrg, Condition(function Conditions))
        
        //setting our globals
        set victims = CreateGroup()
        set chooseVictims = Condition(function PickVictims)
        set mapXmin = GetRectMinX(bj_mapInitialPlayableArea)
        set mapXmax = GetRectMaxX(bj_mapInitialPlayableArea)
        set mapYmin = GetRectMinY(bj_mapInitialPlayableArea)
        set mapYmax = GetRectMaxY(bj_mapInitialPlayableArea)
    endfunction
endscope

set .x_constant = ( casterX + ARROW_SPEED * Cos(angle) ) - casterX
set .y_constant = ( casterY + ARROW_SPEED * Sin(angle) ) - casterY

struct anArrow
    integer distanceMade = 0
    integer unitsHit = 0
endstruct

struct Data
    integer waves = 7
    unit caster = GetTriggerUnit()
    //more stuff
endstruct