scope Jump initializer Init

globals
    private constant real ARC           = 1.8 //the jump arc
    private constant integer SPELL_ID   = 'A001' //the dummy ability id
    private constant integer FLY_HACK   = 'Amrf' //the ability id of crow form
    private constant real MISSILE_SPEED = 500.00 //the speed of the missile
endglobals

//data struct, containing a single boolean
private struct Data
    boolean paused = false
endstruct

function Conditions takes nothing returns boolean
    return GetSpellAbilityId() == SPELL_ID
endfunction

//Thanks to Shadow1500 for this function
private function JumpParabola takes real dist, real maxdist returns real
    local real t = (dist*2)/maxdist-1
    return (-t*t+1)*(maxdist/ARC)
endfunction

private struct Actions extends MissileActions
    //The onHit function, this stops the unit from moving as a missile and unpauses it. It also
    //destroys the attached data
    method onHit takes nothing returns boolean
        local Data d = GetEventMissile.data
        //unpause the unit
        call PauseUnit(GetEventMissile.Dummy, false)
        //destroy the attached data
        call d.destroy()
        //return false to stop the missile
        return false
    endmethod

    //The onLoop function, this sets the unit's fly height to the appropriate value for the
    //parabola
    method onLoop takes nothing returns boolean
        //use Shadow1500's function for a jump parabola to get the current fly height
        local real parabola = JumpParabola(GetEventMissile.CurrentDist, GetEventMissile.StartDist)
        //store the attached data in a usable variable
        local Data d = GetEventMissile.data
        //set the unit's fly height to the height defined by the parabola
        call SetUnitFlyHeight(GetEventMissile.Dummy, parabola, 0.00)
        //The following is necessary to do after the initial cast action because not doing so
        //can cause the spell's cooldown and mana cost to function
        //incorrectly. Also, if it is not done, the unit will repeatedly try to cast the spell
        //after it has landed, until another order is issued.
        if not d.paused then //if the attached data says the unit is not already paused then..
            call PauseUnit(GetEventMissile.Dummy, true) //pause the unit
            set d.paused = true //and tell the function it is paused
        endif
        return true //returning true means the missile keeps moving
    endmethod
endstruct

private function TrigActions takes nothing returns nothing
    local location target = GetSpellTargetLoc()
    //get the target x and y values from the location variable
    local real x = GetLocationX(target)
    local real y = GetLocationY(target)
    //create the missile from the trigger unit, with a radius 0 - we don't want any collision
    //also defines the onHit and onLoop actions.
    local Missile m = Missile.createFromUnit(GetTriggerUnit(), 0.00, Actions.create())
    //attaches data to the missile
    set m.data = Data.create()
    //add, then remove the crow form ability to give the unit the ability to fly
    call UnitAddAbility(GetTriggerUnit(), FLY_HACK)
    call UnitRemoveAbility(GetTriggerUnit(), FLY_HACK)
    //finally, fire the missile (make the unit jump) at speed 500.00
    call m.fireFixed(GetTriggerUnit(), x, y, MISSILE_SPEED)
   
    call RemoveLocation(target)
    set target = null
endfunction

//===========================================================================
private function Init takes nothing returns nothing
    //create the trigger and register the conditions / actions
    local trigger t = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ( t, EVENT_PLAYER_UNIT_SPELL_EFFECT )
    call TriggerAddCondition( t, Condition( function Conditions ) )
    call TriggerAddAction( t, function TrigActions )
endfunction

endscope

scope Fireball initializer Init

globals
    private constant integer SPELL_ID       = 'A000' //the dummy ability id
    //the missile model
    private constant string SFX             = "Abilities\\Weapons\\FireBallMissile\\FireBallMissile.mdl"
    private constant real AOE               = 250.00 //the explosion radius
    private constant real MISSILE_RADIUS    = 50.00 //the collision radius
    private constant real MISSILE_SPEED     = 500.00 //the speed of the missile
    private constant real DAMAGE            = 100.00 //the damage of the missile
    private constant real MAX_RANGE         = 600.00 //the maximum distance a firebal may
                                                     //travel before it automatically
                                                     //explodes
   
    private group ENUM_GROUP = CreateGroup() //a group used for instant enumerations
    private boolexpr filter //the filter to decide which units are damaged by the fireball
endglobals

private function Conditions takes nothing returns boolean
    return GetSpellAbilityId() == SPELL_ID
endfunction

//the filter function - checks if the enumerated unit is an enemy of the caster, and that
//it's not immune to magic.
private function TheFilter takes nothing returns boolean
    return IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(GetEventMissile.Caster)) and not IsUnitType(GetFilterUnit(), UNIT_TYPE_MAGIC_IMMUNE)
endfunction

//the actions struct, containing onHit and onLoop actions
private struct Actions extends MissileActions
    method onHit takes nothing returns boolean
        local unit u //unit used in the group loop
        local unit caster = GetEventMissile.Caster //it's easier to type "caster" than
                                                   //"GetEventMissile.Caster"
       
        //if this onHit call was caused by the missile reaching it's target, we do not
        //want it to explode.
        if GetEventMissile.OnTarget then
            set caster = null
            return true
        endif
       
        //enumerate the units within range which match the filter
        call GroupEnumUnitsInRange(ENUM_GROUP, GetEventMissile.X, GetEventMissile.Y, AOE, filter)
       
        //if no units matched the enumeration, don't explode the missile
        if FirstOfGroup(ENUM_GROUP) == null then
            set caster = null
            return true
        endif
       
        //loop through the enumerated units, damaging them
        loop
            set u = FirstOfGroup(ENUM_GROUP)
            exitwhen u == null
           
            //make the caster damage the unit with fire damage
            call UnitDamageTarget(caster, u, DAMAGE, false, true, ATTACK_TYPE_MAGIC, DAMAGE_TYPE_FIRE, null)
           
            call GroupRemoveUnit(ENUM_GROUP, u)
        endloop
       
        //clean leaks
        set caster = null
       
        //return false to stop the missile
        return false
    endmethod
   
    method onLoop takes nothing returns boolean
        //if the missile has travelled further than the maximum range, explode it
        if GetEventMissile.CurrentDist >= MAX_RANGE then
            call .onHit()
            return false
        endif
        return true
    endmethod
endstruct

private function TrigActions takes nothing returns nothing
    local location target = GetSpellTargetLoc()
    //find the start x/y and target x/y
    local real x0 = GetUnitX(GetTriggerUnit())
    local real y0 = GetUnitY(GetTriggerUnit())
    local real x1 = GetLocationX(target)
    local real y1 = GetLocationY(target)
    //create the missile at the start x/y
    local Missile m = Missile.create(SFX, x0, y0, MISSILE_RADIUS, Actions.create())
    //fire the missile towards the target x/y
    call m.fireFixed(GetTriggerUnit(), x1, y1, MISSILE_SPEED)
   
    call RemoveLocation(target)
    set target = null
endfunction

//===========================================================================
private function Init takes nothing returns nothing
    //create the trigger / register actions, conditions and events
    local trigger t = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function Conditions ))
    call TriggerAddAction(t, function TrigActions)
   
    //preload the effects to prevent lag
    call Preload(SFX)
   
    //create the filter
    set filter = Filter(function TheFilter)
endfunction

endscope

scope LightningHail initializer Init

globals
    private constant integer SPELL_ID       = 'A002' //the dummy ability id
    private constant integer DUMMY_ID       = 'LSdm' //the dummy unit
    private constant player OWNER           = Player(15) //the player to own the dummy unit
    private constant real MISSILE_SPEED     = 200.00 //the speed of the missile
    private constant real SMALL_SPEED       = 50.00 //the speed of the small balls which
                                                    //spawn when the missile explodes
    private constant real STEP_SIZE         = 200.00 //how far the missile moves for each of
                                                     //the below variables to take effect
    private constant real AREA_PER_STEP     = 50.00 //how much wider the area grows per step
    private constant real AOE_PER_STEP      = 25.00 //how much more AOE the smaller balls
                                                    //have per step
    private constant real DAMAGE_PER_STEP   = 50.00 //how much more damage the balls do per
                                                    //step
    private constant real HEIGHT_PER_STEP   = 100.00//how high the ball rises per step
    private constant real SIZE_PER_STEP     = 1.00  //how much the ball grows per step
    private constant integer NUM_BALLS      = 6     //how many smaller balls spawn when the
                                                    //large ball explodes
    private constant real 2PI               = 2 * bj_PI //constant to speed up things with
                                                        //the radians - equivalent to 360
                                                        //degress
   
    private group ENUM_GROUP = CreateGroup() //group used for instant enumerations
    private boolexpr filter //filter for the units hittable by the spell
endglobals

private function Conditions takes nothing returns boolean
    return GetSpellAbilityId() == SPELL_ID
endfunction

//the filter checks if the unit is an enemy of the caster and that the unit isn't immune to
//magic
private function TheFilter takes nothing returns boolean
    return IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(GetEventMissile.Caster)) and not IsUnitType(GetFilterUnit(), UNIT_TYPE_MAGIC_IMMUNE)
endfunction

//Data struct for the small balls
private struct Data2
    real damage //how much damage they will deal
    real aoe    //the area of effect in which they will deal the damage
    real z      //the current height of the balls
    real zfall  //the amount the balls fall by in each onLoop call
endstruct

private struct Actions2 extends MissileActions
    method onHit takes nothing returns boolean
        local Data2 d = GetEventMissile.data //store the missile data in a usable variable
        local unit u //used for the group loop
       
        //enumerate all the damageable units within the aoe
        call GroupEnumUnitsInRange(ENUM_GROUP, GetEventMissile.X, GetEventMissile.Y, d.aoe, filter)
       
        //loopp through the enumerated units, damaging them respectively
        loop
            set u = FirstOfGroup(ENUM_GROUP)
            exitwhen u == null
           
            //cause the caster to damage the unit with lightning damage
            call UnitDamageTarget(GetEventMissile.Caster, u, d.damage, false, true, ATTACK_TYPE_MAGIC, DAMAGE_TYPE_LIGHTNING, null)
           
            call GroupRemoveUnit(ENUM_GROUP, u)
        endloop
       
        //destroy the attached data
        call d.destroy()
        //kill the dummy unit
        call KillUnit(GetEventMissile.Dummy)
       
        //return false so the missile is destroyed
        return false
    endmethod
   
    method onLoop takes nothing returns boolean
        local Data2 d = GetEventMissile.data //store the missile data in a usable variable
       
        set d.z = d.z - d.zfall //reduce the current height variable
        call SetUnitFlyHeight(GetEventMissile.Dummy, d.z, 0.00) //set the unit's height to
                                                                //the appropriate value
       
        return true //return true so the missile keeps moving
    endmethod
endstruct

//Data struct for the original missile
private struct Data1
    real z = 0 //the current height of the missile
    real size = 1.00 //the current size of the missile
endstruct

//The Actions struct for the original missile
private struct Actions1 extends MissileActions
    method onHit takes nothing returns boolean
        local Data1 d = GetEventMissile.data //store the missile data in a usable variable
       
        //calculate the damage for each of the balls
        local real damage= (DAMAGE_PER_STEP / STEP_SIZE) * GetEventMissile.CurrentDist
        //calculate the area over which to spread the balls
        local real area  = (AREA_PER_STEP   / STEP_SIZE) * GetEventMissile.CurrentDist
        //calculate the aoe of the balls
        local real aoe   = (AOE_PER_STEP    / STEP_SIZE) * GetEventMissile.CurrentDist
       
        //the current ball's angle
        local real angle = 0.00
        //the amount to increase the angle by for each ball
        local real step  = 2PI / NUM_BALLS
        //the x/y coordinates of the current ball's target point
        local real x
        local real y
       
        //the current ball's dummy unit
        local unit u
        //the current ball
        local Missile m
        //the current ball's data
        local Data2 d2
       
        loop
            //exit the loop when the angle reaches 360 degrees
            exitwhen angle >= 2PI
           
            //calculate the x/y coordinates of the target point
            set x = GetEventMissile.X + area * Cos(angle)
            set y = GetEventMissile.Y + area * Sin(angle)
           
            //create the dummy unit / set the correct scale and fly height for it
            set u = CreateUnit(OWNER, DUMMY_ID, GetEventMissile.X, GetEventMissile.Y, 0)
            call SetUnitFlyHeight(u, d.z, 0.00)
            call SetUnitScale(u, d.size / NUM_BALLS, 0.00, 0.00)
           
            //create the missile using the newly created dummy unit
            set m = Missile.createFromUnit(u, 0.00, Actions2.create())
            //fire the missile at the target x/y
            call m.fireFixed(GetEventMissile.Caster, x, y, SMALL_SPEED)
            //create the data
            set d2 = Data2.create()
            //store the damage
            set d2.damage = damage
            //store the aoe
            set d2.aoe = aoe
            //store the current height
            set d2.z = d.z
            //store the amount to reduce the height by each onLoop call
            set d2.zfall = (d2.z / (m.StartDist / SMALL_SPEED)) / Missile_FPS
            //store the data on the missile
            set m.data = d2
           
            //increase the angle ready for the next missile
            set angle = angle + step
        endloop
       
        //destroy the attached data
        call d.destroy()
        //kill the dummy unit
        call KillUnit(GetEventMissile.Dummy)
       
        //clean leaks
        set u = null
       
        //return false to destroy the missile
        return false
    endmethod
   
    method onLoop takes nothing returns boolean
        local Data1 d = GetEventMissile.data //store the missile data in a usable variable
       
        //calculate the new size and make the dummy unit that size
        set d.size = 1.00 + (SIZE_PER_STEP   / STEP_SIZE) * GetEventMissile.CurrentDist
        call SetUnitScale(GetEventMissile.Dummy, d.size, 0., 0.)
       
        //calculate the new fly height and set the height of the dummy to that value
        set d.z    =        (HEIGHT_PER_STEP / STEP_SIZE) * GetEventMissile.CurrentDist
        call SetUnitFlyHeight(GetEventMissile.Dummy, d.z, 0.00)
       
        return true
    endmethod
endstruct

private function TrigActions takes nothing returns nothing
    local location target = GetSpellTargetLoc()
    //find the start x/y and target x/y
    local real x0 = GetUnitX(GetTriggerUnit())
    local real y0 = GetUnitY(GetTriggerUnit())
    local real x1 = GetLocationX(target)
    local real y1 = GetLocationY(target)
   
    //create the dummy unit for the missile
    local unit u = CreateUnit(OWNER, DUMMY_ID, x0, y0, 0)
    //create the missile using the dummy unit
    local Missile m = Missile.createFromUnit(u, 0.00, Actions1.create())
    //create and attach a data struct
    set m.data = Data1.create()
    //fire the missile at the target x/y
    call m.fireFixed(GetTriggerUnit(), x1, y1, MISSILE_SPEED)
   
    //clean leaks
    set u = null
    call RemoveLocation(target)
    set target = null
endfunction

//===========================================================================
private function Init takes nothing returns nothing
    local trigger t = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function Conditions ))
    call TriggerAddAction(t, function TrigActions)
   
    set filter = Filter(function TheFilter)
endfunction

endscope

scope ChainDeath initializer Init

globals
    private constant integer SPELL_ID       = 'A003' //the dummy ability id
   
    //the model for the missile
    private constant string MISSILE_ART     = "Abilities\\Spells\\Undead\\DeathCoil\\DeathCoilMissile.mdl"
    //the model for the effects on the target when the missile hits
    private constant string TARGET_ART      = "Abilities\\Spells\\Undead\\DeathCoil\\DeathCoilSpecialArt.mdl"
   
    //the damage the first target recieves
    private constant real DAMAGE            = 300.00
    //the percentage of the previous damage done to the next target
    private constant real DAMAGE_MULTIPLIER = 0.75
    //the percentage of the damage done to heal the caster by
    private constant real PCT_LIFE_STEAL    = 0.25
    //the speed of the missile
    private constant real MISSILE_SPEED     = 750.00
    //the maximum range between units for the spell to chain
    private constant real JUMP_RANGE        = 600.00
   
    //the maximum number of times the spell chains
    private constant integer NUM_JUMPS      = 6
   
    //group used in instant enumerations
    private group ENUM_GROUP                = CreateGroup()
    //filter for the closest unit function
    private boolexpr filter
    //values for the closest unit function
    private real CurX
    private real CurY
    private real CurDist
    private unit CurUnit
endglobals

private function Conditions takes nothing returns boolean
    return GetSpellAbilityId() == SPELL_ID
endfunction

//necessary for the structs to be used above where they are declared
private keyword Data
private keyword Actions

//the filter function
private function TheFilter takes nothing returns boolean
    local real dx
    local real dy
    local real dist
    local Data d = GetEventMissile.data //store the missile data in a usable variable
   
    //check if the unit is a valid target
    if IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(GetEventMissile.Caster)) and not IsUnitType(GetFilterUnit(), UNIT_TYPE_MAGIC_IMMUNE) and not IsUnitInGroup(GetFilterUnit(), d.hit) and GetWidgetLife(GetFilterUnit()) > 0.405 then
        //calculate the distance between the point and the unit
        set dx = GetUnitX(GetFilterUnit()) - CurX
        set dy = GetUnitY(GetFilterUnit()) - CurY
        set dist = SquareRoot(dx * dx + dy * dy)
       
        //calculate the absolute value of the distance
        if dist < 0 then
            set dist = -dist
        endif
       
        //if the distance between this unit and the point is less than the previous distance
        //then update the closest unit
        if dist <= CurDist then
            set CurDist = dist
            set CurUnit = GetFilterUnit()
        endif
    endif
   
    //don't bother adding the unit to the group
    return false
endfunction

//The closest unit function...
private function GetClosestUnit takes nothing returns unit
    set CurDist = JUMP_RANGE //initialise the current distance variable
    set CurUnit = null //initialise the current unit variable
    //loop through the units in range with the filter
    call GroupEnumUnitsInRange(ENUM_GROUP, CurX, CurY, JUMP_RANGE, filter)
    //return the closest unit
    return CurUnit
endfunction

//function to add more modularity to the spell, this bascially makes the missiles
private function MakeDeathMissile takes real x, real y, unit caster, unit target returns Missile
    //create the missile at the specified x/y coordinates
    local Missile m = Missile.create(MISSILE_ART, x, y, 0.00, Actions.create())
    //fire the missile at the target
    call m.fireTarget(caster, target, MISSILE_SPEED)
    //return the new missile
    return m
endfunction

//Data struct for the missile
private struct Data
    real damage = DAMAGE //the amount of damage the missile will do when it hits
    integer num = 0 //the number of jumps already made
    group hit = CreateGroup() //the units already jumped to
endstruct

private struct Actions extends MissileActions
    method onHit takes nothing returns boolean
        local Data d = GetEventMissile.data //store the missile data in a usable variable
        //the new target unit of the missile
        local unit target
        //the new missile
        local Missile m
        //the life of the caster before adding the health absorbed
        local real life = GetUnitState(GetEventMissile.Caster, UNIT_STATE_LIFE)
       
        //the x/y coordinates of where the missile is
        set CurX = GetEventMissile.X
        set CurY = GetEventMissile.Y
       
        //create a special effect using the TARGET_ART model on the hit unit
        call DestroyEffect(AddSpecialEffectTarget(TARGET_ART, GetEventMissile.Target, "origin"))
        //damage the hit unit
        call UnitDamageTarget(GetEventMissile.Caster, GetEventMissile.Target, d.damage, false, true, ATTACK_TYPE_MAGIC, DAMAGE_TYPE_UNIVERSAL, null)
        //increase the caster's health by a percentage of the damage dealt
        call SetUnitState(GetEventMissile.Caster, UNIT_STATE_LIFE, life + d.damage * PCT_LIFE_STEAL)
       
        //if the missile has jumped the maximum number of times, stop the spell
        if d.num >= NUM_JUMPS then
            //clean the group leak
            call GroupClear(d.hit)
            call DestroyGroup(d.hit)
            //destroy the data
            call d.destroy()
            //return false to destroy the missile
            return false
        endif
       
        //add the hit unit to the group of units already hit
        call GroupAddUnit(d.hit, GetEventMissile.Target)
       
        //acquire a new target
        set target = GetClosestUnit()
       
        //if there is no valid unit within the range, stop the spell
        if target == null then
            //clean the group leak
            call GroupClear(d.hit)
            call DestroyGroup(d.hit)
            //destroy the data
            call d.destroy()
            //return false to destroy the missile
            return false
        endif
       
        //make the new missile and fire it at the new target
        set m = MakeDeathMissile(CurX, CurY, GetEventMissile.Caster, target)
        //calculate the damage for the next missile
        set d.damage = d.damage * DAMAGE_MULTIPLIER
        //increment the num variable
        set d.num = d.num + 1
        //store the data in the new missile
        set m.data = d
       
        //return false to destroy the missile
        return false
    endmethod
endstruct

private function TrigActions takes nothing returns nothing
    //the x/y coordinates of the starting point of the missile
    local real x = GetUnitX(GetTriggerUnit())
    local real y = GetUnitY(GetTriggerUnit())
    //create the missile and fire it at the spell target unit
    local Missile m = MakeDeathMissile(x, y, GetTriggerUnit(), GetSpellTargetUnit())
    //create the data and store it on the missile
    set m.data = Data.create()
endfunction

//===========================================================================
private function Init takes nothing returns nothing
    //create the trigger, register events, actions and conditions
    local trigger t = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function Conditions ))
    call TriggerAddAction(t, function TrigActions)
   
    //preload the effects
    call Preload(MISSILE_ART)
    call Preload(TARGET_ART)
   
    //initialise the filter
    set filter = Filter(function TheFilter)
endfunction