Triggers

////////////////////////////////////////////////////////////////////
//                       APEX BLIZZARD V1.00                      //
//  Author: Tank-Commander                                        //
//  Purpose: Designed for General Frank's Icecrown Overlord       //
//           to blast away vast swathes of enemies in a           //
//           literally cool style                                 //
//                                                                //
//  Notes:                                                        //
//    -  Read the readme before you try modifying the config      //
//    -  Use the "Helpful files" to help you import the system    //
//                                                                //
//  Credits:                                                      //
//    -  (Dummy.mdl) Vexorian                                     //
//    -  (IceCube.mdl) Pyritie                                    //
//    -  (FrostNova.mdl) JetFangInferno                           //
//    -  (FrozenShell.mdl) Daelin                                 //
//    -  (FrozenOrb.mdl) Daelin                                   //
//                                                                //
//  If you have used this spell in your map, you are required     //
//  to give credits to Tank-Commander for the creation of it      //
//  If you would like to use snippets of code from this for       //
//  whatever, getting permission and crediting the source/linking //
//  would be much appreciated.                                    //
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//  README:                                                       //
//    Before modifying this spell a few things need to be         //
//    understood and read, this is one of those things, while     //
//    most modification can be considered intuitive, it still     //
//    helps to read through these intstructions, as they will     //
//    inform you about how to configure this spell to your        //
//    desire.                                                     //
//----------------------------------------------------------------//
//  Initial importing: The variable creator trigger can be        //
//  imported first and if you have the correct settings (file,    //
//  preferences, General, automatically create unknown variables  //
//  checked, then when you paste in the variable creator it       //
//  will automatically give you all the variables you need for    //
//  this spell                                                    //
//                                                                //
//  While the remaining object editor based data is not required  //
//  to function (provided they're replaced with equivelents)      //
//  it's recommended that they are also imported, if their data   //
//  value are not the same as listed in the configuration, those  //
//  configurables will need to be changed to work correctly       //
//----------------------------------------------------------------//
//                           MISC                                 //
//----------------------------------------------------------------//
//  TimerSpeed: the time in seconds between each iteration of     //
//  the main loop function (default is 0.031250000) it's          //
//  recommended you leave it like that                            //
constant function APEX_TimerSpeed takes nothing returns real
    return 0.031250000
endfunction
//----------------------------------------------------------------//
//  AbilityID: This is the data value used for the base of the    //
//  ability, it's recommended you base this off channel           //
//  (use Ctrl + D to view raw data in the object editor, do it    //
//  again to return to the normal view)                           //
constant function APEX_AbilityID takes nothing returns integer
    return 'A001'
endfunction
//----------------------------------------------------------------//
//  BuffID: This is the data value of the ability used to apply   //
//  the buff signifying that a unit is currently the target of    //
//  the spell, recommended to base this off slow aura             //
constant function APEX_BuffID takes nothing returns integer
    return 'A000'
endfunction
//----------------------------------------------------------------//
//  StunAbility: This is the data value of the ability used to    //
//  stun the units that are frozen by the ability recommended to  //
//  base this of war stomp                                        //
constant function APEX_StunAbilityID takes nothing returns integer
    return 'A003'
endfunction
//----------------------------------------------------------------//
//  StunBuffID: This is the data value of the buff that           //
//  signifies that a unit has been stunned, it should be applied  //
//  by the StunAbility when it stuns a unit                       //
constant function APEX_StunBuffID takes nothing returns integer
    return 'B001'
endfunction
//----------------------------------------------------------------//
//  DummyID: This is the data value of the dummy unit used as a   //
//  base for all of the effects of the spell, it should use       //
//  dummy.mdl as its model                                        //
constant function APEX_DummyID takes nothing returns integer
    return 'u000'
endfunction
//----------------------------------------------------------------//
//  DummyPlayer: This is the player that has ownership of all     //
//  the dummy units created by the spell, setting it to 14        //
//  ensures that the scoreboard is not interfered with            //
constant function APEX_DummyPlayer takes nothing returns player
    return Player(14)
endfunction
//----------------------------------------------------------------//
//  StunOrderID: This is the Order ID for the stun ability, for   //
//  war stomp this is 852127, it must match or units will not be  //
//  stunned by the spell                                          //
constant function APEX_StunOrderID takes nothing returns integer
    return 852127
endfunction
//----------------------------------------------------------------//
//                          DAMAGE                                //
//----------------------------------------------------------------//
//  Range: This is how far the seeking projectiles will travel    //
//  from the spell origin before being destroyed                  //
function APEX_Range takes real level returns real
    return 300 + (50 * level)
endfunction
//----------------------------------------------------------------//
//  AOE: This is the area of effect of the damage and stun of     //
//  the spell, it will be centered around the target rather than  //
//  the origin of the spell                                       //
function APEX_AOE takes real level returns real
    return 300 + (50 * level)
endfunction
//----------------------------------------------------------------//
//  AOEDamageHealth: This is the amount of damage dealt to all    //
//  units within the AOE (primary target also takes this damage)  //
function APEX_AOEDamageHealth takes real level returns real
    return 50 + (75 * level)
endfunction
//----------------------------------------------------------------//
//  AOEDamageMana: This is the amount of mana lossed by all       //
//  units within the AOE (primary target also takes this loss)    //
function APEX_AOEDamageMana takes real level returns real
    return 0.
endfunction
//----------------------------------------------------------------//
//  ProjectileDamageHealth: This is the total amount of damage    //
//  the projectiles will deal to the primary target's health      //
function APEX_ProjectileDamageHealth takes real level returns real
    return 200 + (100 * level)
endfunction
//----------------------------------------------------------------//
//  ProjectileDamageMana: This is the total amount of damage      //
//  the projectiles will deal to the primary target's mana        //
function APEX_ProjectileDamageMana takes real level returns real
    return 0.
endfunction
//----------------------------------------------------------------//
//  StunDuration: This is how long all units are stunned by the   //
//  ability in seconds                                            //
function APEX_StunDuration takes real level returns real
    return 2. + (1. * level)
endfunction
//----------------------------------------------------------------//
//  StunStartMaxTimeout: This is how long in seconds it takes     //
//  for the furthert targets (targets at max AOE distance) to     //
//  become stunned - this create a more natural expanding feel    //
//  to the stun                                                   //
function APEX_StunStartMaxTimeout takes real level returns real
    return 0.15
endfunction
//----------------------------------------------------------------//
//  AttachkType: This is the attack type used by all damaging     //
//  aspects of the spell                                          //
constant function APEX_AttackType takes nothing returns attacktype
    return ATTACK_TYPE_NORMAL
endfunction
//----------------------------------------------------------------//
//  AttachkType: This is the damage type used by all damaging     //
//  aspects of the spell                                          //
constant function APEX_DamageType takes nothing returns damagetype
    return DAMAGE_TYPE_NORMAL
endfunction
//----------------------------------------------------------------//
//  AttachkType: This is the weapon type used by all damaging     //
//  aspects of the spell                                          //
constant function APEX_WeaponType takes nothing returns weapontype
    return null
endfunction
//----------------------------------------------------------------//
//                         BEHAVIOUR                              //
//----------------------------------------------------------------//
//  ProjectileCountCircle: This is the amount of seeking lines    //
//  created by the spell (more makes it easier to hit targets)    //
function APEX_ProjectileCountCircle takes real level returns integer
    return 10
endfunction
//----------------------------------------------------------------//
//  ProjectileCountArc: This is the amount of projectiles that    //
//  are launched down each seek line, (more makes the seek line   //
//  longer and thus easier to hit targets) mostly makes the       //
//  spell look better                                             //
function APEX_ProjectileCountArc takes real level returns integer
    return 0 + (1 * R2I(level))
endfunction
//----------------------------------------------------------------//
//  ProjectileHitBox: This is how close to another unit a         //
//  seeking projectile has to get in order to hit it and set it   //
//  as the spell target                                           //
function APEX_ProjectileHitBox takes real level returns real
    return 80.
endfunction
//----------------------------------------------------------------//
//  TargetHeight: This is how far off the ground the projectiles  //
//  will aim to be (visual effect only)                           //
constant function APEX_TargetHeight takes nothing returns real
    return 70.
endfunction
//----------------------------------------------------------------//
//  ProjectileTurnRate: This is the strength at which the         //
//  Projectiles are pulled towards the target - this does affect  //
//  the speed of the projectile and should almost never be a      //
//  a negative value as that may cause crashes                    //
constant function APEX_ProjectileTurnRate takes real level returns real
    return 1.
endfunction
//----------------------------------------------------------------//
//  ProjectileTurnEfficiency: This is the rate at which existing  //
//  momentum is converted to be toward the target unit (this      //
//  will cause the projectile to slow when turning) 1 converts    //
//  50% each cycle, 0.5 converts 25% and so on                    //
constant function APEX_ProjectileTurnEfficiency takes real level returns real
    return 0.08
endfunction
//----------------------------------------------------------------//
//  ProjectileAcceleration: This is the percentage increase in    //
//  speed the projectile gains or loses each cycle (1.01 being    //
//  an increase of 1% speed)                                      //
constant function APEX_ProjectileAcceleration takes real level returns real
    return 1.01
endfunction
//----------------------------------------------------------------//
//  ProjectileLaunchPower: This is the net momentum that          //
//  projectiles are launched out of the origin point of the       //
//  spell                                                         //
constant function APEX_ProjectileLaunchPower takes real level returns real
    return 40.
endfunction
//----------------------------------------------------------------//
//  SpeedMultiplyer: This is the number of movement steps         //
//  calculated when a target has been caught, increasing this     //
//  number takes up much more processing but increases the speed  //
//  that projectiles hit their target without altering their      //
//  behaviour otherwise, 2-4 are safe values                      //
constant function APEX_SpeedMultiplyer takes real level returns integer
    return 2
endfunction
//----------------------------------------------------------------//
//  Gravity: This is the strength at which unguided projectiles   //
//  are pulled towards the ground regardless of their own         //
//  intended direction                                            //
constant function APEX_Gravity takes nothing returns real
    return 0.3065
endfunction
//----------------------------------------------------------------//
//                          MODELS                                //
//----------------------------------------------------------------//
//  ProjectileAttachmentPoint: This is where on the dummy unit    //
//  that the ProjectileModel will be attached                     //
constant function APEX_ProjectileAttachmentPoint takes nothing returns string
    return "origin"
endfunction
//----------------------------------------------------------------//
//  ProjectileModel: This is the path for the model used for the  //
//  projecitles, remember to place double slashes ("\\") instead  //
//  of single slashes ("\") as this will cause a compilation      //
//  error                                                         //
constant function APEX_ProjectileModel takes nothing returns string
    return "war3mapImported\\FrozenOrb.mdl"
endfunction
//----------------------------------------------------------------//
//  ProjectileScale: This is the size of the projectiles relative //
//  to the base model's size (1. = 100% or normal size)           //
function APEX_ProjectileScale takes real level returns real
    return 0.8 + (0.1 * level)
endfunction
//----------------------------------------------------------------//
//  ExplosionAttachmentPoint: This is where on the dummy unit     //
//  that the explosion (AOE effect) will be attached              //
constant function APEX_ExplosionAttachmentPoint takes nothing returns string
    return "origin"
endfunction
//----------------------------------------------------------------//
//  ExplosionModel: This is the path for the model used for the   //
//  explosion (AOE effect)                                        //
constant function APEX_ExplosionModel takes nothing returns string
    return "war3mapImported\\FrostNova.mdx"
endfunction
//----------------------------------------------------------------//
//  TargetAttachmentPoint: This is where on the target unit that  //
//  the target marker (identifies that this unit is being         //
//  targetted by the spell) will be attached                      //
constant function APEX_TargetAttachmentPoint takes nothing returns string
    return "chest"
endfunction
//----------------------------------------------------------------//
//  TargetModel: This is the path for the model used for the      //
//  target marker                                                 //
constant function APEX_TargetModel takes nothing returns string
    return "war3mapImported\\FrozenShell.MDX"
endfunction
//----------------------------------------------------------------//
//  FrozenAttachmentPoint: This is where on frozen units that     //
//  the frozen effect (identifies that this unit is stunned)      //
//  will be attached                                              //
constant function APEX_FrozenAttachmentPoint takes nothing returns string
    return "origin"
endfunction
//----------------------------------------------------------------//
//  FrozenModel: This is the path for the model used for the      //
//  frozen effect                                                 //
constant function APEX_FrozenModel takes nothing returns string
    return "war3mapImported\\ice cube.mdx"
endfunction
//----------------------------------------------------------------//
//  StartEffectModel: This is the path for the effect used at     //
//  start of the spell that projectiles are launched from         //
constant function APEX_StartEffectModel takes nothing returns string    
    return "Abilities\\Spells\\Undead\\FrostNova\\FrostNovaTarget.mdl"
endfunction
//----------------------------------------------------------------//
//                        READ ONLY                               //
//----------------------------------------------------------------//
//  SpellCoreStageID: This is the ID given to spell cores to      //
//  make sure they run their aspects of the code only             //
constant function APEX_SpellCoreStageID takes nothing returns integer
    return 1
endfunction
//----------------------------------------------------------------//
//  ProjectileStageID: This is the ID given to proejctiles to     //
//  make sure they run their aspects of the code only             //
constant function APEX_ProjectileStageID takes nothing returns integer
    return 2
endfunction
//----------------------------------------------------------------//
//  StunnedUnitStageID: This is the ID given to stunned units to  //
//  make sure they run their aspects of the code only             //
constant function APEX_StunnedUnitStageID takes nothing returns integer
    return 3
endfunction
//----------------------------------------------------------------//
//                     END OF CONFIGURATION                       //
//----------------------------------------------------------------//
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//  Target filter function used to differentiate between units    //
//  that can be hit by the spell and those that cannot            //
////////////////////////////////////////////////////////////////////
function APEX_TargetFilter takes unit u, player pl returns boolean
    return (not IsUnitType(u, UNIT_TYPE_STRUCTURE)) and (not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE)) and (IsUnitEnemy(u, pl)) and (GetUnitTypeId(u) != APEX_DummyID()) and not(IsUnitType(u, UNIT_TYPE_DEAD) or GetUnitTypeId(u) == 0)
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to get the Z location height at a given point   //
////////////////////////////////////////////////////////////////////
function APEX_GetZ takes real x, real y returns real
    call MoveLocation(udg_APEX_ZLoc, x, y)
    return GetLocationZ(udg_APEX_ZLoc)
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to make sure that the location is within the    //
//  map bounds so that units cannot be moved outside of it and    //
//  get permanently stuck                                         //
////////////////////////////////////////////////////////////////////
function APEX_ValidateLocation takes real x, real y returns boolean
    //Check if the point is within the map bounds
    return (x < udg_APEX_MapMaxX) and (x > udg_APEX_MapMinX) and (y < udg_APEX_MapMaxY) and (y > udg_APEX_MapMinY)
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to get the distance between two points (3D)     //
////////////////////////////////////////////////////////////////////
function APEX_Get3DDistance takes real x, real x2, real y, real y2, real z, real z2 returns real
    return SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y) + (z2 - z) * (z2 - z))
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to get the distance between two points (2D)     //
////////////////////////////////////////////////////////////////////
function APEX_Get2DDistance takes real x, real x2, real y, real y2 returns real
    return SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to remove instances from the linked list once   //
//  they have expired                                             //
////////////////////////////////////////////////////////////////////
function APEX_RecycleNode takes integer node returns nothing
    set udg_APEX_RecycleNodes[udg_APEX_RecyclableNodes] = node
    set udg_APEX_RecyclableNodes = udg_APEX_RecyclableNodes + 1
    set udg_APEX_NextNode[udg_APEX_PrevNode[node]] = udg_APEX_NextNode[node]
    set udg_APEX_PrevNode[udg_APEX_NextNode[node]] = udg_APEX_PrevNode[node]
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to add new nodes to the linked list used by the //
//  spell                                                         //
////////////////////////////////////////////////////////////////////
function APEX_CreateNode takes nothing returns integer
    local integer node

    if (udg_APEX_RecyclableNodes == 0) then
        set udg_APEX_NodeNumber = udg_APEX_NodeNumber + 1
        set node = udg_APEX_NodeNumber
    else
        set udg_APEX_RecyclableNodes = udg_APEX_RecyclableNodes - 1
        set node = udg_APEX_RecycleNodes[udg_APEX_RecyclableNodes]
    endif
    
    set udg_APEX_NextNode[node] = 0
    set udg_APEX_NextNode[udg_APEX_PrevNode[0]] = node
    set udg_APEX_PrevNode[node] = udg_APEX_PrevNode[0]
    set udg_APEX_PrevNode[0] = node
    
    return node
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to handle the behaviour of the projectiles      //
//  while in-flight and reports if the projectile has crashed     //
////////////////////////////////////////////////////////////////////
function APEX_MoveProjectile takes integer node returns boolean
    //Set up locals
    local real dy = udg_APEX_TargetY[node] - udg_APEX_ProjectileY[node]
    local real dx = udg_APEX_TargetX[node]- udg_APEX_ProjectileX[node]
    local real x
    local real y
    local real z
    local real Angle = Atan2(dy, dx)
    local real Angle2 = Atan2((APEX_GetZ(udg_APEX_TargetX[node], udg_APEX_TargetY[node]) + udg_APEX_TargetZ[node]) - (APEX_GetZ(udg_APEX_ProjectileX[node], udg_APEX_ProjectileY[node]) + GetUnitFlyHeight(udg_APEX_Unit[node])), Pow(dx * dx + dy * dy, 0.5))
    local real TempReal = Pow((udg_APEX_ZVel[node] * udg_APEX_ZVel[node]) + (udg_APEX_XVel[node] * udg_APEX_XVel[node]) + (udg_APEX_YVel[node] * udg_APEX_YVel[node]), 0.5) * udg_APEX_ProjectileTurnEfficiency[udg_APEX_Parent[node]]
    local real TempReal2 = 1/(1 + udg_APEX_ProjectileTurnEfficiency[udg_APEX_Parent[node]]) 
    local unit u
    
    //Calculate new velocities
    set udg_APEX_ZVel[node] = ((udg_APEX_ZVel[node] + (TempReal + udg_APEX_ProjectileTurnRate[udg_APEX_Parent[node]]) * Sin(Angle2)) * udg_APEX_ProjectileAcceleration[udg_APEX_Parent[node]]) * TempReal2
    set udg_APEX_XVel[node] = ((udg_APEX_XVel[node] + (TempReal + udg_APEX_ProjectileTurnRate[udg_APEX_Parent[node]]) * Cos(Angle) * Cos(Angle2)) * udg_APEX_ProjectileAcceleration[udg_APEX_Parent[node]]) * TempReal2
    set udg_APEX_YVel[node] = ((udg_APEX_YVel[node] + (TempReal + udg_APEX_ProjectileTurnRate[udg_APEX_Parent[node]]) * Sin(Angle) * Cos(Angle2)) * udg_APEX_ProjectileAcceleration[udg_APEX_Parent[node]]) * TempReal2
    set udg_APEX_ProjectileHeight[node] = udg_APEX_ProjectileHeight[node] + udg_APEX_ZVel[node] - APEX_Gravity()
    
    set x = udg_APEX_ProjectileX[node] + udg_APEX_XVel[node]
    set y = udg_APEX_ProjectileY[node] + udg_APEX_YVel[node]
    set z = udg_APEX_ProjectileHeight[node] - APEX_GetZ(x, y)
    
    //Make sure the location is within the map bounds
    if APEX_ValidateLocation(x, y) then
        set udg_APEX_ProjectileX[node] = x
        set udg_APEX_ProjectileY[node] = y
        call SetUnitX(udg_APEX_Unit[node], x)
        call SetUnitY(udg_APEX_Unit[node], y)
    endif
    
    //Apply visuals
    call SetUnitFlyHeight(udg_APEX_Unit[node], z, 0.)
    call SetUnitFacing(udg_APEX_Unit[node], bj_RADTODEG * Atan2(udg_APEX_YVel[node], udg_APEX_XVel[node]))
    set udg_APEX_ProjectileAnimation[node] = R2I(Atan2((udg_APEX_ZVel[node]), Pow((udg_APEX_XVel[node] * udg_APEX_XVel[node]) + (udg_APEX_YVel[node] * udg_APEX_YVel[node]), 0.5) * bj_RADTODEG + 0.5)) + 70
    call SetUnitAnimationByIndex(udg_APEX_Unit[node], udg_APEX_ProjectileAnimation[node])
    
    //Update target unit information if applicable
    if (udg_APEX_Target[udg_APEX_Parent[node]] == null) then
        
        //Check range from origin point
        if (APEX_Get3DDistance(x, udg_APEX_OriginX[udg_APEX_Parent[node]], y, udg_APEX_OriginY[udg_APEX_Parent[node]], udg_APEX_ProjectileHeight[node], udg_APEX_OriginZ[udg_APEX_Parent[node]]) >= udg_APEX_Range[udg_APEX_Parent[node]]) then
            //Too far, destroy
            set udg_APEX_ProjectileCount[udg_APEX_Parent[node]] = udg_APEX_ProjectileCount[udg_APEX_Parent[node]] - 1
            call DestroyEffect(udg_APEX_CurrentEffect[node])
            call KillUnit(udg_APEX_Unit[node])
            call APEX_RecycleNode(node)
        else
            //Look for targets 
            call GroupEnumUnitsInRange(udg_APEX_TempGroup, x, y, udg_APEX_ProjectileHitBox[udg_APEX_Parent[node]], null)
                   
            loop
                set u = FirstOfGroup(udg_APEX_TempGroup)
                exitwhen (u == null or not(udg_APEX_Target[udg_APEX_Parent[node]] == null))
                               
                if (APEX_TargetFilter(u, udg_APEX_Player[udg_APEX_Parent[node]])) then
                    //Target found, set up data
                    set udg_APEX_ProjectileDamageHealth[udg_APEX_Parent[node]] = udg_APEX_ProjectileDamageHealth[udg_APEX_Parent[node]] / udg_APEX_ProjectileCount[udg_APEX_Parent[node]]
                    set udg_APEX_ProjectileDamageMana[udg_APEX_Parent[node]] = udg_APEX_ProjectileDamageMana[udg_APEX_Parent[node]] / udg_APEX_ProjectileCount[udg_APEX_Parent[node]]
                    set udg_APEX_Target[udg_APEX_Parent[node]] = u
                    set udg_APEX_SpeedMultiplyer[udg_APEX_Parent[node]] = udg_APEX_MaxSpeed[udg_APEX_Parent[node]]
                    set udg_APEX_CurrentEffect[udg_APEX_Parent[node]] = AddSpecialEffectTarget(APEX_TargetModel(), u, APEX_TargetAttachmentPoint())
                    call UnitAddAbility(u, APEX_BuffID())
                endif
                                
                call GroupRemoveUnit(udg_APEX_TempGroup, u)
            endloop
            
        endif
        
    //Check if target has been hit
    elseif (APEX_Get3DDistance(x, udg_APEX_TargetX[node], y, udg_APEX_TargetY[node], z, udg_APEX_TargetZ[node]) <= udg_APEX_ProjectileHitBox[udg_APEX_Parent[node]]) then
        return true
    else
        //Update target point
        set udg_APEX_TargetX[node] = GetUnitX(udg_APEX_Target[udg_APEX_Parent[node]])
        set udg_APEX_TargetY[node] = GetUnitY(udg_APEX_Target[udg_APEX_Parent[node]])
        set udg_APEX_TargetZ[node] = GetUnitFlyHeight(udg_APEX_Target[udg_APEX_Parent[node]]) + APEX_TargetHeight()
    endif
    
    return false
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to detect if a unit is currently stunned by     //
//  the spell to permit spell overwrite                           //
////////////////////////////////////////////////////////////////////
function APEX_GetStunNode takes unit u returns integer
    local integer node = 0
    
    loop
        set node = udg_APEX_NextNode[node]
        exitwhen node == 0 or udg_APEX_Unit[node] == u
    endloop
    
    if (node == 0) then
        set node = APEX_CreateNode()
        set udg_APEX_NO_PREV_STUN = true
    else
        set udg_APEX_NO_PREV_STUN = false
    endif
    
    return node
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to set up new units being stunned and adding    //
//  them to the linked list                                       //
////////////////////////////////////////////////////////////////////
function APEX_FreezeUnit takes unit u, integer parent, real x, real y returns nothing
    local integer node = APEX_GetStunNode(u)
    
    set udg_APEX_Unit[node] = u
    set udg_APEX_StageID[node] = APEX_StunnedUnitStageID()
    
    if (udg_APEX_NO_PREV_STUN) then
        set udg_APEX_NotStunned[node] = true
        set udg_APEX_StunStartTimeout[node] = APEX_Get2DDistance(x, GetUnitX(u), y, GetUnitY(u)) * udg_APEX_StunStartMultiplyer[parent]
        set udg_APEX_StunDurationTimeout[node] = udg_APEX_StunDuration[parent]
    elseif udg_APEX_StunDuration[parent] > udg_APEX_StunDurationTimeout[node] then
        set udg_APEX_StunDurationTimeout[node] = udg_APEX_StunDuration[parent]
    endif
    
endfunction
////////////////////////////////////////////////////////////////////
//  Function used to run the main engine of the spell, handles    //
//  creation of new units, buff control and projectile control    //
////////////////////////////////////////////////////////////////////
function APEX_Loop takes nothing returns nothing
    //Set up locals
    local integer node = 0
    local integer i = 0
    local unit u
    local real x
    local real y
    
    loop
        set node = udg_APEX_NextNode[node]
        exitwhen node == 0
        
        //Handle projectiles
        if (udg_APEX_StageID[node] == APEX_ProjectileStageID()) then
            set i = 0
            
            //Handle speed boost
            loop
                set i = i + 1
                exitwhen ((i > udg_APEX_SpeedMultiplyer[udg_APEX_Parent[node]]) or IsUnitType(udg_APEX_Unit[node], UNIT_TYPE_DEAD))
        
                //Move projectiles
                if (APEX_MoveProjectile(node)) then
                    //Target hit damage and destroy projectile
                    call UnitDamageTarget(udg_APEX_Unit[udg_APEX_Parent[node]], udg_APEX_Target[udg_APEX_Parent[node]], udg_APEX_ProjectileDamageHealth[udg_APEX_Parent[node]], false, false, APEX_AttackType(), APEX_DamageType(), APEX_WeaponType())
                    call SetUnitState(udg_APEX_Target[udg_APEX_Parent[node]], UNIT_STATE_MANA, GetUnitState(udg_APEX_Target[udg_APEX_Parent[node]], UNIT_STATE_MANA) - udg_APEX_ProjectileDamageMana[udg_APEX_Parent[node]])
                    call DestroyEffect(udg_APEX_CurrentEffect[node])
                    call KillUnit(udg_APEX_Unit[node])
                    call APEX_RecycleNode(node)
                    
                    set udg_APEX_ProjectileCount[udg_APEX_Parent[node]] = udg_APEX_ProjectileCount[udg_APEX_Parent[node]] - 1
                endif
                
                
            endloop
            
        //Handle frozen units
        elseif (udg_APEX_StageID[node] == APEX_StunnedUnitStageID()) then
            if (udg_APEX_NotStunned[node]) then
            
                if (udg_APEX_StunStartTimeout[node] <= 0.) then
                    //Stun the unit
                    set udg_APEX_CurrentEffect[node] = AddSpecialEffectTarget(APEX_FrozenModel(), udg_APEX_Unit[node], APEX_FrozenAttachmentPoint())
                    call SetUnitX(udg_APEX_Stunner, GetUnitX(udg_APEX_Unit[node]))
                    call SetUnitY(udg_APEX_Stunner, GetUnitY(udg_APEX_Unit[node]))
                    call IssueImmediateOrderById(udg_APEX_Stunner, APEX_StunOrderID())
                    call SetUnitTimeScale(udg_APEX_Unit[node], 0.)
                    set udg_APEX_NotStunned[node] = false
                endif
                
                set udg_APEX_StunStartTimeout[node] = udg_APEX_StunStartTimeout[node] - APEX_TimerSpeed()
            
            elseif (udg_APEX_StunDurationTimeout[node] <= 0.) or (IsUnitType(udg_APEX_Unit[node], UNIT_TYPE_DEAD)) then
                //Remove the stun
                call UnitRemoveAbility(udg_APEX_Unit[node], APEX_StunBuffID())
                call SetUnitTimeScale(udg_APEX_Unit[node], 1.)
                call DestroyEffect(udg_APEX_CurrentEffect[node])
                call APEX_RecycleNode(node)
                
               //Stops the timer if this is the only remaining Node
                if (udg_APEX_PrevNode[0] == 0) then
                    call PauseTimer(udg_APEX_Timer)
                endif
                
            else
                set udg_APEX_StunDurationTimeout[node] = udg_APEX_StunDurationTimeout[node] - APEX_TimerSpeed()
            endif
            
        //Handle spell core
        elseif (udg_APEX_ProjectileCount[node] == 0) then
                
            if not(udg_APEX_Target[node] == null) then
                //Play ending effect
                call UnitRemoveAbility(udg_APEX_Target[node], APEX_BuffID())
                call DestroyEffect(udg_APEX_CurrentEffect[node])
                call DestroyEffect(AddSpecialEffectTarget(APEX_ExplosionModel(), udg_APEX_Target[node], APEX_ExplosionAttachmentPoint()))
            
                //Damage and freeze units
                set x = GetUnitX(udg_APEX_Target[node])
                set y = GetUnitY(udg_APEX_Target[node])
                call GroupEnumUnitsInRange(udg_APEX_TempGroup, x, y, udg_APEX_AOE[node], null)
           
                loop
                    set u = FirstOfGroup(udg_APEX_TempGroup)
                    exitwhen u == null
                                   
                    if (APEX_TargetFilter(u, udg_APEX_Player[node])) then
                        call UnitDamageTarget(udg_APEX_Unit[node], u, udg_APEX_AOEDamageHealth[node], false, false, APEX_AttackType(), APEX_DamageType(), APEX_WeaponType())
                        call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_APEX_AOEDamageMana[node])
                        call APEX_FreezeUnit(u, node, x, y)
                    endif
                                    
                    call GroupRemoveUnit(udg_APEX_TempGroup, u)
                endloop
                
            endif
            
            call APEX_RecycleNode(node)
            
            //Stops the timer if this is the only remaining Node
            if (udg_APEX_PrevNode[0] == 0) then
                call PauseTimer(udg_APEX_Timer)
            endif
            
        endif
        
    endloop
    
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to create new projectiles                       //
////////////////////////////////////////////////////////////////////
function APEX_CreateProjectile takes integer parent, real x, real y, real angle, real angle2, real arc returns nothing
    local integer node = APEX_CreateNode()
    
    //set up projectile data
    set udg_APEX_Parent[node] = parent
    set udg_APEX_Unit[node] = CreateUnit(APEX_DummyPlayer(), APEX_DummyID(), udg_APEX_OriginX[udg_APEX_Parent[node]], udg_APEX_OriginY[udg_APEX_Parent[node]], angle)
    set udg_APEX_StageID[node] = APEX_ProjectileStageID()
    set udg_APEX_CurrentEffect[node] = AddSpecialEffectTarget(APEX_ProjectileModel(), udg_APEX_Unit[node], APEX_ProjectileAttachmentPoint())
    call SetUnitScale(udg_APEX_Unit[node], udg_APEX_ProjectileScale[parent], 0., 0.)
    if UnitAddAbility(udg_APEX_Unit[node], 'Amrf') and UnitRemoveAbility(udg_APEX_Unit[node], 'Amrf') then
    endif
    
    set udg_APEX_ProjectileX[node] = udg_APEX_OriginX[udg_APEX_Parent[node]]
    set udg_APEX_ProjectileY[node] = udg_APEX_OriginY[udg_APEX_Parent[node]]
    set udg_APEX_TargetX[node] = x
    set udg_APEX_TargetY[node] = y
    set udg_APEX_TargetZ[node] = APEX_TargetHeight()
    set udg_APEX_ProjectileHeight[node] = udg_APEX_OriginZ[udg_APEX_Parent[node]]
    call SetUnitFlyHeight(udg_APEX_Unit[node], udg_APEX_ProjectileHeight[node] - udg_APEX_TempReal[udg_APEX_Parent[node]], 0.)
    
    set udg_APEX_XVel[node] = udg_APEX_ProjectileLaunchPower[udg_APEX_Parent[node]] * Cos(angle2) * Cos(arc)
    set udg_APEX_YVel[node] = udg_APEX_ProjectileLaunchPower[udg_APEX_Parent[node]] * Sin(angle2) * Cos(arc)
    set udg_APEX_ZVel[node] = udg_APEX_ProjectileLaunchPower[udg_APEX_Parent[node]] * Sin(arc)
    
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to start an instance of the spell               //
////////////////////////////////////////////////////////////////////
function APEX_OnCast takes nothing returns boolean
    //Set up locals
    local integer node
    local integer spellID = GetSpellAbilityId()
    local integer projCountCircle
    local integer projCountArc
    local integer i = 0
    local integer i2
    local real level
    local real angle = 0
    local real radAngle
    local real angleIncrement
    local real arc = 0
    local real arcIncrement
    local real x
    local real y
    local real z
    
    //Check if something was infected
    if (spellID == APEX_AbilityID()) then
        //Set up spell data
        set node = APEX_CreateNode()
        set udg_APEX_Unit[node] = GetTriggerUnit()
        set level = GetUnitAbilityLevel(udg_APEX_Unit[node], APEX_AbilityID())
        set projCountCircle = APEX_ProjectileCountCircle(level)
        set projCountArc = APEX_ProjectileCountArc(level)      
        set udg_APEX_StageID[node] = APEX_SpellCoreStageID()
        set udg_APEX_Parent[node] = node
        set udg_APEX_Target[node] = null
        set udg_APEX_Player[node] = GetTriggerPlayer()
        set udg_APEX_TempReal[node] = APEX_GetZ(udg_APEX_OriginX[node], udg_APEX_OriginY[node])
        set udg_APEX_OriginX[node] = GetSpellTargetX()
        set udg_APEX_OriginY[node] = GetSpellTargetY()
        set udg_APEX_OriginZ[node] = udg_APEX_TempReal[node] + APEX_TargetHeight()
        set udg_APEX_ProjectileScale[node] = APEX_ProjectileScale(level) 
        set udg_APEX_AOE[node] = APEX_AOE(level)
        set udg_APEX_AOEDamageHealth[node] = APEX_AOEDamageHealth(level)
        set udg_APEX_AOEDamageMana[node] = APEX_AOEDamageMana(level)
        set udg_APEX_Range[node] = APEX_Range(level)
        set udg_APEX_StunDuration[node] = APEX_StunDuration(level)
        set udg_APEX_StunStartMultiplyer[node] = APEX_StunStartMaxTimeout(level) / udg_APEX_AOE[node] 
        set udg_APEX_ProjectileCount[node] = projCountCircle * projCountArc
        set udg_APEX_ProjectileDamageHealth[node] = APEX_ProjectileDamageHealth(level)
        set udg_APEX_ProjectileDamageMana[node] = APEX_ProjectileDamageMana(level)
        set udg_APEX_ProjectileHitBox[node] = APEX_ProjectileHitBox(level)
        set udg_APEX_ProjectileTurnRate[node] = APEX_ProjectileTurnRate(level)
        set udg_APEX_ProjectileTurnEfficiency[node] = APEX_ProjectileTurnEfficiency(level)
        set udg_APEX_ProjectileAcceleration[node] = APEX_ProjectileAcceleration(level)
        set udg_APEX_ProjectileLaunchPower[node] = APEX_ProjectileLaunchPower(level)
        set udg_APEX_SpeedMultiplyer[node] = 1
        set udg_APEX_MaxSpeed[node] = APEX_SpeedMultiplyer(level)
        
        //Start Timer
        if udg_APEX_PrevNode[node] == 0 then
            call TimerStart(udg_APEX_Timer, APEX_TimerSpeed(), true, function APEX_Loop)
        endif
        
        call DestroyEffect(AddSpecialEffect(APEX_StartEffectModel(), udg_APEX_OriginX[node], udg_APEX_OriginY[node]))
        
        //Create projectiles
        set angleIncrement = 360. / projCountCircle
        set arcIncrement = bj_PI / 2. / projCountArc
        
        loop
            set i = i + 1
            exitwhen i > projCountCircle
            set i2 = 0
            set angle = angle + angleIncrement
            set radAngle = bj_DEGTORAD * angle
            set arc = 0
            
            set x = udg_APEX_OriginX[node] + udg_APEX_Range[node] * Cos(radAngle)
            set y = udg_APEX_OriginY[node] + udg_APEX_Range[node] * Sin(radAngle)
            
            loop
                set i2 = i2 + 1
                exitwhen i2 > projCountArc
                
                call APEX_CreateProjectile(node, x, y, angle, radAngle, arc)

                set arc = arc + arcIncrement
            endloop
            
        endloop
        
    endif
    
    return false
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to register the trigger of the ability          //
////////////////////////////////////////////////////////////////////
function InitTrig_Apex_Blizzard takes nothing returns nothing
    //Set up local variables
    local trigger t = CreateTrigger()
    
    //Set up trigger
    call TriggerRegisterAnyUnitEventBJ(t,EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function APEX_OnCast))
    set udg_APEX_ZLoc = Location(0., 0.)
    
    //Sets up the variables used to make sure a point is within the map area
    set udg_APEX_MapMaxX = GetRectMaxX(bj_mapInitialPlayableArea)
    set udg_APEX_MapMinX = GetRectMinX(bj_mapInitialPlayableArea)
    set udg_APEX_MapMaxY = GetRectMaxY(bj_mapInitialPlayableArea)
    set udg_APEX_MapMinY = GetRectMinY(bj_mapInitialPlayableArea)
    set udg_APEX_Stunner = CreateUnit(APEX_DummyPlayer(), APEX_DummyID(), 0., 0., 0.)
    call UnitAddAbility(udg_APEX_Stunner, APEX_StunAbilityID())
endfunction
////////////////////////////////////////////////////////////////////
//END OF THE SPELL                                                //
////////////////////////////////////////////////////////////////////