Zephyr Contest #12 - Combo

[Kazeon]

Let's use GMT time.

 

[Tank-Commander]

Well, we can't start until the contest is approved, which hasn't happened in time for today: Guess we'll need to Pm mods to start it since Flad isn't? (user page says "not currently moderating"

 

[Kazeon]

@sentrywiz:
meh, I'm sorry I missed your post.

What exactly is spell documentation? Trigger comments? Text file? The description box above every trigger? Explaining each variable, loop and spell logic?

Documentation includes:
- Read me: could be written in a separated trigger. Includes: Short description about your spell, importing instructions, needed libraries/dependencies, credits, etc.
- Explanation above every configuration variables
- Some outlines inside your code. For easier reviewing.

Or I can design 4 spells that will be used by 4 different units?

For single unit only.

What kind of map are the spells for? Because 4 spells for let's say: Melee map aren't fitting for a tower defense map.

You want to make ability for tower defense, eh? But for melee or AoS, it's up to you, doesn't affect your score.

Do I also have to make the map? Or just add random enemy units getting killed/damaged/healed/what not?

No, just a simple demo map with any elements needed for testing (vary terrains, units, heroes, destructables, etc.)

@TC:
I have requested to Ralle

 

[Kyrbi0]

I think you misunderstood. What we meant here was not synergization between two or more abilities, but:

Design a spellpack (ability set) consists of 3 spells (abilities),
which can have multiple effects based on their cast order.

Hum... That's very different. I suppose the closest comparison would be the Invoker from DotA, then? (Quas, Wex, Exort - cast in certain order does certain things)...

I'm not sure I can do that, in that case. Hrm.

3 isn't the easiest to do on a hero (consider that the only ability which wouldn't be part of the set would likely the ultimate, it's a bit awkward) though is 3 being used as a limit or an "at least" here?

...

...

Edit2: Also what is that "awesomness" criteria doing there for? that's entirely subjective and has no place in a competitive environment

Not sure. These don't necessarily have to be for a Hero, though; like you yourself said, a spell can be retrofitted for a variety of settings (game types, caster types, etc), so it's more like "designing" in the most abstract sense.

I'd rather link you to some of my earlier writings rather than fill the pages here... But basically, it's there for several, purposeful reasons. For one, it's a nod to the fact that no matter what, we cannot fully stamp out "subjectivity" in our Judging; so whereas the other Criteria focus on objectivity, there is one category of Criteria where the Judge/Voter can insert their personal thoughts, give an overall/total/general "feel" for an entry. For two, it's only 5 points; nothing major. For three, exactly how "competitive" do you feel this is (honest question, not entirely joking)? I mean, it's a simple Contest to make (a) spell(s); are you here for the fun of challenging friends to a test of skill, or the thrill of competition and of victory?

 

[Tank-Commander]

Hum... That's very different. I suppose the closest comparison would be the Invoker from DotA, then? (Quas, Wex, Exort - cast in certain order does certain things)...

I'm not sure I can do that, in that case. Hrm.

Review the updated main post (You'll see it's been expanded to include other forms as well)

I'd rather link you to some of my earlier writings rather than fill the pages here... But basically, it's there for several, purposeful reasons. For one, it's a nod to the fact that no matter what, we cannot fully stamp out "subjectivity" in our Judging; so whereas the other Criteria focus on objectivity, there is one category of Criteria where the Judge/Voter can insert their personal thoughts, give an overall/total/general "feel" for an entry.

Isn't that however, intentionally perverting the objectivity we /do/ have by increasing the sway subjectivity holds on the results

For two, it's only 5 points; nothing major.

I'd suggest you look at how close the marks have been for the last few contests between 1st-2nd, 2nd-3rd & 3rd-4th, 5 points is absolutely enough to have a large effect imo.

For three, exactly how "competitive" do you feel this is (honest question, not entirely joking)? I mean, it's a simple Contest to make (a) spell(s); are you here for the fun of challenging friends to a test of skill, or the thrill of competition and of victory?

I do it for testing my own skill and as you put it "the thrill of competition", eitherway I treat it as you'd expect any competitive scene to be treated - with criteria designed to limit subjectivity, not intentionally cater for it. Naturally you can never entirely be rid of subjectivity, which is why having many judges is heavily preferred as this further limits it, but having criteria designed to be subjective is outright rediculous in my opinion. (Also the criteria has been removed in the revised Original Post)

 

[fladdermasken]

I'm away on leave to get some shit together. Anyways, everything here looks okay.

Approved.

 

[Kazeon]

Thnks mr. flad

Okay, starting date has updated. Check it out! Your time is 45 days. Use it wisely! Good luck and have fun ^^

 

[Cokemonkey11]

My two days of availability are well past their prime we'll see what happens...

 

[Almia]

Seriously? a combo? and no one is notifying me?


Count me in.


[edit]
Seeing how "Combo" works, this should have been an HC.

[edit]
May I ask, is it allowed to create 3 spells even if only 1 of them is the base and the other 2 requires the base?

 

[Kazeon]

May I ask, is it allowed to create 3 spells even if only 1 of them is the base and the other 2 requires the base?

Sure

 

[Almia]

Sure

Nevermind
I already have made an idea of a 2 passive combo.

 

[Tank-Commander]

Tch! trust it to start over the time that I'm out, eitherway here is my entry description:

lots of text

Divine Envoy Combo Spellset

I'm going to be entering with another installment of my "Envoy" theme, though this one is significantly different from all my other ones, so it'll be interesting to do.

Description/Explanation of idea:
I'm attempting to create a skillset in which every decision when using affects the outcome of the ability and all orders of usage are viable both practically and tactically (to the measure in that if it were in say an AOS-type map how the player was using each ability would give some indication of their intentions, such as trying to set up their ultimate, or trying to lure opponents into a false sense of security for a quick turn-around) I recommend reading the full description (yes it's rather lengthy but it's necessary if somebody is to appreciate how I've constructed this idea for this to be the case)

Abilities:
- Orbs of Creation
- Orbs of Destruction
- Orbs of Justice
- Pillar of Judgement

Each ability (aside from the ultimate) creates Orbs which remain on the battlefield for a short time (each having one of the primary colours, Green for Creation, Red for Destruction and Blue for Justice), each orb has a passive effect on the nearby area (they continue during the ultimate, and Orbs of Creation and Destruction have their effect stack for each orb). If these orbs collide (come within melee range of eachother) they create additional effects originating in the middle of the remaining gap between them:
- Orb of Creation + Orb of Destruction = Cycle of Life
- Orb of Creation + Orb of Justice = Equaliser
- Orb of Destruction + Orb of Justice = Trial by Fire

Pillar of Judgement (Designed to be used as an ultimate but can be a levelled ability) creates a pillar surrounded by 3 stacks (one for each type of orb) starting with 3 orbs (15 power level in each type) on each stack the pillar pulls in surrounding enemies as well as orbs, adding the orbs to the stack (one visual orb is added to the stack for every 5 units of power added to the pillar, orbs cannot cause combination effects while being pulled) after a time, the stacks stop rotating and a light shines on the tallest stack (if all stacks are of equal height then the light is larger and shines on the entire pillar) and then the following effects occur:
- Creation has the heighest stack: Wild Growth
- Destruction has the heighest stack: Armageddon
- Judgement has the heighest stack: Countdown
- All Pillars are equal: Divine Envoy

Total ability count: 11

Effects of the abilities:
Note - all orbs have a power level (based on the level of the ability) the strength of combination abilities is done by adding up the power level of involved orbs, this is also how the ultimate calculates its effects by using the total amount of the power level in each type of orb on the pillar

Basic Abilities:
- Orbs of Creation: Launches orbs into the target area in a circle, healing nearby friendly units in a small aoe on impact and leaves Orbs of Creation which continue to passively heal nearby friendly units over time.

- Orbs of Destruction: Launches a large Orb into the target area, exploding on impact dealing damage to nearby enemy units and creates Orbs of Destruction which are deflected back up into the air, landing around the impact site randomly dealing additional damage and passively burning nearby enemy units over time.

- Orbs of Justice: Sends out a cone of Orbs of Justice toward the target point which deals health and mana damage (with manaburn effect) to enemy units caught within and leaves the orbs when they reach their destination, passively slowing nearby enemy units.

Combo spells:
- Cycle of Life: Damage is dealt to nearby enemy units from the combination point, a percentage of the total damage dealt is then restored to allied units within the same area
Power Level Effect: increases the AOE, amount of damage dealt, and the percentage healed

- Equaliser: All units in the nearby area have their mana drained (both friendly and unfriendly units) they then have their total amount of hitpoints added up, and then divided by the amount of units involved - all units now get that amount of health
Power Level Effect: Increases AOE

- Trial by Fire: All enemy units in the nearby area are set on fire taking damage over time, if the unit dies while on fire, additional damage is dealt to all nearby enemy units
Power Level Effect: Increases AOE and Damage Dealt

Ultimate:
- Wild Growth: A ring of green quickly spreads from around the pillar, creating treants with timed lives as the circle spreads.
- Effect of Orbs of Creation: Increases the amount of treants spawned
- Effect of Orbs of Destruction: Increases the total AOE of the ring spreading
- Effect of Orbs of Justice: Increases the duration of the timed lives

- Armageddon: The pillar rains flaming judgement onto the surrounding area in an even spread dealing large amounts of damage in the surrounding area.
- Effect of Orbs of Creation: Increases the AOE of each projectile
- Effect of Orbs of Destruction: Increases the amount of Projectiles launched by the pillar (attempts to entirely cover the area)
- Effects of Orbs of Justice: Increases the amount of damage each projectile deals

- Countdown: Every unit within the area gains a buff, after a while the buff is removed and either heals the unit or damages it depending on if it is friendly or enemy.
- Effect of Orbs of Creation: Decreases the Timer until the effect goes off
- Effect of Orbs of Destruction: Increases the Damage/Healing dealt by the ability
- Effect of Orbs of Justice: Increases the AOE of the ability

- Divine Envoy: By achieving balance the pillar elevates above the ground, with each stack spreading out before striking beams of light into the surrounding area which heal allies and damage enemies, upon ending the centre of the pillar fires a large purifying beam of light into the ground, dealing massive damage and knocking enemy units far back around the cast area (3D knockback the closer to the centre, the more they're knocked back, corpses are also affected by this knockback, units take bonus damage based on their velocity upon hitting the ground)
- Effect of Orbs of Creation: Increases the amount of Beams at any given time the frequency of them, and the AOE of the final beam
- Effect of Orbs of Destruction: Increases the Damage/Healing of each of the beams, their AOE and the damage of the final beam
- Effect of Orbs of Justice: Increases the AOE, Duration of the ability and the strength of the knockback of the final beam

Tricks and tactics:

Combo Abilities:
- Orbs of Judgement are by far easiest to set up combination attacks due to their sweeping nature, Orbs of Creation are second easiest, and Orbs of Destruction are hardest, it's recommended to use the abilities in the order of easiest to set up for the combination effects (i.e. always use Orbs of Destruction first if it is in the combination) Additionally, the slowing effect of Orbs of Judgement are helpful for keeping enemies within the target AOE for Equaliser and Trial by fire.
- Equaliser is hugely effective against low amounts of enemies with high HP when you are using large amounts of low HP units as it will heal them and take a higher chunk of the enemies health away, the more they have.
- Trial by Fire is hugely effective against high amounts of enemies with low HP as they are more likely to die when on fire and cause a chain reaction killing all enemies affected by it.
- Setting up an Equaliser to be quickly followed up by a Cycle of life can quickly turn around a situation - when losing a battle equaliser will heal your units putting you on an even plain and Cycle of life will push you ahead, be careful not to get this the wrong way around though as you may remove your advantage.
- When low on Mana focussing usage on Cycle of Life is more effecient as Orbs of Judgement are less effective for damaging purposes and are more situational

Ultimate:
- When using the ultimate always consider what effect you want/need in the situation as well as how many orbs of each type you will have available and their respective power levels, getting it wrong can result in a waste of the ultimate
- Using Orbs of Judgement on enemy units while the Ultimate is pulling them in is helpful as it makes it more difficult for them to escape the AOE
- Countdown is helpful in and out of combat as in pressing situations it is more difficult/risky to stay within the radius for the healing effect
- During Countdown, using Orbs of Judgement to slow enemies helps you keep them within the radius to take the damag. (as opposed to before, as the pillar will potentially have pulled those orbs in and only effect those closest to the pillar) By the same merit, it is also helpful for setting up Wild Growth and Armaggedon depending on the type of usage of them you are attempting to achieve
- Consider the desired AOE when using Wild Growth, a small AOE gives a very high concentration of Treants which can be very helpful at the immediate area, and a high AOE puts them over a much wider area, more useful for surrounding and body blocking bigger groups of enemies
- Armageddon's effectiveness depends largely on the size of the enemy army - a large army scattered across the area will take more damage from a higher AOE, lower Damage Armageddon while a small army, close to the ultimate takes much more damage from a High damage, low AOE armageddon as the AOE effects how far the projectiles spread out and thus their damage distribution.
- Divine Envoy is by far the strongest form of the ultimate with higher reward for each unit of power placed into it, but requires a large amount of mana generally to use it effectively and can cause accidental combos when trying to set up which can result in the player failing to set it up correctly and getting one of the other effects.
- If you're trying to set up the ultimate, you should avoid creating combination abilities - attempt to keep things efficient but the order of casting should be reversed, with Orbs of judgement being cast first in order to minimise combos. It is also suggested to potentially waste an ability just to put more orbs on the battlefield before using the ultimate
- Launching abilities directly into the centre of the ultimate can quickly add the orbs to the stacks, this is particularly helpful when there is not much time left for gathering with the ultimate.

Note: things are subject to change but they shouldn't be too far from this

Edit (7:58pm): Early-days estimation of configurables ~200 (currently at 100 as time of this edit)
Edit2(10:10pm): I've completed 2/11 abilities, currently the code is about 800 lines (few other places are still wip, mostly configuration making up that many lines)

 

[Almia]

There goes Tank with the 4-ability combo. I should entet mine as well :

Hidden

The Eternal Suffering Spell set
Fitting for : AoS
Type:2-passive combo
First Ability:
Souls of Agony
Everytime you kill an enemy,the enemy drops it's soul which lasts for 10 seconds or until consumed if you go within a soul. Once consumed,the soul will be enslaved,granting bonus hp regeneration and empowers your next Painful Strike. There's a limited number of souls to be consumed.

Second Ability:
Every 1.5 Seconds,the next basic attack will deal damage plus a bonus damage equal to the number of souls you have consumed with Souls of Agony. Once the attack landed,the souls will be released, striking the enemy causing the enemy to have refuced hp regeneration. A portion of souls released will be thrown between you and the affected unit.


My hero's combo is best used in a 1v1 situation,due to its massive single unit damage plus thr movement combo which you will use consume souls while on battle.

 

[GywGod133]

:v yeah

 

[Kazeon]

Meh, here's mine

Hidden

Consists of 2 abilities:

The first one will absorb all target units in front of caster to his position. After reached certain distance, the victims will get stuck and take damage over times.

The second one is simply fires a missile towards caster's facing angle :v

The basic idea is two or more abilities that can be channeled in an exactly same time.

 

[Almia]

Meh, here's mine

Hidden

Consists of 2 abilities:

The first one will absorb all target units in front of caster to his position. After reached certain distance, the victims will get stuck and take damage over times.

The second one is simply fires a missile towards caster's facing angle :v

The basic idea is two or more abilities that can be channeled in an exactly same time.

I don't get how both abilities work. Does the first ability is like "Dragging" all the units in front?

 

[Kazeon]

So, the unit can cast two abilities in the same time.

The first one will drag enemies to certain location, collecting them all in one place, ready to be toasted using the second spell

Unit can cast the second ability without interrupting the first ability (channeling).

 

[Shoto]

Is it too late to join? What do I need to know to participate, except what is in the original post in this thread? (I haven't taken part in any contest before, but I have an idea for this)

 

[Kazeon]

No, this has just been started. You just need to share your progresses here.

 

[Chaosy]

And I am just sitting here without a clue x)

 

[Tank-Commander]

Progress report: 3/11 abilities completed
Currently: 1150 Lines of code
The first WIP screenshots are to come soon

Edit: First one (Orbs of Creation)
Edit2: Revised the effect when the projectiles are moving
Edit3: Passive healing of units next to the orbs and Strong Heal when first landing
Edit4: Second One (Orbs of Justice)
Edit5: Damaging units they pass through (with manaburn and slow)
Progress is now 4/11 complete
Edit6: Third One (Orbs of Destruction)

Current lines of Code: 1530
Progress is now 5/11 complete

 

[Kazeon]

Progress report: 3/11 abilities completed
Currently: 1150 Lines of code
The first WIP screenshots are to come soon

Edit: First one (Orbs of Creation)
Edit2: Revised the effect when the projectiles are moving
Edit3: Passive healing of units next to the orbs and Strong Heal when first landing
Edit4: Second One (Orbs of Justice)
Edit5: Damaging units they pass through (with manaburn and slow)
Progress is now 4/11 complete
Edit6: Third One (Orbs of Destruction)

Current lines of Code: 1530
Progress is now 5/11 complete

That was cool, man. As always.

 

[Almia]

And there goes again for Tank,the guy who loves eyegasms

 

[Tank-Commander]

And there goes again for Tank,the guy who loves eyegasms

Well, why make something that can look good, not look as good as it can? Visuals are very important in game design, so I consider it important in spell design too. It's not like I'm dicarding anything in exchange for better looks.

Eitherway, looking forward to seeing some good WIPs from you guys!

Edit: Second batch of WIPs, Combo abilities this time (difficult to time those screenshots, I'll need gifs of these in the end)
WIP8: Equaliser
WIP9: Trial by Fire
WIP10: Cycle of Life
(All of them are fully functional)

Current Progress:
Lines of code 1813
Configurables (so far): 209
6/11 Abilities complete
Changes: Recycling is complete, Comboing is fully functional, Made the orbs smaller (felt they took up too much screen space), various balance and visual tweaks (which will continue probably up until the deadline), Finished Trial by Fire

Next Up: Starting work on the ultimate

 

[Kingz]

Guess i will have to pack a ton of SFX if i am to compete, since most of people just wanna look at nice flashy things.

*sigh*

I will probably join, will have some time off in february.

 

[Kazeon]

Nice visual doesn't mean bloated special effects. Overloading your spell with effects will decrease your points.

 

[Tank-Commander]

I've reduced all of mycombo special effects sizes (quite a few times actually before I'm happy with them, they're much less screen-flooding now (even when there's quite a few of them going off))

Eitherway, first WIP for the ultimate ability 1 (the pulling in of Orbs and enemy units) Looks better ingame though
Edit: Next WIP, added spinning
Edit2: I've got the stacks functioning (dragging units generally too) Altered the size of the orbs when absorbed into miniorbs (this is so stacking is clearer and doesn't go off the top) WIP of the before and after shots
Edit3: Finally can say I have 7/11 abilities completed
Current lines of code: 2394
Current Configurables: 257
Next up: Ultimate -> Armageddon

 

[Empirean]

i wanna join.

 

[Almia]

And im just sitting here waiting for the queue of my brother.

Anyways,I am still thinking of creating Spheres without using Hashtables

 

[Tank-Commander]

Completed the ultimate armageddon effect, WIPs of a short range one (low Creation Orbs) and Medium range one (Medium Creation Orbs) both have Medium Destruction and Justice Orbs.
Current Progress: 8/11 Abilities completed
Edit: Completed the ultimate Wild Growth effect,Wip shows one with high treant count and medium range and short duration
(also note that I haven't yet scripted the slow of blue orbs to only affect enemy units, hence the purple)
Current Progress: 9/11 Abilities completed
Lines of Code: 2719

 

[Shoto]

That is a lot of clutter. Tell me, does your framerate tank when casting the ability? Because from the screenshots it looks like it should.

Also, I want to enter. I'll put up WIP posts when I've actually started working on my submission, which will probably be sometime during the weekend.

 

[Tank-Commander]

Framerate remains unaffected at all stages, unless your computer is what would fall under the category of "wooden" in performance, I've been doing this for quite a while: I know how to limit framerate loss when it comes to large effects

 

[Kingz]

Nice visual doesn't mean bloated special effects. Overloading your spell with effects will decrease your points.

Maybe for judges, however it is what wins public polls.
Which brings me to the next point, the poll:judges ratio isn't stated anywhere.

 

[Tank-Commander]

At this rate I'll be done before somebody posts a WIP
Current Progress: 10(2/3)/11 (Nearly done, but I'm stopping for today)
Lines of Code: 3217
Configurables: 347
Up Next -> Ultimate Divine Envoy Stage 3

WIP screenshots are of Countdown and Divine Envoy, (haven't finished the last stage of divine envoy yet) Countdown is a bit hard to get a good screenshot for, since it's a buff and then a heal/damage effect when it times out, Divine envoy also a bit hard, because lightning effects but there you go.

Also kingz raises a fair point on the judgesoll ratio

 

[Kazeon]

Which brings me to the next point, the poll:judges ratio isn't stated anywhere.

Added ^^ Thanks for reminding.

At this rate I'll be done before somebody posts a WIP

I haven't made any progress since the last 3 days.

 

[Almia]

At this rate I'll be done before somebody posts a WIP
Current Progress: 10(2/3)/11 (Nearly done, but I'm stopping for today)
Lines of Code: 3217
Configurables: 347
Up Next -> Ultimate Divine Envoy Stage 3

WIP screenshots are of Countdown and Divine Envoy, (haven't finished the last stage of divine envoy yet) Countdown is a bit hard to get a good screenshot for, since it's a buff and then a heal/damage effect when it times out, Divine envoy also a bit hard, because lightning effects but there you go.

Also kingz raises a fair point on the judgesoll ratio

Should I post my WIP? XD

 

[Tank-Commander]

I am pleased to announce that I have completed* my entry code and all 11 abilities are functioning as intended so my next post will be my entry post once I've added documentaiton, gotten my gifs together, done tooltips and the like. I'd say I was basically done if it wasn't going to be a mountain task to document it all.

So here is my next (and last) WIP post, a code listing one so you guys can get the idea of my code (The configuration isn't at all arranged properly yet as it was constructed on-the-fly, I will be rearranging it completely):
Lines of Code (Minimal Documentation): 3598
Configurables (Should be the final amount): 385
Documentation Level so far: Don't even try to understand the code

Warning: Big

////////////////////////////////////////////////////////////////////
//                   DIVINE ENVOY SPELLSET V1.00                  //                                                                //
//  Author: Tank-Commander                                        //
//  Requires: Dummy.mdl                                           //
//  Purpose: Combo Spell Set                                      //
//                                                                //
//  Notes:                                                        //
//    -  Read the readme before you try modifying the config      //
//    -  Use the "Helpful files" to help you import the spell     //
//                                                                //
//  Credits:                                                      //
//    -  (Dummy.mdl) Vexorian                                     //
//    -  (Orb Models) Frankster                                   //
//                                                                //
//                                                                //
//  If you have used this spellset 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.                                    //
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
constant function DES_DummyID takes nothing returns integer
    return 'u000'
endfunction

constant function DES_TreantID takes nothing returns integer
    return 'efon'
endfunction

constant function DES_TreeCheckerID takes nothing returns integer
    return 'u001'
endfunction

constant function DES_CreationID takes nothing returns integer
    return 'A000'
endfunction

constant function DES_DestructionID takes nothing returns integer
    return 'A001'
endfunction

constant function DES_JusticeID takes nothing returns integer
    return 'A002'
endfunction

constant function DES_PillarID takes nothing returns integer
    return 'A003'
endfunction

constant function DES_SlowID takes nothing returns integer
    return 'A004'
endfunction

constant function DES_CountdownID takes nothing returns integer
    return 'A005'
endfunction

constant function DES_BurnID takes nothing returns integer
    return 'A006'
endfunction

constant function DES_TimedLifeID takes nothing returns integer
    return 'BEfn'
endfunction

constant function DES_LightningID takes nothing returns string
    return "CLPB"
endfunction

constant function DES_TimerSpeed takes nothing returns real
    return 0.031250000
endfunction

constant function DES_COrbEffect takes nothing returns string
    return "war3mapImported\\OrbPoisonX.mdx"
endfunction

constant function DES_LightningRed takes nothing returns real
    return 1.00
endfunction

constant function DES_LightningGreen takes nothing returns real
    return 1.00
endfunction

constant function DES_LightningBlue takes nothing returns real
    return 1.00
endfunction

constant function DES_LightningAlpha takes nothing returns real
    return 1.00
endfunction

constant function DES_DOrbEffect takes nothing returns string
    return "war3mapImported\\OrbFireX.mdx"
endfunction

constant function DES_JOrbEffect takes nothing returns string
    return "war3mapImported\\OrbDragonX.mdx"
endfunction

constant function DES_POrbEffect takes nothing returns string
    return "Abilities\\Weapons\\WitchDoctorMissile\\WitchDoctorMissile.mdl"
endfunction

constant function DES_SlowEffect takes nothing returns string
    return "Abilities\\Weapons\\ZigguratFrostMissile\\ZigguratFrostMissile.mdl"
endfunction

constant function DES_PBoarderEffect takes nothing returns string
    return "Abilities\\Spells\\NightElf\\SpiritOfVengeance\\SpiritOfVengeanceOrbs1.mdl"
endfunction

constant function DES_PSpawnEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\Resurrect\\ResurrectTarget.mdl"
endfunction

constant function DES_PPullEffect takes nothing returns string
    return "Objects\\Spawnmodels\\Undead\\ImpaleTargetDust\\ImpaleTargetDust.mdl"
endfunction

constant function DES_PAbsorbEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\Resurrect\\ResurrectTarget.mdl"
endfunction

constant function DES_PWildSpawnEffect takes nothing returns string
    return "Objects\\Spawnmodels\\NightElf\\EntBirthTarget\\EntBirthTarget.mdl"
endfunction

constant function DES_PArmaProjectileEffect takes nothing returns string
    return "Abilities\\Weapons\\FireBallMissile\\FireBallMissile.mdl"
endfunction

constant function DES_PCountEffect takes nothing returns string
    return "Abilities\\Spells\\Undead\\FrostArmor\\FrostArmorTarget.mdl"
endfunction

constant function DES_PCountDamageEffect takes nothing returns string
    return "Objects\\Spawnmodels\\Undead\\UndeadDissipate\\UndeadDissipate.mdl"
endfunction

constant function DES_PCountHealEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\HolyBolt\\HolyBoltSpecialArt.mdl"
endfunction

constant function DES_CDeathEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
endfunction

constant function DES_DDeathEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
endfunction

constant function DES_JDeathEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
endfunction

constant function DES_PDeathEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
endfunction

constant function DES_CImpactEffect takes nothing returns string
    return "Objects\\Spawnmodels\\NightElf\\NEDeathSmall\\NEDeathSmall.mdl"
endfunction

constant function DES_DImpactEffect takes nothing returns string
    return "Objects\\Spawnmodels\\Other\\NeutralBuildingExplosion\\NeutralBuildingExplosion.mdl"
endfunction

constant function DES_CMoveEffect takes nothing returns string
    return "Abilities\\Weapons\\IllidanMissile\\IllidanMissile.mdl"
endfunction

constant function DES_DMoveEffect takes nothing returns string
    return "Abilities\\Weapons\\PhoenixMissile\\Phoenix_Missile_mini.mdl"
endfunction

constant function DES_JMoveEffect takes nothing returns string
    return "Abilities\\Weapons\\ZigguratMissile\\ZigguratMissile.mdl"
endfunction

constant function DES_PArmaProjectileMoveEffect takes nothing returns string
    return "Abilities\\Weapons\\PhoenixMissile\\Phoenix_Missile_mini.mdl"
endfunction

constant function DES_CHealEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\ResourceItems\\ResourceEffectTarget.mdl"
endfunction

constant function DES_CImpactHealEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\HolyBolt\\HolyBoltSpecialArt.mdl"
endfunction

constant function DES_DDamageEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\AIfb\\AIfbSpecialArt.mdl"
endfunction

constant function DES_DImpactDamageEffect takes nothing returns string
    return "Abilities\\Weapons\\DemolisherFireMissile\\DemolisherFireMissile.mdl"
endfunction

constant function DES_JDamageEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\AIil\\AIilTarget.mdl"
endfunction

constant function DES_PArmaImpactEffect takes nothing returns string
    return "war3mapImported\\dummy.mdl"
endfunction

constant function DES_PDivineStormDamageEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\Feedback\\ArcaneTowerAttack.mdl"
endfunction

constant function DES_PDivineStormHealEffect takes nothing returns string
    return "Abilities\\Spells\\Undead\\ReplenishMana\\SpiritTouchTarget.mdl"
endfunction

constant function DES_PDivineStormStrikeEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Charm\\CharmTarget.mdl"
endfunction

constant function DES_PDivineLaserEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Awaken\\Awaken.mdl"
endfunction

constant function DES_PDivineLaserDamageEffect takes nothing returns string
    return "war3mapImported\\dummy.mdl"
endfunction

constant function DES_PDivineLaserHealEffect takes nothing returns string
    return "war3mapImported\\dummy.mdl"
endfunction

constant function DES_KnockbackEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Tornado\\Tornado_Target.mdl"
endfunction

constant function DES_CycleBoarderEffect takes nothing returns string
    return "Units\\NightElf\\Wisp\\WispExplode.mdl"
endfunction

constant function DES_EqualBoarderEffect takes nothing returns string
    return "Abilities\\Spells\\Items\\AIre\\AIreTarget.mdl"
endfunction

constant function DES_TrialBoarderEffect takes nothing returns string
    return "Abilities\\Weapons\\PhoenixMissile\\Phoenix_Missile.mdl"
endfunction

constant function DES_CycleDamageEffect takes nothing returns string
    return "Abilities\\Spells\\Undead\\DeathCoil\\DeathCoilSpecialArt.mdl"
endfunction

constant function DES_CycleHealEffect takes nothing returns string
    return "Abilities\\Spells\\Orc\\HealingWave\\HealingWaveTarget.mdl"
endfunction

constant function DES_EqualAlterEffect takes nothing returns string
    return "Abilities\\Spells\\Human\\Invisibility\\InvisibilityTarget.mdl"
endfunction

constant function DES_TrialDamageEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Incinerate\\IncinerateBuff.mdl"
endfunction

constant function DES_PArmaDamageEffect takes nothing returns string
    return "war3mapImported\\dummy.mdl"
endfunction

constant function DES_TrialBurnEffect takes nothing returns string
    return "Environment\\LargeBuildingFire\\LargeBuildingFire2.mdl"
endfunction

constant function DES_TrialExplodeEffect takes nothing returns string
    return "Abilities\\Spells\\Orc\\FeralSpirit\\feralspiritdone.mdl"
endfunction

constant function DES_CycleActivateEffect takes nothing returns string
    return "Objects\\Spawnmodels\\NightElf\\EntBirthTarget\\EntBirthTarget.mdl"
endfunction

constant function DES_EqualActivateEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Charm\\CharmTarget.mdl"
endfunction

constant function DES_TrialActivateEffect takes nothing returns string
    return "Abilities\\Spells\\Other\\Incinerate\\FireLordDeathExplode.mdl"
endfunction

constant function DES_COrbScaleBase takes nothing returns real
    return 0.40
endfunction

constant function DES_DOrbScaleBase takes nothing returns real
    return 0.40
endfunction

constant function DES_JOrbScaleBase takes nothing returns real
    return 0.40
endfunction

constant function DES_POrbScaleBase takes nothing returns real
    return 3.00
endfunction

constant function DES_PBoarderScaleBase takes nothing returns real
    return 7.00
endfunction

constant function DES_PArmaProjectileScale takes nothing returns real
    return 1.50
endfunction

constant function DES_CImpactScaleBase takes nothing returns real
    return 0.20
endfunction

constant function DES_DImpactScaleBase takes nothing returns real
    return 0.40
endfunction

constant function DES_JImpactScaleBase takes nothing returns real
    return 1.00
endfunction

constant function DES_CycleBoarderScaleBase takes nothing returns real
    return 0.05
endfunction

constant function DES_EqualBoarderScaleBase takes nothing returns real
    return 0.20
endfunction

constant function DES_TrialBoarderScaleBase takes nothing returns real
    return 0.10
endfunction

constant function DES_CycleActivateScaleBase takes nothing returns real
    return 0.30
endfunction

constant function DES_EqualActivateScaleBase takes nothing returns real
    return 0.50
endfunction

constant function DES_TrialActivateScaleBase takes nothing returns real
    return 0.20
endfunction

constant function DES_COrbScalePerPowerLevel takes nothing returns real
    return 0.20
endfunction

constant function DES_DOrbScalePerPowerLevel takes nothing returns real
    return 0.20
endfunction

constant function DES_JOrbScalePerPowerLevel takes nothing returns real
    return 0.20
endfunction

constant function DES_POrbScalePerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_PBoarderScalePerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_CImpactScalePerPowerLevel takes nothing returns real
    return 0.20
endfunction

constant function DES_DImpactScalePerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_JImpactScalePerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_CycleBoarderScalePerPowerLevel takes nothing returns real
    return 0.015
endfunction

constant function DES_EqualBoarderScalePerPowerLevel takes nothing returns real
    return 0.015
endfunction

constant function DES_TrialBoarderScalePerPowerLevel takes nothing returns real
    return 0.015
endfunction

constant function DES_CycleActivateScalePerPowerLevel takes nothing returns real
    return 0.1
endfunction

constant function DES_EqualActivateScalePerPowerLevel takes nothing returns real
    return 0.0075
endfunction

constant function DES_TrialActivateScalePerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_PDivineStormStrikeScaleBase takes nothing returns real
    return 0.30
endfunction

constant function DES_PDivineStormStrikeScalePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserStartScaleBase takes nothing returns real
    return 0.01
endfunction

constant function DES_PDivineLaserStartScalePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserEndScaleBase takes nothing returns real
    return 4.00
endfunction

constant function DES_PDivineLaserEndScalePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PSmallOrbOffsetBase takes nothing returns real
    return 150.00
endfunction

constant function DES_PSmallOrbsHeightOffsetBase takes nothing returns real
    return 50.00
endfunction

constant function DES_PSmallOrbOffsetPerLevel takes nothing returns real
    return 50.00
endfunction

constant function DES_PDivineSmallOrbsOffsetIncreaseBase takes nothing returns real
    return 90.00
endfunction

constant function DES_PDivineSmallOrbsOffsetIncreasePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PSmallOrbsHeightOffsetPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_POrbHeightOffsetBase takes nothing returns real
    return 200.00
endfunction

constant function DES_POrbHeightOffsetPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineHeightIncreaseBase takes nothing returns real
    return 300.00
endfunction

constant function DES_PDivineHeightIncreasePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PSmallOrbAngleOffset takes nothing returns real
    return 120.
endfunction

constant function DES_PBoarderHeightOffsetAlter takes nothing returns real
    return -50.
endfunction

constant function DES_PBoarderOffsetBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PBoarderOffsetPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CPowerLevelBase takes nothing returns real
    return 1.50
endfunction

constant function DES_DPowerLevelBase takes nothing returns real
    return 1.50
endfunction

constant function DES_JPowerLevelBase takes nothing returns real
    return 1.50
endfunction

constant function DES_LargeDPowerLevelMultiplyerBase takes nothing returns real
    return 2.00
endfunction

constant function DES_CPowerLevelPerLevel takes nothing returns real
    return 0.50
endfunction

constant function DES_DPowerLevelPerLevel takes nothing returns real
    return 0.50
endfunction

constant function DES_JPowerLevelPerLevel takes nothing returns real
    return 0.50
endfunction

constant function DES_LargeDPowerLevelMultiplyerPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CImpactHealHealthBase takes nothing returns real
    return 10.00
endfunction

constant function DES_CImpactHealManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_CImpactHealHealthPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_CImpactHealManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_DImpactDamageHealthBase takes nothing returns real
    return 10.00
endfunction

constant function DES_DImpactDamageManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_DImpactDamageHealthPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_DImpactDamageManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_JDamageHealthBase takes nothing returns real
    return 20.00
endfunction

constant function DES_JDamageManaBase takes nothing returns real
    return 20.00
endfunction

constant function DES_JDamageManaburnRatioBase takes nothing returns real
    return 0.5
endfunction

constant function DES_JDamageHealthPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_JDamageManaPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_JDamageManaburnRatioPerPowerLevel takes nothing returns real
    return 0.20
endfunction

constant function DES_CPassiveHealHealthBase takes nothing returns real
    return 2.00
endfunction

constant function DES_CPassiveHealManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_CPassiveHealHealthPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_CPassiveHealManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_DPassiveDamageHealthBase takes nothing returns real
    return 5.00
endfunction

constant function DES_DPassiveDamageManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_DPassiveDamageHealthPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_DPassiveDamageManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PArmaProjectileHealthDamageBase takes nothing returns real
    return 20.00
endfunction

constant function DES_PArmaProjectileManaDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PArmaProjectileHealthDamagePerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PArmaProjectileManaDamagePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CImpactAOEBase takes nothing returns real
    return 45.00
endfunction

constant function DES_DImpactAOEBase takes nothing returns real
    return 45.00
endfunction

constant function DES_CImpactAOEPerPowerLevel takes nothing returns real
    return 20.00
endfunction

constant function DES_DImpactAOEPerPowerLevel takes nothing returns real
    return 40.00
endfunction

constant function DES_CPassiveHealAOEBase takes nothing returns real
    return 45.00
endfunction

constant function DES_DPassiveDamageAOEBase takes nothing returns real
    return 45.00
endfunction

constant function DES_JDamageAOEBase takes nothing returns real  
    return 45.00
endfunction

constant function DES_CSpreadAOEBase takes nothing returns real
    return 150.00
endfunction

constant function DES_PPullAOEBase takes nothing returns real
    return 600.00
endfunction

constant function DES_PPullAOEPerLevel takes nothing returns real
    return 50.00
endfunction

constant function DES_PWildAOEBase takes nothing returns real
    return 150.00
endfunction

constant function DES_PWildStartAOEBase takes nothing returns real
    return 50.00
endfunction

constant function DES_PArmaAOEBase takes nothing returns real
    return 100.00
endfunction

constant function DES_PArmaMinAOE takes nothing returns real
    return 100.00
endfunction

constant function DES_PWildAOEPerPowerLevel takes nothing returns real
    return 15.00
endfunction

constant function DES_PWildStartAOEPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PArmaAOEPerPowerLevel takes nothing returns real
    return 10.00
endfunction

constant function DES_PArmaProjectileAOEBase takes nothing returns real
    return 40.00
endfunction

constant function DES_PArmaProjectileAOEPerPowerLevel takes nothing returns real
    return 2.50
endfunction

constant function DES_PCountAOEBase takes nothing returns real
    return 150.00
endfunction

constant function DES_PCountAOEPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_PDivineStormLightningOffset takes nothing returns real
    return 180.00
endfunction

constant function DES_PDivineStormAOEBase takes nothing returns real
    return 400.00
endfunction

constant function DES_PDivineStormAOEPerPowerLevel takes nothing returns real
    return 3.00
endfunction

constant function DES_PDivineStormStrikeAOEBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormStrikeAOEPerPowerLevel takes nothing returns real
    return 4.00
endfunction

constant function DES_PDivineLaserAOEToScaleRatioBase takes nothing returns real
    return 60.00
endfunction

constant function DES_PDivineLaserAOEToScaleRatioPerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_CycleDamageHealthBase takes nothing returns real
    return 20.00
endfunction

constant function DES_CycleDamageManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_CycleHealHealthRatioBase takes nothing returns real
    return 0.05
endfunction

constant function DES_CycleHealManaRatioBase takes nothing returns real
    return 0.00
endfunction

constant function DES_CycleDamageHealthPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_CycleDamageManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CycleHealHealthRatioPerPowerLevel takes nothing returns real
    return 0.02
endfunction

constant function DES_CycleHealManaRatioPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_EqualManaCostBase takes nothing returns real
    return 10.00
endfunction

constant function DES_EqualManaCostPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_TrialDamageHealthBase takes nothing returns real
    return 20.00
endfunction

constant function DES_TrialDamageManaBase takes nothing returns real
    return 0.00
endfunction

constant function DES_TrialExplosionHealthDamageBase takes nothing returns real
    return 20.00
endfunction

constant function DES_TrialExplosionManaDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_TrialBurnHealthDamageBase takes nothing returns real
    return 2.00
endfunction

constant function DES_TrialBurnManaDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_TrialDamageHealthPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_TrialDamageManaPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_TrialExplosionHealthDamagePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_TrialExplosionManaDamagePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_TrialBurnHealthDamagePerPowerLevel takes nothing returns real
    return 0.5
endfunction

constant function DES_TrialBurnManaDamagePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PCountHealthDamageBase takes nothing returns real
    return 20.00
endfunction

constant function DES_PCountHealthHealBase takes nothing returns real
    return 20.00
endfunction

constant function DES_PCountManaDamageBase takes nothing returns real
    return 20.00
endfunction

constant function DES_PCountManaHealBase takes nothing returns real
    return 20.00
endfunction

constant function DES_PCountHealthDamagePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_PCountHealthHealPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_PCountManaDamagePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_PCountManaHealPerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_PDivineStormHealthDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormManaDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormHealthHealBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormManaHealBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormHealthDamagePerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PDivineStormManaDamagePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormHealthHealPerPowerLevel takes nothing returns real 
    return 1.00
endfunction

constant function DES_PDivineStormManaHealPerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PDivineLaserHealthDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserManaDamageBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserHealthHealBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserManaHealBase takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserHealthDamagePerPowerLevel takes nothing returns real
    return 4.00
endfunction

constant function DES_PDivineLaserManaDamagePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserHealthHealPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineLaserManaHealPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CPassiveHealAOEPerPowerLevel takes nothing returns real
    return 20.00
endfunction

constant function DES_DPassiveDamageAOEPerPowerLevel takes nothing returns real
    return 20.00
endfunction

constant function DES_PPullStrengthBase takes nothing returns real
    return 140.00
endfunction

constant function DES_PPullStrengthPerLevel takes nothing returns real
    return 10.00
endfunction

constant function DES_PDivineLaserKnockbackPowerBase takes nothing returns real
    return 7500.00
endfunction

constant function DES_PDivineLaserKnockbackPowerCapBase takes nothing returns real
    return 30.00
endfunction

constant function DES_PDivineLaserKnockbackPowerPerPowerLevel takes nothing returns real
    return 200.0
endfunction

constant function DES_PDivineLaserKnockbackPowerCapPerPowerLevel takes nothing returns real
    return 0.50
endfunction

constant function DES_JDamageAOEPerPowerLevel takes nothing returns real
    return 20.00
endfunction

constant function DES_PSlowLevel takes nothing returns integer
    return 3
endfunction

constant function DES_CSpreadAOEPerLevel takes nothing returns real
    return 15.00
endfunction

constant function DES_JAngleAreaBase takes nothing returns real
    return 45.00
endfunction

constant function DES_JAngleAreaPerLevel takes nothing returns real
    return 18.33
endfunction

constant function DES_CycleAOEBase takes nothing returns real
    return  50.00
endfunction

constant function DES_EqualAOEBase takes nothing returns real
    return 50.00
endfunction

constant function DES_TrialAOEBase takes nothing returns real
    return 50.00
endfunction

constant function DES_TrialExplosionAOEBase takes nothing returns real
    return 20.00
endfunction

constant function DES_CycleAOEPerPowerLevel takes nothing returns real
    return 25.00
endfunction

constant function DES_EqualAOEPerPowerLevel takes nothing returns real
    return 25.00
endfunction

constant function DES_TrialAOEPerPowerLevel takes nothing returns real
    return 25.00
endfunction

constant function DES_TrialExplosionAOEPerPowerLevel takes nothing returns real
    return 10.00
endfunction

constant function DES_CycleBoarderSpaceBase takes nothing returns real
    return 20.00
endfunction

constant function DES_EqualBoarderSpaceBase takes nothing returns real
    return 20.00
endfunction

constant function DES_TrialBoarderSpaceBase takes nothing returns real
    return 20.00
endfunction

constant function DES_CycleBoarderSpacePerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_EqualBoarderSpacePerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_TrialBoarderSpacePerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_COrbCountBase takes nothing returns integer
    return 5
endfunction

constant function DES_DOrbCountBase takes nothing returns integer
    return 2
endfunction

constant function DES_JOrbCountBase takes nothing returns integer
    return -1
endfunction

constant function DES_COrbCountPerLevel takes nothing returns integer
    return 1
endfunction

constant function DES_DOrbCountPerLevel takes nothing returns integer
    return 2
endfunction

constant function DES_JOrbCountPerLevel takes nothing returns integer
    return 3
endfunction

constant function DES_PBoarderCountBase takes nothing returns integer
    return 8
endfunction

constant function DES_PBoarderCountPerLevel takes nothing returns integer
    return 0
endfunction

constant function DES_PWildTreantCountPerRingBase takes nothing returns real
    return 3.00
endfunction

constant function DES_PWildTreantCountPerRingPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_PArmaProjectilesPerSecondBase takes nothing returns real
    return 2.00
endfunction

constant function DES_PArmaProjectilesPerSecondPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_PDivineStormAmountPerSecondBase takes nothing returns real
    return 10.00
endfunction

constant function DES_PDivineStormAmountPerSecondPerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PPowerForOrbBase takes nothing returns real
    return 7.00
endfunction

constant function DES_PPowerForOrbPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PCreationStartingPowerBase takes nothing returns real
    return 21.00
endfunction

constant function DES_PDestructionStartingPowerBase takes nothing returns real
    return 21.00
endfunction

constant function DES_PJusticeStartingPowerBase takes nothing returns real   
    return 21.00
endfunction

constant function DES_PCreationStartingPowerPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDestructionStartingPowerPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PJusticeStartingPowerPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_CTimedLifeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_DTimedLifeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_JTimedLifeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_CTimedLifePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_DTimedLifePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_JTimedLifePerPowerLevel takes nothing returns real
    return 2.00
endfunction

constant function DES_TrialBurnDurationBase takes nothing returns real
    return 1.00
endfunction

constant function DES_PPullDurationBase takes nothing returns real
    return 9.00
endfunction

constant function DES_PWildTreantDurationBase takes nothing returns real
    return 10.00
endfunction

constant  function  DES_PWildTreantDurationPerPowerLevel takes nothing returns real
    return 0.1
endfunction

constant function DES_PArmaDurationBase takes nothing returns real
    return 5.00
endfunction

constant function DES_PArmaDurationPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_TrialBurnDurationPerPowerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PPullDurationPerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PDivineLaserTimerBase takes nothing returns real
    return 1.50
endfunction

constant function DES_PDivineLaserTimerPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_Gravity takes nothing returns real
    return 4.12
endfunction

constant function DES_DestroyTrees takes nothing returns boolean
    return true
endfunction

constant function DES_TerrainHeightMatters takes nothing returns boolean
    return true
endfunction

constant function DES_CTrueOrIncomingSpeed takes nothing returns boolean
    return false
endfunction

constant function DES_DTrueOrIncomingSpeed takes nothing returns boolean
    return true
endfunction

constant function DES_JTrueOrIncomingSpeed takes nothing returns boolean
    return false
endfunction

constant function DES_PSpinTrueOrIncomingSpeed takes nothing returns boolean
    return false
endfunction

constant function DES_PArmaTrueOrIncomingSpeed takes nothing returns boolean
    return false
endfunction

constant function DES_CTrueSpeedBase takes nothing returns real
    return 5.00
endfunction

constant function DES_DTrueSpeedBase takes nothing returns real
    return 5.00
endfunction

constant function DES_JTrueSpeedBase takes nothing returns real
    return 5.00
endfunction

constant function DES_POrbTrueSpinSpeedBase takes nothing returns real
    return 0.50
endfunction

constant function DES_PArmaTrueSpeedBase takes nothing returns real
    return 3.00
endfunction

constant function DES_CIncomingTimeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_DIncomingTimeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_JIncomingTimeBase takes nothing returns real
    return 1.50
endfunction

constant function DES_POrbSpinIncomingTimeBase takes nothing returns real
    return 3.00
endfunction

constant function DES_PArmaIncomingTimeBase takes nothing returns real
    return 1.00
endfunction

constant function DES_CTrueSpeedPerPowerLevel takes nothing returns real
    return 7.00
endfunction

constant function DES_DTrueSpeedPerPowerLevel takes nothing returns real
    return 3.00
endfunction

constant function DES_JTrueSpeedPerPowerLevel takes nothing returns real
    return 5.00
endfunction

constant function DES_POrbTrueSpinSpeedPerLevel takes nothing returns real
    return 1.00
endfunction

constant function DES_PArmaTrueSpeedPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_CIncomingTimePerPowerLevel takes nothing returns real
    return -0.30
endfunction

constant function DES_DIncomingTimePerPowerLevel takes nothing returns real
    return -0.30
endfunction

constant function DES_JIncomingTimePerPowerLevel takes nothing returns real
    return -0.25
endfunction

constant function DES_POrbSpinIncomingTimePerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PArmaIncomingTimePerPowerLevel takes nothing returns real
    return -0.01
endfunction

constant function DES_CPassiveDelayBase takes nothing returns real
    return 2.00
endfunction

constant function DES_DPassiveDelayBase takes nothing returns real
    return 2.00
endfunction

constant function DES_JDamageDelayBase takes nothing returns real
    return 0.30
endfunction

constant function DES_TrialDamageDelayBase takes nothing returns real
    return 0.50
endfunction

constant function DES_CPassiveDelayPerPowerLevel takes nothing returns real
    return -0.075
endfunction

constant function DES_DPassiveDelayPerPowerLevel takes nothing returns real
    return -0.075
endfunction

constant function DES_JDamageDelayPerPowerLevel takes nothing returns real
    return -0.05
endfunction

constant function DES_TrialDamageDelayPerPowerLevel takes nothing returns real 
    return 0.00
endfunction

constant function DES_PPullEffectDelayBase takes nothing returns real
    return 1.00
endfunction

constant function DES_PPullEffectDelayPerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PWildExpandRingCountBase takes nothing returns real
    return 3.00
endfunction

constant function DES_PWildExpandRingCountPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_PWildTreantSpawnDelayBase takes nothing returns real
    return 0.50
endfunction

constant function DES_PWildTreantSpawnDelayPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PArmaLaunchDelayBase takes nothing returns real
    return 0.06
endfunction

constant function DES_PArmaLaunchDelayPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PCountTimerBase takes nothing returns real
    return 10.00
endfunction

constant function DES_PCountTimerPerPowerLevel takes nothing returns real
    return -0.10
endfunction

constant function DES_PDivineAscensionTimeBase takes nothing returns real
    return 2.00
endfunction

constant function DES_PDivineAscensionTimePerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormDurationBase takes nothing returns real
    return 5.00
endfunction

constant function DES_PDivineStormDelayBase takes nothing returns real
    return 0.15
endfunction

constant function DES_PDivineStormDelayPerPowerLevel takes nothing returns real
    return 0.00
endfunction

constant function DES_PDivineStormDurationPerPowerLevel takes nothing returns real
    return 0.10
endfunction

constant function DES_DAttackType takes nothing returns attacktype
    return ATTACK_TYPE_MAGIC
endfunction

constant function DES_JAttackType takes nothing returns attacktype
    return ATTACK_TYPE_MAGIC
endfunction

constant function DES_CycleAttackType takes nothing returns attacktype
    return ATTACK_TYPE_MAGIC
endfunction

constant function DES_TrialAttackType takes nothing returns attacktype
    return ATTACK_TYPE_MAGIC
endfunction

constant function DES_PAttackType takes nothing returns attacktype
    return ATTACK_TYPE_MAGIC
endfunction

constant function DES_DDamageType takes nothing returns damagetype
    return DAMAGE_TYPE_MAGIC
endfunction

constant function DES_JDamageType takes nothing returns damagetype
    return DAMAGE_TYPE_MAGIC
endfunction

constant function DES_CycleDamageType takes nothing returns damagetype
    return DAMAGE_TYPE_MAGIC
endfunction

constant function DES_TrialDamageType takes nothing returns damagetype
    return DAMAGE_TYPE_MAGIC
endfunction

constant function DES_PDamageType takes nothing returns damagetype
    return DAMAGE_TYPE_MAGIC
endfunction

constant function DES_DWeaponType takes nothing returns weapontype
    return null
endfunction

constant function DES_JWeaponType takes nothing returns weapontype
    return null
endfunction

constant function DES_CycleWeaponType takes nothing returns weapontype
    return null
endfunction

constant function DES_TrialWeaponType takes nothing returns weapontype
    return null
endfunction

constant function DES_PWeaponType takes nothing returns weapontype
    return null
endfunction

constant function DES_EffectExpirationTimer takes nothing returns real
    return 2.00
endfunction

constant function DES_DummyPlayer takes nothing returns player
    return Player(1)
endfunction

constant function DES_AttachmentPoint takes nothing returns string
    return "origin"
endfunction

constant function DES_CStageID takes nothing returns integer
    return 1
endfunction

constant function DES_DStageID takes nothing returns integer
    return 2
endfunction

constant function DES_JStageID takes nothing returns integer
    return 3
endfunction

constant function DES_LargeDStageID takes nothing returns integer
    return 4
endfunction

constant function DES_UnitStageID takes nothing returns integer
    return 5
endfunction

constant function DES_UltimateStageID takes nothing returns integer
    return 6
endfunction

constant function DES_PProjectileStageID takes nothing returns integer
    return 7
endfunction

constant function DES_RecycleStageID takes nothing returns integer
    return 8
endfunction

constant function DES_UltimateWaitingTypeID takes nothing returns integer
    return 0
endfunction

constant function DES_UltimatePullingTypeID takes nothing returns integer
    return 1
endfunction

constant function DES_UltimateWildTypeID takes nothing returns integer
    return 2
endfunction

constant function DES_UltimateArmaTypeID takes nothing returns integer
    return 3
endfunction

constant function DES_UltimateCountTypeID takes nothing returns integer
    return 4
endfunction

constant function DES_UltimateDivineStartTypeID takes nothing returns integer
    return 5
endfunction

constant function DES_UltimateDivineStormTypeID takes nothing returns integer
    return 6
endfunction

constant function DES_UltimateDivineLaserTypeID takes nothing returns integer
    return 7
endfunction

constant function DES_UltimateDivineLightningTypeID takes nothing returns integer
    return 8
endfunction

constant function DES_GroundHeightLet takes nothing returns real
    return 0.
endfunction

constant function DES_PSmallOrbSizeLimiter takes nothing returns real
    return 5.00
endfunction

constant function DES_ComboCollision takes nothing returns real
    return 60.00
endfunction

constant function DES_PDivineLaserKnockbackAngle takes nothing returns real
    return 1.308
endfunction

constant function DES_GroundDrag takes nothing returns real  
    return 0.95
endfunction

constant function DES_GroundDragStop takes nothing returns real
    return 1.00
endfunction

constant function DES_FallDamageMultiplyer takes nothing returns real
    return 1.00
endfunction

constant function DES_FilterMaxZ takes nothing returns real
    return 0.00
endfunction

constant function DES_TreeDestroyRadius takes nothing returns real
    return 45.00
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
//  Function used to get the z height of locations needed by the  //
//  spell, since it can only be done with locations, this one     //
//  is reused throughout, instead of creating/destroying them     //
////////////////////////////////////////////////////////////////////
function DES_GetZ takes real x, real y returns real

    //Gets the location Z of the selected location
    call MoveLocation(udg_DES_Loc, x, y)
    return GetLocationZ(udg_DES_Loc)
    
endfunction

/////////////////////////////////////////////////////////////////////
//  Target filter function - passed units and players and checks   //
//  if the unit is allowed to be targetted by this ability         //
/////////////////////////////////////////////////////////////////////
function DES_NeutralTargetFilter takes unit u returns boolean

    //Checks if the unit can be used as a target
    if (not IsUnitType(u, UNIT_TYPE_STRUCTURE)) and (GetUnitFlyHeight(u) <= DES_FilterMaxZ) and (IsUnitType(u, UNIT_TYPE_GROUND)) and (not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE)) and (GetUnitTypeId(u) != DES_DummyID()) and not(IsUnitType(u, UNIT_TYPE_DEAD) or GetUnitTypeId(u) == 0) then
        return true
    endif
    
    return false
    
endfunction

/////////////////////////////////////////////////////////////////////
//  Target filter function - passed units and players and checks   //
//  if the unit is allowed to be targetted by this ability         //
/////////////////////////////////////////////////////////////////////
function DES_EnemyTargetFilter takes unit u, player pl returns boolean

    //Checks if the unit can be used as a target
    if (not IsUnitType(u, UNIT_TYPE_STRUCTURE)) and (GetUnitFlyHeight(u) <= DES_FilterMaxZ) and (IsUnitType(u, UNIT_TYPE_GROUND)) and (not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE)) and (IsUnitEnemy(u, pl)) and (GetUnitTypeId(u) != DES_DummyID()) and not(IsUnitType(u, UNIT_TYPE_DEAD) or GetUnitTypeId(u) == 0) then
        return true
    endif
    
    return false
    
endfunction

/////////////////////////////////////////////////////////////////////
//  Target filter function - passed units and players and checks   //
//  if the unit is allowed to be targetted by this ability         //
/////////////////////////////////////////////////////////////////////
function DES_FriendlyTargetFilter takes unit u, player pl returns boolean

    //Checks if the unit can be used as a target
    if (not IsUnitType(u, UNIT_TYPE_STRUCTURE)) and (GetUnitFlyHeight(u) <= DES_FilterMaxZ) and (IsUnitType(u, UNIT_TYPE_GROUND)) and (not IsUnitType(u, UNIT_TYPE_MAGIC_IMMUNE)) and (not(IsUnitEnemy(u, pl))) and (GetUnitTypeId(u) != DES_DummyID()) and not(IsUnitType(u, UNIT_TYPE_DEAD) or GetUnitTypeId(u) == 0) then
        return true
    endif
    
    return false
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_OrbTargetFilter takes integer Node, integer StageID, player pl returns boolean

    if ((GetUnitTypeId(udg_DES_Unit[Node]) == DES_DummyID()) and (udg_DES_StageID[Node] <= DES_JStageID()) and (udg_DES_Boolean1[Node] == true) and (udg_DES_Boolean2[Node] == false) and (udg_DES_Player[Node] == pl) and (not(udg_DES_StageID[Node] == StageID))) then
        return true
    endif
    
    return false
    
endfunction

////////////////////////////////////////////////////////////////////
//  Function used to recycle instances, so that they can used     //
//  again later, keeping the total array sizes smaller            //
////////////////////////////////////////////////////////////////////
function DES_Recycle takes integer Node returns nothing
           
        set udg_DES_StageID[Node] = DES_RecycleStageID()
        
        if (udg_DES_LastNode == Node) then
            set udg_DES_LastNode = udg_DES_PrevNode[Node]
        endif
           
        //Recycles the node
        set udg_DES_RecycleNodes[udg_DES_RecyclableNodes] = Node
        set udg_DES_RecyclableNodes = udg_DES_RecyclableNodes + 1
        set udg_DES_NextNode[udg_DES_PrevNode[Node]] = udg_DES_NextNode[Node]
        set udg_DES_PrevNode[udg_DES_NextNode[Node]] = udg_DES_PrevNode[Node]
        set udg_DES_AbilityCounter = udg_DES_AbilityCounter - 1

        if (udg_DES_AbilityCounter == 0) then
            call PauseTimer(udg_DES_Timer)
        endif

endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_CreateNode takes nothing returns integer
    local integer Node = 0
    
    //Checking for recycleable Nodes
    if (udg_DES_RecyclableNodes == 0) then
        set udg_DES_NodeNumber = udg_DES_NodeNumber + 1
        set Node = udg_DES_NodeNumber
    else
        set udg_DES_RecyclableNodes = udg_DES_RecyclableNodes - 1
        set Node = udg_DES_RecycleNodes[udg_DES_RecyclableNodes]
    endif

    //Sets up this Node
    set udg_DES_NextNode[Node] = 0
    set udg_DES_NextNode[udg_DES_LastNode] = Node
    set udg_DES_PrevNode[Node] = udg_DES_LastNode
    set udg_DES_LastNode = Node
    
    set udg_DES_AbilityCounter = udg_DES_AbilityCounter + 1
    
    return Node
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_ValidateLocation takes real x, real y returns boolean
    
    if (x < udg_DES_MapMaxX) and (x > udg_DES_MapMinX) and (y < udg_DES_MapMaxY) and (y > udg_DES_MapMinY) then
        return true
    endif
    
    return false

endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_TreeDestroy takes nothing returns nothing
    local destructable Tree = GetEnumDestructable()
    
    call IssueTargetOrderById(udg_DES_TreeChecker, 852018, Tree)
    
    if (GetUnitCurrentOrder(udg_DES_TreeChecker) == 852018) then
        call KillDestructable(Tree)
    endif

    call IssueImmediateOrderById(udg_DES_TreeChecker, 851972)
    set Tree = null
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_GetTrees takes real x, real y returns nothing
    local rect TempRect = Rect(x - DES_TreeDestroyRadius(), y - DES_TreeDestroyRadius(), x + DES_TreeDestroyRadius(), y + DES_TreeDestroyRadius())
    
    call MoveLocation(udg_DES_Loc, x, y)
    set bj_enumDestructableCenter = udg_DES_Loc
    set bj_enumDestructableRadius = DES_TreeDestroyRadius()
    call EnumDestructablesInRect(TempRect, filterEnumDestructablesInCircleBJ, function DES_TreeDestroy)
    call RemoveRect(TempRect)
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_EndUltimate takes integer Node returns nothing
    local integer TempInt = 0
    local integer TempNode = 0
    
    loop
        set TempInt = TempInt + 1
        exitwhen TempInt > udg_DES_AbilityCounter
        set TempNode = udg_DES_NextNode[TempNode]
        
        if (udg_DES_Core[TempNode] == udg_DES_Unit[Node]) then
            
            call DestroyEffect(udg_DES_CurrentEffect[TempNode])
            set udg_DES_StageID[TempNode] = DES_RecycleStageID()
            call DES_Recycle(TempNode)
            set TempInt = TempInt - 1
            
            if (udg_DES_Boolean4[TempNode] == true) and (udg_DES_Boolean3[TempNode] == false) then
                call DestroyEffect(AddSpecialEffectTarget(DES_PDeathEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint()))
            else
                call RemoveUnit(udg_DES_Unit[TempNode])
            endif
            
            call UnitApplyTimedLife(udg_DES_Unit[TempNode], DES_TimedLifeID(), DES_EffectExpirationTimer())
        endif
        
    endloop

endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_UltimateCountStart takes integer Node returns nothing
    set udg_DES_Integer1[Node] = DES_UltimateCountTypeID()
    set udg_DES_Real4[Node] = DES_PCountAOEBase() + (udg_DES_Real3[Node] * DES_PCountAOEPerPowerLevel())
    set udg_DES_Real5[Node] = DES_PCountHealthDamageBase() + (udg_DES_Real2[Node] * DES_PCountHealthDamagePerPowerLevel())
    set udg_DES_Real6[Node] = DES_PCountManaDamageBase() + (udg_DES_Real2[Node] * DES_PCountManaDamagePerPowerLevel())
    set udg_DES_Real7[Node] = DES_PCountHealthHealBase() + (udg_DES_Real2[Node] * DES_PCountHealthHealBase())
    set udg_DES_Real10[Node] = DES_PCountManaHealBase() + (udg_DES_Real2[Node] * DES_PCountManaHealPerPowerLevel())
    set udg_DES_Real11[Node] = DES_PCountTimerBase() + (udg_DES_Real1[Node] * DES_PCountTimerPerPowerLevel())
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_AddOrb takes integer Node, integer Type, real x, real y, real Height, real Angle returns nothing
    local integer TempNode = DES_CreateNode()
    local real x2 = x + udg_DES_Real8[Node] * Cos(Angle)
    local real y2 = y + udg_DES_Real8[Node] * Sin(Angle)
    
    if (Type == DES_CStageID()) then
        set udg_DES_Real2[TempNode] = DES_CPassiveHealAOEBase() + (udg_DES_Real3[Node] * DES_CPassiveHealAOEPerPowerLevel())
        set udg_DES_Real3[TempNode] = DES_CPassiveHealHealthBase() + (udg_DES_Real3[Node] * DES_CPassiveHealHealthPerPowerLevel())
        set udg_DES_Real4[TempNode] = DES_CPassiveHealManaBase() + (udg_DES_Real3[Node] * DES_CPassiveHealManaPerPowerLevel())
        set udg_DES_Real5[TempNode] = DES_CPassiveDelayBase() + (udg_DES_Real3[Node] * DES_CPassiveDelayPerPowerLevel())
        set udg_DES_Real6[TempNode] = udg_DES_Real5[TempNode]
        set udg_DES_Boolean1[TempNode] = true
        set udg_DES_Boolean2[TempNode] = true
        set udg_DES_Boolean3[TempNode] = false
        set udg_DES_Boolean4[TempNode] = true
        set udg_DES_StageID[TempNode] = DES_CStageID()
        set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
        set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
        set udg_DES_Player[TempNode] = udg_DES_Player[Node]
        
        set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x2, y2, Angle)
        set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_COrbEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
        call SetUnitScale(udg_DES_Unit[TempNode], (DES_COrbScaleBase() + (udg_DES_Real3[Node] * DES_COrbScalePerPowerLevel())) / DES_PSmallOrbSizeLimiter(), 0, 0)
        
        if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
        endif
        
        call SetUnitFlyHeight(udg_DES_Unit[TempNode], Height, 0.)
    elseif (Type == DES_DStageID()) then
        set udg_DES_Real2[TempNode] = DES_DPassiveDamageAOEBase() + (udg_DES_Real3[Node] * DES_DPassiveDamageAOEPerPowerLevel())
        set udg_DES_Real3[TempNode] = DES_DPassiveDamageHealthBase() + (udg_DES_Real3[Node] * DES_DPassiveDamageHealthPerPowerLevel())
        set udg_DES_Real4[TempNode] = DES_DPassiveDamageManaBase() + (udg_DES_Real3[Node] * DES_DPassiveDamageManaPerPowerLevel())
        set udg_DES_Real5[TempNode] = DES_DPassiveDelayBase() + (udg_DES_Real3[Node] * DES_DPassiveDelayPerPowerLevel())
        set udg_DES_Real6[TempNode] = udg_DES_Real5[TempNode]
        set udg_DES_Boolean1[TempNode] = true
        set udg_DES_Boolean2[TempNode] = true
        set udg_DES_Boolean3[TempNode] = false
        set udg_DES_Boolean4[TempNode] = true
        
        set udg_DES_StageID[TempNode] = DES_DStageID()
        set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
        set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
        set udg_DES_Player[TempNode] = udg_DES_Player[Node]
        
        set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x2, y2, Angle)
        set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_DOrbEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
        call SetUnitScale(udg_DES_Unit[TempNode], (DES_DOrbScaleBase() + (udg_DES_Real3[Node] * DES_DOrbScalePerPowerLevel())) / DES_PSmallOrbSizeLimiter(), 0, 0)
        
        if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
        endif
        
        call SetUnitFlyHeight(udg_DES_Unit[TempNode], Height, 0.)
    else
        set udg_DES_Real2[TempNode] = DES_JDamageAOEBase() + (udg_DES_Real3[Node] * DES_JDamageAOEPerPowerLevel())
        set udg_DES_Integer2[TempNode] = DES_PSlowLevel()
        set udg_DES_Boolean1[TempNode] = true
        set udg_DES_Boolean2[TempNode] = true
        set udg_DES_Boolean3[TempNode] = false
        set udg_DES_Boolean4[TempNode] = true
        
        set udg_DES_StageID[TempNode] = DES_JStageID()
        set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
        set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
        set udg_DES_Player[TempNode] = udg_DES_Player[Node]
        
        set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x2, y2, Angle * bj_RADTODEG)
        set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_JOrbEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
        call SetUnitScale(udg_DES_Unit[TempNode], (DES_JOrbScaleBase() + (udg_DES_Real3[Node] * DES_JOrbScalePerPowerLevel())) / DES_PSmallOrbSizeLimiter(), 0, 0)
        
        if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
        endif
        
        call SetUnitFlyHeight(udg_DES_Unit[TempNode], Height, 0.)
    endif
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_ComboEffects takes real x, real y, integer Divider, real AOE, real BoarderScale, real ActivateScale, string BoarderEffect, string ActivateEffect returns nothing
    local integer iLoop = 0
    local real Angle = 0
    local real Angle2 = 0
    local unit u = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, 0)
    local integer BoarderCount= (360 / Divider)
    
    call DestroyEffect(AddSpecialEffectTarget(ActivateEffect, u, DES_AttachmentPoint()))
    call SetUnitScale(u, ActivateScale, 0,0)
    call UnitApplyTimedLife(u, DES_TimedLifeID(), DES_EffectExpirationTimer()) 
    
    set u = null
    
    loop
        set iLoop = iLoop + 1
        set Angle = Angle + Divider
        set Angle2 = Angle * bj_DEGTORAD
        set u = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x + AOE * Cos(Angle2),  y + AOE * Sin(Angle2), 0)
        call DestroyEffect(AddSpecialEffectTarget(BoarderEffect, u, DES_AttachmentPoint()))
        call SetUnitScale(u, BoarderScale, 0, 0)
        call UnitApplyTimedLife(u, DES_TimedLifeID(), DES_EffectExpirationTimer())
        set u = null
        exitwhen iLoop > BoarderCount
    endloop
    
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_CycleOfLife takes real x, real y, real Power, unit Caster, player pl returns nothing
    local real AOE = DES_CycleAOEBase() + (Power * DES_CycleAOEPerPowerLevel())
    local real DamageHealth = DES_CycleDamageHealthBase() + (Power * DES_CycleDamageHealthPerPowerLevel())
    local real DamageMana = DES_CycleDamageManaBase() + (Power * DES_CycleDamageManaPerPowerLevel())
    local real HealHealthRatio = DES_CycleHealHealthRatioBase() + (Power * DES_CycleHealHealthRatioPerPowerLevel())
    local real HealManaRatio = DES_CycleHealManaRatioBase() + (Power * DES_CycleHealManaRatioPerPowerLevel())
    local real TotalDamageHealth = 0
    local real TotalDamageMana = 0
    local real TempReal
    local integer Divider = R2I((bj_PI * AOE * 2) / (DES_CycleBoarderSpaceBase() + (Power * DES_CycleBoarderSpacePerPowerLevel())))
    local unit u
    
    call DES_ComboEffects(x, y, Divider, AOE, DES_CycleBoarderScaleBase() + (Power * DES_CycleBoarderScalePerPowerLevel()), DES_CycleActivateScaleBase() + (Power * DES_CycleActivateScalePerPowerLevel()), DES_CycleBoarderEffect(), DES_CycleActivateEffect())
    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, AOE, null)
    
    loop
        set u = FirstOfGroup(udg_DES_TempGroup)
        exitwhen  u == null
        
        if (DES_EnemyTargetFilter(u, pl)) then
            call DestroyEffect(AddSpecialEffectTarget(DES_CycleDamageEffect(), u, DES_AttachmentPoint()))
            set TempReal = GetUnitState(u, UNIT_STATE_LIFE)
            call UnitDamageTarget(Caster, u, DamageHealth, false, false, DES_CycleAttackType(), DES_CycleDamageType(), DES_CycleWeaponType())
            set TotalDamageHealth = TotalDamageHealth + (TempReal - GetUnitState(u, UNIT_STATE_LIFE))
            set TempReal = GetUnitState(u, UNIT_STATE_MANA)
            call SetUnitState(u, UNIT_STATE_MANA, TempReal - DamageMana)
            set TotalDamageMana = TotalDamageMana + (TempReal - GetUnitState(u, UNIT_STATE_MANA))
        endif
        
        call GroupRemoveUnit(udg_DES_TempGroup, u)
    endloop
    
    set TotalDamageHealth = TotalDamageHealth * HealHealthRatio
    set TotalDamageMana = TotalDamageMana * HealManaRatio
    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, AOE, null)
    
    loop
        set u = FirstOfGroup(udg_DES_TempGroup)
        exitwhen  u == null
        
        if (DES_FriendlyTargetFilter(u, pl)) then
            call DestroyEffect(AddSpecialEffectTarget(DES_CycleHealEffect(), u, DES_AttachmentPoint()))
            call SetUnitState(u, UNIT_STATE_LIFE, GetUnitState(u, UNIT_STATE_LIFE) + TotalDamageHealth)
            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) + TotalDamageMana)
        endif
        
        call GroupRemoveUnit(udg_DES_TempGroup, u)
    endloop    
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_Equaliser takes real x, real y, real Power, unit Caster, player pl returns nothing
    local real AOE = DES_EqualAOEBase() + (Power * DES_EqualAOEPerPowerLevel())
    local real ManaCost = DES_EqualManaCostBase() + (Power * DES_EqualManaCostPerPowerLevel())
    local real Health= 0
    local real iCount = 0
    local integer Divider = R2I((bj_PI * AOE * 2) / (DES_EqualBoarderSpaceBase() + (Power * DES_EqualBoarderSpacePerPowerLevel())))
    local unit u
    
    call DES_ComboEffects(x, y, Divider, AOE, DES_EqualBoarderScaleBase() + (Power * DES_EqualBoarderScalePerPowerLevel()), DES_EqualActivateScaleBase() + (Power * DES_EqualActivateScalePerPowerLevel()), DES_EqualBoarderEffect(), DES_EqualActivateEffect())
    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, AOE, null)
    
    loop
        set u = FirstOfGroup(udg_DES_TempGroup)
        exitwhen  u == null
        
        if (DES_NeutralTargetFilter(u)) then
            call GroupAddUnit(udg_DES_TempGroup2, u)
            set iCount = iCount + 1
            set Health = Health + GetUnitState(u, UNIT_STATE_LIFE)
            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - ManaCost)
        endif
        
        call GroupRemoveUnit(udg_DES_TempGroup, u)
    endloop
    
    set Health = Health / iCount
    
    loop
        set u = FirstOfGroup(udg_DES_TempGroup2)
        exitwhen u == null
        call DestroyEffect(AddSpecialEffectTarget(DES_EqualAlterEffect(), u, DES_AttachmentPoint()))
        call SetUnitState(u, UNIT_STATE_LIFE, Health)
        call GroupRemoveUnit(udg_DES_TempGroup2, u)
    endloop
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_TrialByFire takes real x, real y, real Power, integer Node returns nothing
    local real AOE = DES_TrialAOEBase() + (Power * DES_TrialAOEPerPowerLevel())
    local real BoarderScale = DES_TrialBoarderScaleBase() + (Power * DES_TrialBoarderScalePerPowerLevel())
    local real DamageHealth = DES_TrialDamageHealthBase() + (Power * DES_TrialDamageHealthPerPowerLevel())
    local real DamageMana = DES_TrialDamageManaBase() + (Power * DES_TrialDamageManaPerPowerLevel())
    local integer Divider = R2I((bj_PI * AOE * 2) / (DES_TrialBoarderSpaceBase() + (Power * DES_TrialBoarderSpacePerPowerLevel())))
    local integer TempNode = 0
    local unit u
    
    call DES_ComboEffects(x, y, Divider, AOE, DES_TrialBoarderScaleBase() + (Power * DES_TrialBoarderScalePerPowerLevel()), DES_TrialActivateScaleBase() + (Power * DES_TrialActivateScalePerPowerLevel()), DES_TrialBoarderEffect(), DES_TrialActivateEffect())
    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, AOE, null)

    loop
        set u = FirstOfGroup(udg_DES_TempGroup)
        exitwhen u == null
        
        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
            call DestroyEffect(AddSpecialEffectTarget(DES_TrialDamageEffect(), u, DES_AttachmentPoint()))
            call UnitDamageTarget(udg_DES_Caster[Node], u, DamageHealth, false, false, DES_TrialAttackType(), DES_TrialDamageType(), DES_TrialWeaponType())
            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - DamageMana)
            
            set TempNode = DES_CreateNode()
            set udg_DES_Real1[TempNode] = Power
            set udg_DES_Real2[TempNode] = DES_TrialExplosionAOEBase() + (Power * DES_TrialExplosionAOEPerPowerLevel())
            set udg_DES_Real3[TempNode] = DES_TrialExplosionHealthDamageBase() + (Power * DES_TrialExplosionHealthDamagePerPowerLevel())
            set udg_DES_Real4[TempNode] = DES_TrialExplosionManaDamageBase() + (Power * DES_TrialExplosionManaDamagePerPowerLevel())
            set udg_DES_Real5[TempNode] = DES_TrialBurnHealthDamageBase() + (Power * DES_TrialBurnHealthDamagePerPowerLevel())
            set udg_DES_Real6[TempNode] = DES_TrialBurnManaDamageBase() + (Power * DES_TrialBurnManaDamagePerPowerLevel())
            set udg_DES_Real7[TempNode] = DES_TrialBurnDurationBase() + (Power * DES_TrialBurnDurationPerPowerLevel())
            set udg_DES_Real8[TempNode] = DES_TrialDamageDelayBase() + (Power * DES_TrialDamageDelayPerPowerLevel())
            set udg_DES_Real9[TempNode] = udg_DES_Real8[TempNode]
            set udg_DES_Boolean1[TempNode] = true
            set udg_DES_Boolean2[TempNode] = false
            set udg_DES_Boolean3[TempNode] = false
            set udg_DES_Boolean4[TempNode] = false
            
            set udg_DES_StageID[TempNode] = DES_UnitStageID() 
            set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
            set udg_DES_Unit[TempNode] = u
            set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
            
            set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_TrialBurnEffect(), u, DES_AttachmentPoint())
        endif
        
        call GroupRemoveUnit(udg_DES_TempGroup, u)
    endloop
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_SlowScan takes integer Node returns nothing
    local integer TempNode = 0
    local integer TempInt = 0
    
    loop
        set TempInt = TempInt + 1
        exitwhen TempInt > udg_DES_AbilityCounter
        set TempNode = udg_DES_NextNode[TempNode]
        
        if (udg_DES_Core[TempNode] == udg_DES_Unit[Node]) and (udg_DES_Boolean2[TempNode] == true) and (udg_DES_StageID[TempNode] == DES_UnitStageID()) then
            call UnitRemoveAbility(udg_DES_Unit[TempNode], DES_SlowID())
            call DestroyEffect(udg_DES_CurrentEffect[TempNode])
            call DES_Recycle(TempNode)
            set TempInt = TempInt - 1
        endif
        
    endloop
    
endfunction
////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_ComboCollisionDetection takes real x, real y, integer Node returns nothing
    local integer TempInt = 0
    local integer TempNode = 0
    local real x2 = 0
    local real y2 = 0
    local real TempReal = 0
    local real TempReal2 = 0
    
    loop
        //Moves to the next node
        set TempInt = TempInt + 1
        exitwhen ((TempInt > udg_DES_AbilityCounter) or (udg_DES_StageID[Node] == DES_RecycleStageID()))
        set TempNode = udg_DES_NextNode[TempNode]

        if (DES_OrbTargetFilter(TempNode, udg_DES_StageID[Node], udg_DES_Player[Node])) then
            set x2 = GetUnitX(udg_DES_Unit[TempNode])
            set y2 = GetUnitY(udg_DES_Unit[TempNode])
            set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
            
            if (TempReal <= DES_ComboCollision()) then
                set x = x + (x2 - x)
                set y = y + (y2 - y)
                
                if (udg_DES_StageID[Node] == DES_JStageID()) then
                    call DestroyEffect(udg_DES_SecondaryEffect[Node])
                    call DES_SlowScan(Node)
                elseif (udg_DES_StageID[TempNode] == DES_JStageID()) then
                    call DestroyEffect(udg_DES_SecondaryEffect[TempNode])
                    call DES_SlowScan(TempNode)
                endif
                
                set TempReal = udg_DES_StageID[TempNode] * udg_DES_StageID[Node]
                set TempReal2 = udg_DES_Real1[TempNode] + udg_DES_Real1[Node]
                
                call DES_Recycle(Node)
                call DES_Recycle(TempNode)
                set TempInt = TempInt - 1
                
                call DestroyEffect(udg_DES_CurrentEffect[Node])
                call DestroyEffect(udg_DES_CurrentEffect[TempNode])
                call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_EffectExpirationTimer())
                call UnitApplyTimedLife(udg_DES_Unit[TempNode], DES_TimedLifeID(), DES_EffectExpirationTimer())
                
                if (TempReal == DES_DStageID()) then
                    call DES_CycleOfLife(x, y, TempReal2, udg_DES_Caster[Node], udg_DES_Player[Node])
                elseif  (TempReal == DES_JStageID()) then
                    call DES_Equaliser(x, y, TempReal2, udg_DES_Caster[Node], udg_DES_Player[Node])
                else
                    call DES_TrialByFire(x, y, TempReal2, Node)
                endif
                
            endif
            
        endif
        
    endloop
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_ProjectileHandler takes integer Node returns boolean
    local real z
    local real z2
    local real x = GetUnitX(udg_DES_Unit[Node])
    local real x2 = x + udg_DES_Real6[Node]
    local real y = GetUnitY(udg_DES_Unit[Node])
    local real y2 = y + udg_DES_Real7[Node]
    local real TempReal
    local integer iLoop = 0
    local unit u
    
    if (DES_ValidateLocation(x2, y2)) then
        call SetUnitX(udg_DES_Unit[Node], x2)
        call SetUnitY(udg_DES_Unit[Node], y2)
    endif
    
    if (udg_DES_StageID[Node] == DES_JStageID()) then
        set udg_DES_Real5[Node] = udg_DES_Real5[Node] - udg_DES_Real8[Node]
        
        if (udg_DES_Real11[Node] <= 0) then
            set udg_DES_Real11[Node] = udg_DES_Real10[Node]
            call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
            
            loop
                set u = FirstOfGroup(udg_DES_TempGroup)
                exitwhen u == null
                
                if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                    call DestroyEffect(AddSpecialEffectTarget(DES_JDamageEffect(), u, DES_AttachmentPoint()))
                    call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_JAttackType(), DES_JDamageType(), DES_JWeaponType())
                    set TempReal = GetUnitState(u, UNIT_STATE_MANA)
                    call SetUnitState(u, UNIT_STATE_MANA, TempReal - udg_DES_Real4[Node])
                    call UnitDamageTarget(udg_DES_Caster[Node], u, (TempReal - GetUnitState(u, UNIT_STATE_MANA)) * udg_DES_Real9[Node], false, false, DES_JAttackType(), DES_JDamageType(), DES_JWeaponType())
                endif
                
                call GroupRemoveUnit(udg_DES_TempGroup, u)
            endloop
            
        else
            set udg_DES_Real11[Node] = udg_DES_Real11[Node] - DES_TimerSpeed()
        endif
        
        call DES_ComboCollisionDetection(x, y, Node)
        
        if (udg_DES_Real5[Node] <= 0) then
            return true
        endif
        
    else
    
        if (DES_TerrainHeightMatters()) then
            set z2 = DES_GetZ(x2, y2)
            set z = DES_GetZ(x, y)
            set z = GetUnitFlyHeight(udg_DES_Unit[Node]) + udg_DES_Real5[Node] - (z2 - z)
        else
            set z = GetUnitFlyHeight(udg_DES_Unit[Node]) + udg_DES_Real5[Node]        
        endif

        set udg_DES_Real5[Node] = udg_DES_Real5[Node] - DES_Gravity()
        call SetUnitFlyHeight(udg_DES_Unit[Node], z, 0.)
        
        if (z <= DES_GroundHeightLet()) then
            call SetUnitFlyHeight(udg_DES_Unit[Node], 0., 0.)
            return true
        endif
        
    endif
    
    return false
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_Loop takes nothing returns nothing
    local integer TempInt = 0
    local integer TempInt2 = 0
    local integer iLoop = 0
    local integer Node = 0
    local integer TempNode = 0
    local real x
    local real x2
    local real y
    local real y2
    local real z
    local real z2
    local real Angle = 0
    local real TempReal = 0
    local unit u
    //Main loop
    loop
        //Moves to the next node
        set TempInt = TempInt + 1
        exitwhen TempInt > udg_DES_AbilityCounter
        set Node = udg_DES_NextNode[Node]
        
        //Creation Orbs
        if (udg_DES_StageID[Node] == DES_CStageID()) then
        
            if ((IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD)) or (GetUnitTypeId(udg_DES_Unit[Node]) == null)) then
                call DestroyEffect(AddSpecialEffectTarget(DES_CDeathEffect(), udg_DES_Unit[Node], DES_AttachmentPoint()))
                call DES_Recycle(Node)
                set TempInt = TempInt - 1
            else
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                
                if (udg_DES_Boolean1[Node] == false) then
                
                    if (DES_ProjectileHandler(Node)) then
                        set udg_DES_Boolean1[Node] = true
                        call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                        
                        loop
                            set u = FirstOfGroup(udg_DES_TempGroup)
                            exitwhen u == null
                            
                            if (DES_FriendlyTargetFilter(u, udg_DES_Player[Node])) then
                                call DestroyEffect(AddSpecialEffectTarget(DES_CImpactHealEffect(), u, DES_AttachmentPoint()))
                                call SetUnitState(u, UNIT_STATE_LIFE, GetUnitState(u, UNIT_STATE_LIFE) + udg_DES_Real3[Node])
                                call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) + udg_DES_Real4[Node])
                            endif
                            
                            call GroupRemoveUnit(udg_DES_TempGroup, u)
                        endloop
                        
                        set u = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, 0)
                        call SetUnitScale(u, DES_CImpactScaleBase() + (udg_DES_Real1[Node] * DES_CImpactScalePerPowerLevel()), 0., 0.)
                        call DestroyEffect(AddSpecialEffectTarget(DES_CImpactEffect(), u, DES_AttachmentPoint()))
                        call DestroyEffect(udg_DES_SecondaryEffect[Node])
                        
                        set udg_DES_Real2[Node] = DES_CPassiveHealAOEBase() + (udg_DES_Real1[Node] * DES_CPassiveHealAOEPerPowerLevel())
                        set udg_DES_Real3[Node] = DES_CPassiveHealHealthBase() + (udg_DES_Real1[Node] * DES_CPassiveHealHealthPerPowerLevel())
                        set udg_DES_Real4[Node] = DES_CPassiveHealManaBase() + (udg_DES_Real1[Node] * DES_CPassiveHealManaPerPowerLevel())
                        set udg_DES_Real5[Node] = DES_CPassiveDelayBase() + (udg_DES_Real1[Node] * DES_CPassiveDelayPerPowerLevel())
                        set udg_DES_Real6[Node] = udg_DES_Real5[Node]
                        
                        call UnitApplyTimedLife(u, DES_TimedLifeID(), DES_EffectExpirationTimer())
                        call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_CTimedLifeBase() * (udg_DES_Real1[Node] * DES_CTimedLifePerPowerLevel()))

                        set u = null
                        call DES_ComboCollisionDetection(x, y, Node)
                        
                    endif
                
                elseif (udg_DES_Real6[Node] <= 0) then
                    set udg_DES_Real6[Node] = udg_DES_Real5[Node]
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                    
                   loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_FriendlyTargetFilter(u, udg_DES_Player[Node])) then
                            call DestroyEffect(AddSpecialEffectTarget(DES_CHealEffect(), u, DES_AttachmentPoint()))
                            call SetUnitState(u, UNIT_STATE_LIFE, GetUnitState(u, UNIT_STATE_LIFE) + udg_DES_Real3[Node])
                            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) + udg_DES_Real4[Node])
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                    
                else
                    set udg_DES_Real6[Node] = udg_DES_Real6[Node] - DES_TimerSpeed()
                endif
                
            endif
        //Destruction Orbs
        elseif (udg_DES_StageID[Node] == DES_DStageID()) then
        
            if ((IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD)) or (GetUnitTypeId(udg_DES_Unit[Node]) == null)) then
                call DestroyEffect(AddSpecialEffectTarget(DES_DDeathEffect(), udg_DES_Unit[Node], DES_AttachmentPoint()))
                call DES_Recycle(Node)
                set TempInt = TempInt - 1
            else
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                
                if (udg_DES_Boolean1[Node] == false) then
                
                    if (DES_ProjectileHandler(Node)) then
                        set udg_DES_Boolean1[Node] = true
                        call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                    
                        loop
                            set u = FirstOfGroup(udg_DES_TempGroup)
                            exitwhen u == null
                            
                            if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                                call DestroyEffect(AddSpecialEffectTarget(DES_DImpactDamageEffect(), u, DES_AttachmentPoint()))
                                call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_DAttackType(), DES_DDamageType(), DES_DWeaponType())
                                call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real4[Node])
                            endif
                            
                            call GroupRemoveUnit(udg_DES_TempGroup, u)
                        endloop
                        
                        set u = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, 0)
                        call SetUnitScale(u, DES_DImpactScaleBase() + (udg_DES_Real1[Node] * DES_DImpactScalePerPowerLevel()), 0., 0.)
                        call DestroyEffect(AddSpecialEffectTarget(DES_DImpactEffect(), u, DES_AttachmentPoint()))
                        call DestroyEffect(udg_DES_SecondaryEffect[Node])
                        
                        set udg_DES_Real2[Node] = DES_DPassiveDamageAOEBase() + (udg_DES_Real1[Node] * DES_DPassiveDamageAOEPerPowerLevel())
                        set udg_DES_Real3[Node] = DES_DPassiveDamageHealthBase() + (udg_DES_Real1[Node] * DES_DPassiveDamageHealthPerPowerLevel())
                        set udg_DES_Real4[Node] = DES_DPassiveDamageManaBase() + (udg_DES_Real1[Node] * DES_DPassiveDamageManaPerPowerLevel())
                        set udg_DES_Real5[Node] = DES_DPassiveDelayBase() + (udg_DES_Real1[Node] * DES_DPassiveDelayPerPowerLevel())
                        set udg_DES_Real6[Node] = udg_DES_Real5[Node]
                        
                        call UnitApplyTimedLife(u, DES_TimedLifeID(), DES_EffectExpirationTimer())
                        call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_DTimedLifeBase() * (udg_DES_Real1[Node] * DES_DTimedLifePerPowerLevel()))
                    
                        set u = null
                        call DES_ComboCollisionDetection(x, y, Node)
                        
                    endif
                    
                elseif (udg_DES_Real6[Node] <= 0) then
                    set udg_DES_Real6[Node] = udg_DES_Real5[Node]
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                    
                   loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                            call DestroyEffect(AddSpecialEffectTarget(DES_DDamageEffect(), u, DES_AttachmentPoint()))
                            call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_DAttackType(), DES_DDamageType(), DES_DWeaponType())
                            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real4[Node])
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                    
                else
                    set udg_DES_Real6[Node] = udg_DES_Real6[Node] - DES_TimerSpeed()
                endif
            
            endif
        //Justice Orbs
        elseif (udg_DES_StageID[Node] == DES_JStageID()) then
            
            if (IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD)) or (GetUnitTypeId(udg_DES_Unit[Node]) == null) then
                call DestroyEffect(AddSpecialEffectTarget(DES_JDeathEffect(), udg_DES_Unit[Node], DES_AttachmentPoint()))
                call DES_SlowScan(Node)
                call DES_Recycle(Node)
                set TempInt = TempInt - 1
            else
            
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                
                loop
                    set u = FirstOfGroup(udg_DES_TempGroup)
                    exitwhen u == null
                    
                    if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                    
                        if (UnitAddAbility(u, DES_SlowID())) then
                            set TempNode = DES_CreateNode()
                            set udg_DES_Unit[TempNode] = u
                            set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
                            call SetUnitAbilityLevel(udg_DES_Unit[TempNode], DES_SlowID(), udg_DES_Integer2[Node])
                            set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_SlowEffect(), u, DES_AttachmentPoint())
                            set udg_DES_Integer1[TempNode] = Node
                            set udg_DES_Boolean1[TempNode] = false
                            set udg_DES_Boolean2[TempNode] = true
                            set udg_DES_Boolean3[TempNode] = false
                            set udg_DES_Boolean4[TempNode] = false
                            set udg_DES_StageID[TempNode] = DES_UnitStageID()
                        endif
                        
                    endif
                    
                    call GroupRemoveUnit(udg_DES_TempGroup, u)
                endloop
                
                if (udg_DES_Boolean3[Node] == true) then
                    
                    if (DES_ProjectileHandler(Node)) then
                        set udg_DES_Boolean3[Node] = false
                        call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_JTimedLifeBase() * (udg_DES_Real1[Node] * DES_JTimedLifePerPowerLevel()))
                        call DestroyEffect(udg_DES_SecondaryEffect[Node])
                    endif

                endif
            
            endif
            
        //Large Destruction Orbs
        elseif (udg_DES_StageID[Node] == DES_LargeDStageID()) then
        
            if (DES_ProjectileHandler(Node)) then
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                
                loop
                    set u = FirstOfGroup(udg_DES_TempGroup)
                    exitwhen u == null
                    
                    if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                        call DestroyEffect(AddSpecialEffectTarget(DES_DImpactDamageEffect(), u, DES_AttachmentPoint()))
                        call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_DAttackType(), DES_DDamageType(), DES_DWeaponType())
                        call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real4[Node])
                    endif
                    
                    call GroupRemoveUnit(udg_DES_TempGroup, u)
                endloop
                
                set z = DES_GetZ(x, y)
                loop
                    set iLoop = iLoop + 1
                    exitwhen iLoop > udg_DES_Integer1[Node]
                    set Angle = GetRandomReal(-bj_PI,bj_PI)
                    set TempReal = GetRandomReal(0, udg_DES_Real2[Node])
                    set x2 = x + TempReal * Cos(Angle)
                    set y2 = y + TempReal * Sin(Angle)
                    set z2 = DES_GetZ(x2 , y2)
                
                    set TempNode = DES_CreateNode()
                    set udg_DES_Real1[TempNode] = udg_DES_Real8[Node]
                    set udg_DES_Real2[TempNode] = DES_DImpactAOEBase() + (udg_DES_Real1[TempNode] * DES_DImpactAOEPerPowerLevel())
                    set udg_DES_Real3[TempNode] = DES_DImpactDamageHealthBase() + (udg_DES_Real1[TempNode] * DES_DImpactDamageHealthPerPowerLevel())
                    set udg_DES_Real4[TempNode] = DES_DImpactDamageManaBase() + (udg_DES_Real1[TempNode] * DES_DImpactDamageManaPerPowerLevel())
                    
                    if (DES_CTrueOrIncomingSpeed()) then
                        set udg_DES_Real5[TempNode] = DES_DTrueSpeedBase() + (udg_DES_Real1[TempNode] * DES_DTrueSpeedPerPowerLevel())
                    else
                        set udg_DES_Real5[TempNode] = TempReal / ((DES_DIncomingTimeBase() + (udg_DES_Real1[TempNode] * DES_DIncomingTimePerPowerLevel())) / DES_TimerSpeed())
                    endif
                    
                    set TempReal = TempReal / udg_DES_Real5[TempNode]
                    set udg_DES_Real6[TempNode] = udg_DES_Real5[TempNode] * Cos(Angle)
                    set udg_DES_Real7[TempNode] = udg_DES_Real5[TempNode] * Sin(Angle)
                    set udg_DES_Real5[TempNode] = ((z2 - z) + ((DES_Gravity() * (TempReal) * (TempReal)) / 2)) / TempReal
                    set udg_DES_Boolean1[TempNode] = false
                    set udg_DES_Boolean2[TempNode] = false
                    set udg_DES_Boolean3[TempNode] = false
                    set udg_DES_Boolean4[TempNode] = false
                    set udg_DES_StageID[TempNode] = DES_DStageID()
                    set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
                    set udg_DES_Core[TempNode] = udg_DES_Core[Node]
                    set udg_DES_Player[TempNode] = GetOwningPlayer(udg_DES_Caster[TempNode])
                
                    set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle * bj_RADTODEG)
                    set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_DOrbEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
                    set udg_DES_SecondaryEffect[TempNode] = AddSpecialEffectTarget(DES_DMoveEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
                    call SetUnitScale(udg_DES_Unit[TempNode], DES_DOrbScaleBase() + (udg_DES_Real1[TempNode] * DES_DOrbScalePerPowerLevel()), 0, 0)
                    
                    if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
                    endif

                endloop
                
                set u = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, 0)
                call SetUnitScale(u, DES_DImpactScaleBase() + (udg_DES_Real1[Node] * DES_DImpactScalePerPowerLevel()), 0., 0.)
                call DestroyEffect(AddSpecialEffectTarget(DES_DImpactEffect(), u, DES_AttachmentPoint()))
                call DestroyEffect(udg_DES_SecondaryEffect[Node])
                call DestroyEffect(udg_DES_CurrentEffect[Node])

                call UnitApplyTimedLife(u, DES_TimedLifeID(), DES_EffectExpirationTimer())
                call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_EffectExpirationTimer())
                call DES_Recycle(Node)
                set TempInt = TempInt - 1
                
                set u = null
            endif
            
        //Afflicted Units
        elseif (udg_DES_StageID[Node] == DES_UnitStageID()) then
        
            if (udg_DES_Boolean1[Node]) then
                
                if ((not(IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD)) and (not(GetUnitTypeId(udg_DES_Unit[Node]) == null)))) then
                    set udg_DES_Real7[Node] = udg_DES_Real7[Node] - DES_TimerSpeed()
                    call UnitAddAbility(udg_DES_Unit[Node], DES_BurnID())
                    
                    if (udg_DES_Real7[Node] > 0.00) then
                    
                        if (udg_DES_Real9[Node] <= 0.00) then
                            set udg_DES_Real9[Node] = udg_DES_Real8[Node]
                            call UnitDamageTarget(udg_DES_Caster[Node], udg_DES_Unit[Node], udg_DES_Real5[Node], false, false, DES_TrialAttackType(), DES_TrialDamageType(), DES_TrialWeaponType())
                            call SetUnitState(udg_DES_Unit[Node], UNIT_STATE_MANA, GetUnitState(udg_DES_Unit[Node], UNIT_STATE_MANA) - udg_DES_Real6[Node])
                        else
                            set udg_DES_Real9[Node] = udg_DES_Real9[Node] - DES_TimerSpeed()
                        endif
                        
                    else
                        call UnitRemoveAbility(udg_DES_Unit[Node], DES_BurnID())
                        call DestroyEffect(udg_DES_CurrentEffect[Node])
                        call DES_Recycle(Node)
                        set TempInt = TempInt - 1
                    endif
                    
                else
                    call DestroyEffect(udg_DES_CurrentEffect[Node])
                    call DestroyEffect(AddSpecialEffectTarget(DES_TrialExplodeEffect(), udg_DES_Unit[Node], DES_AttachmentPoint()))
                    call UnitRemoveAbility(udg_DES_Unit[Node], DES_BurnID())
                    set x = GetUnitX(udg_DES_Unit[Node])
                    set y = GetUnitY(udg_DES_Unit[Node])
                    
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                    
                    loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                            call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_TrialAttackType(), DES_TrialDamageType(), DES_TrialWeaponType())
                            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real4[Node])
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                    
                    call DES_Recycle(Node)
                    set TempInt = TempInt - 1
                endif
                
            elseif (udg_DES_Boolean2[Node]) then
            
                if (IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD) or (GetUnitTypeId(udg_DES_Unit[Node]) == null)) then
                    call UnitRemoveAbility(udg_DES_Unit[Node], DES_SlowID())
                    call DestroyEffect(udg_DES_CurrentEffect[Node])
                    call DES_Recycle(Node)
                    set TempInt = TempInt - 1
                else
                    set x = GetUnitX(udg_DES_Unit[Node])
                    set y = GetUnitY(udg_DES_Unit[Node])
                    set x2 = GetUnitX(udg_DES_Unit[udg_DES_Integer1[Node]])
                    set y2 = GetUnitY(udg_DES_Unit[udg_DES_Integer1[Node]])
                    set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
                    
                    if (TempReal > udg_DES_Real2[udg_DES_Integer1[Node]]) then
                        call UnitRemoveAbility(udg_DES_Unit[Node], DES_SlowID())
                        call DestroyEffect(udg_DES_CurrentEffect[Node])
                        call DES_Recycle(Node)
                        set TempInt = TempInt - 1
                    endif
                    
                endif
                
            elseif (udg_DES_Boolean3[Node]) then
            
                if (IsUnitType(udg_DES_Unit[Node], UNIT_TYPE_DEAD) or (GetUnitTypeId(udg_DES_Unit[Node]) == null)) then
                    call UnitRemoveAbility(udg_DES_Unit[Node], DES_CountdownID())
                    call DestroyEffect(udg_DES_CurrentEffect[Node])
                    call DES_Recycle(Node)
                    set TempInt = TempInt - 1
                else
                    set x = GetUnitX(udg_DES_Unit[Node])
                    set y = GetUnitY(udg_DES_Unit[Node])
                    set x2 = GetUnitX(udg_DES_Unit[udg_DES_Integer1[Node]])
                    set y2 = GetUnitY(udg_DES_Unit[udg_DES_Integer1[Node]])
                    set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
                    
                    if (TempReal > udg_DES_Real4[udg_DES_Integer1[Node]]) then
                        call UnitRemoveAbility(udg_DES_Unit[Node], DES_CountdownID())
                        call DestroyEffect(udg_DES_CurrentEffect[Node])
                        call DES_Recycle(Node)
                        set TempInt = TempInt - 1
                    endif
                    
                endif
                
            elseif (udg_DES_Boolean4[Node]) then
            
                if (DES_ProjectileHandler(Node)) then
                    set udg_DES_Boolean4[Node] = false
                    call DestroyEffect(udg_DES_CurrentEffect[Node])
                    call UnitDamageTarget(udg_DES_Caster[Node], udg_DES_Unit[Node], (DES_FallDamageMultiplyer() * (-udg_DES_Real5[Node])), false, false, DES_PAttackType(), DES_PDamageType(), DES_PWeaponType())
                    call SetUnitState(udg_DES_Unit[Node], UNIT_STATE_MANA, GetUnitState(udg_DES_Unit[Node], UNIT_STATE_MANA) - (DES_FallDamageMultiplyer * (-udg_DES_Real5[Node])))
                endif
                
            else
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                set udg_DES_Real6[Node] = udg_DES_Real6[Node] * DES_GroundDrag()
                set udg_DES_Real7[Node] = udg_DES_Real7[Node] * DES_GroundDrag()
                set TempReal = SquareRoot((udg_DES_Real6[Node] * udg_DES_Real6[Node]) + (udg_DES_Real7[Node] * udg_DES_Real7[Node]))
                
                if (TempReal <= DES_GroundDragStop()) then
                    call DES_Recycle(Node)
                    set TempInt = TempInt - 1
                elseif (DES_ValidateLocation(x, y)) then
                
                    if (DES_DestroyTrees()) then
                        call DES_GetTrees(x, y)
                    endif
                    
                    call SetUnitX(udg_DES_Unit[Node], x + udg_DES_Real6[Node])
                    call SetUnitY(udg_DES_Unit[Node], y + udg_DES_Real7[Node])
                endif
                
            endif
        //Ultimate
        elseif (udg_DES_StageID[Node] == DES_UltimateStageID()) then
        
            if (udg_DES_Integer1[Node] <= DES_UltimateDivineStormTypeID()) then
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                
                set udg_DES_Real12[Node] = udg_DES_Real12[Node] + udg_DES_Real9[Node]
                set TempInt2 = TempInt
                set TempNode = Node
                
                loop
                    set TempInt2 = TempInt2 + 1
                    exitwhen TempInt2 > udg_DES_AbilityCounter
                    set TempNode = udg_DES_NextNode[TempNode]
                    
                    if (udg_DES_Boolean2[TempNode] == true) and (udg_DES_Core[TempNode] == udg_DES_Unit[Node]) then
                        set Angle = (udg_DES_Real12[Node] + (DES_PSmallOrbAngleOffset() * udg_DES_StageID[TempNode])) * bj_DEGTORAD
                        call SetUnitX(udg_DES_Unit[TempNode], x + udg_DES_Real8[Node] * Cos(Angle))
                        call SetUnitY(udg_DES_Unit[TempNode], y + udg_DES_Real8[Node] * Sin(Angle))
                        
                        if (udg_DES_Integer1[Node] == DES_UltimateDivineStartTypeID()) then
                            call SetUnitFlyHeight(udg_DES_Unit[TempNode], GetUnitFlyHeight(udg_DES_Unit[TempNode]) + udg_DES_Real6[Node], 0.)
                        endif
                        
                    endif
                    
                    if (udg_DES_Integer1[Node] == DES_UltimateDivineStartTypeID()) and (udg_DES_Boolean4[TempNode] == true) and (udg_DES_Core[TempNode] == udg_DES_Unit[Node]) then
                        call SetUnitFlyHeight(udg_DES_Unit[TempNode], GetUnitFlyHeight(udg_DES_Unit[TempNode]) + udg_DES_Real3[Node], 0.)
                    endif
                    
                endloop
            endif
            
            if (udg_DES_Integer1[Node] == DES_UltimatePullingTypeID()) then
                set udg_DES_Real2[Node] = udg_DES_Real2[Node] - DES_TimerSpeed()
                set udg_DES_Real11[Node] = udg_DES_Real11[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real2[Node] > 0) then
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real1[Node], null)
                    
                    set TempInt2 = 0
                    set TempNode = 0
                    
                    loop
                        set TempInt2 = TempInt2 + 1
                        exitwhen TempInt2 > udg_DES_AbilityCounter
                        set TempNode = udg_DES_NextNode[TempNode]
                        
                        if (not(udg_DES_Core[TempNode] == udg_DES_Unit[Node])) and (udg_DES_StageID[TempNode] <= DES_JStageID()) and (udg_DES_Boolean1[TempNode] == true) and (udg_DES_Boolean3[TempNode] == false) and (udg_DES_Boolean4[TempNode] == false) and (GetUnitTypeId(udg_DES_Unit[Node]) == DES_DummyID()) then
                            
                            set x2 = GetUnitX(udg_DES_Unit[TempNode])
                            set y2 = GetUnitY(udg_DES_Unit[TempNode])
                            set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
                            
                            if (TempReal <= udg_DES_Real1[Node]) then
                            
                                set Angle = Atan2(y - y2, x - x2)
                                if (TempReal > udg_DES_Real8[Node]) then
                                    call SetUnitX(udg_DES_Unit[TempNode], x2 + udg_DES_Real7[Node] * Cos(Angle))
                                    call SetUnitY(udg_DES_Unit[TempNode], y2 + udg_DES_Real7[Node] * Sin(Angle))
                                    
                                    if (udg_DES_Boolean2[TempNode] == false) then
                                        set udg_DES_Boolean2[TempNode] = true
                                    endif
                                    
                                else
                                    call DestroyEffect(udg_DES_CurrentEffect[TempNode])
                                    call DestroyEffect(AddSpecialEffectTarget(DES_PAbsorbEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint()))
                                    call UnitApplyTimedLife(udg_DES_Unit[TempNode], DES_TimedLifeID(), DES_EffectExpirationTimer())
                                    
                                    if (udg_DES_StageID[TempNode] == DES_CStageID()) then
                                        set udg_DES_Real4[Node] = udg_DES_Real4[Node] + udg_DES_Real1[TempNode]
                                        
                                        if (udg_DES_Real4[Node] >= udg_DES_Real3[Node]) then
                                            set udg_DES_Real4[Node] = udg_DES_Real4[Node] - udg_DES_Real3[Node]
                                            call DES_AddOrb(Node, DES_CStageID(), x, y, udg_DES_Real13[Node] * udg_DES_Integer2[Node], Angle)
                                            set udg_DES_Integer2[Node] = udg_DES_Integer2[Node] + 1
                                        endif
                                        
                                    elseif (udg_DES_StageID[TempNode] == DES_DStageID()) then
                                        set udg_DES_Real5[Node] = udg_DES_Real5[Node] + udg_DES_Real1[TempNode]
                                        
                                        if (udg_DES_Real5[Node] >= udg_DES_Real3[Node]) then
                                            set udg_DES_Real5[Node] = udg_DES_Real5[Node] - udg_DES_Real3[Node]
                                            call DES_AddOrb(Node, DES_DStageID(), x, y, udg_DES_Real13[Node] * udg_DES_Integer3[Node], Angle)
                                            set udg_DES_Integer3[Node] = udg_DES_Integer3[Node] + 1
                                        endif
                                        
                                    else
                                        call DES_SlowScan(TempNode)
                                        set udg_DES_Real6[Node] = udg_DES_Real6[Node] + udg_DES_Real1[TempNode]
                                        
                                        if (udg_DES_Real6[Node] >= udg_DES_Real3[Node]) then
                                            set udg_DES_Real6[Node] = udg_DES_Real6[Node] - udg_DES_Real3[Node]
                                            call DES_AddOrb(Node, DES_JStageID(), x, y, udg_DES_Real13[Node] * udg_DES_Integer4[Node], Angle)
                                            set udg_DES_Integer4[Node] = udg_DES_Integer4[Node] + 1
                                        endif
                                        
                                    endif
                                    
                                    call DES_Recycle(TempNode)
                                    set TempInt = TempInt - 1
                                    set TempInt2 = TempInt2 - 1
                                endif
                                
                            endif
                            
                        endif
                        
                    endloop
                    
                    loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                            
                            if (udg_DES_Real11[Node] <= 0) then
                                call DestroyEffect(AddSpecialEffectTarget(DES_PPullEffect(), u, DES_AttachmentPoint()))
                            endif
                            
                            set x2 = GetUnitX(u)
                            set y2 = GetUnitY(u)
                            set Angle = Atan2(y - y2, x - x2)

                            if (DES_DestroyTrees()) then
                                call DES_GetTrees(x2, y2)
                            endif
                            
                            if (DES_ValidateLocation(x2, y2)) and (not(IsTerrainPathable(x2, y2, PATHING_TYPE_WALKABILITY))) then
                                call SetUnitX(u, x2 + udg_DES_Real7[Node] * Cos(Angle))
                                call SetUnitY(u, y2 + udg_DES_Real7[Node] * Sin(Angle))
                            endif
                            
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                    
                    if (udg_DES_Real11[Node] <= 0) then
                        set udg_DES_Real11[Node] = udg_DES_Real10[Node]
                    endif
                    
                else
                    
                    set TempInt2 = 0
                    set TempNode = 0
                    
                    loop
                        set TempInt2 = TempInt2 + 1
                        exitwhen TempInt2 > udg_DES_AbilityCounter
                        set TempNode = udg_DES_NextNode[TempNode]
                        if (not(udg_DES_Core[TempNode] == udg_DES_Unit[Node])) and (udg_DES_StageID[TempNode] <= DES_JStageID()) and (udg_DES_Boolean1[TempNode] == true) and (udg_DES_Boolean1[TempNode] == true) and (udg_DES_Boolean3[TempNode] == false) and (udg_DES_Boolean4[TempNode] == false) and (GetUnitTypeId(udg_DES_Unit[Node]) == DES_DummyID()) then
                            set x2 = GetUnitX(udg_DES_Unit[TempNode])
                            set y2 = GetUnitY(udg_DES_Unit[TempNode])
                            set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
                            
                            if (TempReal <= udg_DES_Real1[Node]) then
                                set udg_DES_Boolean2[TempNode] = false
                            endif
                            
                        endif
                        
                    endloop
                    
                    set udg_DES_Real1[Node] = udg_DES_Real3[Node] * udg_DES_Integer2[Node]
                    
                    if (udg_DES_Integer4[Node] == udg_DES_Integer3[Node]) and (udg_DES_Integer4[Node] == udg_DES_Integer2[Node]) then
                        set udg_DES_Integer1[Node] = DES_UltimateDivineStartTypeID()
                        set udg_DES_Real2[Node] = (DES_PDivineAscensionTimeBase() + (udg_DES_Real1[Node] * DES_PDivineAscensionTimePerPowerLevel()))
                        set udg_DES_Real3[Node] = (DES_PDivineHeightIncreaseBase() + (udg_DES_Real1[Node] * DES_PDivineHeightIncreasePerPowerLevel()))
                        set udg_DES_Real4[Node] = (DES_PDivineSmallOrbsOffsetIncreaseBase() + (udg_DES_Real1[Node] * DES_PDivineSmallOrbsOffsetIncreasePerPowerLevel())) / (udg_DES_Real2[Node] / DES_TimerSpeed())
                        set udg_DES_Real5[Node] = GetUnitFlyHeight(udg_DES_Unit[Node])
                        set udg_DES_Real6[Node] = (((udg_DES_Real3[Node] + udg_DES_Real5[Node]) - ((udg_DES_Integer2[Node] * udg_DES_Real13[Node]))) / 2.) / (udg_DES_Real2[Node] / DES_TimerSpeed())
                        set udg_DES_Real3[Node] = udg_DES_Real3[Node] / (udg_DES_Real2[Node] / DES_TimerSpeed())
                    else
                    
                        set udg_DES_Real2[Node] = udg_DES_Real3[Node] * udg_DES_Integer3[Node]
                        set udg_DES_Real3[Node] = udg_DES_Real3[Node] * udg_DES_Integer4[Node]
                        
                        if (udg_DES_Integer2[Node] > udg_DES_Integer3[Node]) then
                        
                            if (udg_DES_Integer2[Node] > udg_DES_Integer4[Node]) then
                                set udg_DES_Integer1[Node] = DES_UltimateWildTypeID()
                                set udg_DES_Real4[Node] = DES_PWildAOEBase() + (udg_DES_Real2[Node] * DES_PWildAOEPerPowerLevel())
                                set udg_DES_Real5[Node] = DES_PWildStartAOEBase() + (udg_DES_Real2[Node] * DES_PWildStartAOEPerPowerLevel())
                                set udg_DES_Real6[Node] = (udg_DES_Real4[Node] - udg_DES_Real5[Node]) / (DES_PWildExpandRingCountBase() + (udg_DES_Real2[Node] * DES_PWildExpandRingCountPerPowerLevel()))
                                set udg_DES_Real7[Node] = udg_DES_Real5[Node]
                                set udg_DES_Real10[Node] = DES_PWildTreantDurationBase() + (udg_DES_Real3[Node] * DES_PWildTreantDurationPerPowerLevel())
                                set udg_DES_Real11[Node] = DES_PWildTreantCountPerRingBase() + (udg_DES_Real1[Node] * DES_PWildTreantCountPerRingPerPowerLevel())
                                set udg_DES_Real1[Node] = DES_PWildTreantSpawnDelayBase() + (udg_DES_Real2[Node] * DES_PWildTreantSpawnDelayPerPowerLevel())
                                set udg_DES_Real13[Node] = udg_DES_Real1[Node]
                            else
                                call DES_UltimateCountStart(Node)
                            endif
                            
                        elseif (udg_DES_Integer3[Node] > udg_DES_Integer4[Node]) then
                            set udg_DES_Integer1[Node] = DES_UltimateArmaTypeID()
                            set udg_DES_Real4[Node] = DES_PArmaAOEBase() + (udg_DES_Real1[Node] * DES_PArmaAOEPerPowerLevel())
                            set udg_DES_Real5[Node] = DES_PArmaProjectilesPerSecondBase() + (udg_DES_Real2[Node] * DES_PArmaProjectilesPerSecondPerPowerLevel())
                            set udg_DES_Real6[Node] = DES_PArmaDurationBase() + (udg_DES_Real3[Node] * DES_PArmaDurationPerPowerLevel())
                            set udg_DES_Real7[Node] = (DES_PArmaLaunchDelayBase() + (udg_DES_Real2[Node] * DES_PArmaLaunchDelayPerPowerLevel()))
                            set udg_DES_Real10[Node] = udg_DES_Real5[Node] / (udg_DES_Real7[Node] / DES_TimerSpeed())
                            set udg_DES_Real11[Node] = udg_DES_Real7[Node]
                        else 
                            call DES_UltimateCountStart(Node)
                        endif
                    
                    endif
                    
                endif
                
            elseif (udg_DES_Integer1[Node] == DES_UltimateWildTypeID()) then
                
                if (udg_DES_Real13[Node] <= 0) then 
                
                    set udg_DES_Real13[Node] = udg_DES_Real1[Node]
                    set udg_DES_Real7[Node] = udg_DES_Real7[Node] + udg_DES_Real6[Node]
                    
                    if (udg_DES_Real7[Node] <= udg_DES_Real4[Node]) then

                        set iLoop = 0
                        set Angle = 0
                        set TempReal = (2 * bj_PI) / udg_DES_Real11[Node]
                        
                        loop
                            set iLoop = iLoop + 1
                            exitwhen iLoop > udg_DES_Real11[Node]
                            set Angle = Angle + TempReal
                            
                            set x2 = x + udg_DES_Real7[Node] * Cos(Angle)
                            set y2 = y + udg_DES_Real7[Node] * Sin(Angle)
                            
                            set u = CreateUnit(udg_DES_Player[Node], DES_TreantID(), x2, y2, Angle * bj_RADTODEG)
                            call DestroyEffect(AddSpecialEffectTarget(DES_PWildSpawnEffect(), u, DES_AttachmentPoint()))
                            call UnitApplyTimedLife(u, DES_TimedLifeID(), udg_DES_Real10[Node])
                        endloop
                        
                    else
                        call DES_EndUltimate(Node)
                        set TempInt = TempInt - 1
                    endif
                    
                else
                    set udg_DES_Real13[Node] = udg_DES_Real13[Node] - DES_TimerSpeed()
                endif

                
            elseif (udg_DES_Integer1[Node] == DES_UltimateArmaTypeID()) then
                set udg_DES_Real6[Node] = udg_DES_Real6[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real6[Node] > 0) then
                
                    if (udg_DES_Real11[Node] <= 0) then
                        set udg_DES_Real11[Node] = udg_DES_Real7[Node]
                        set iLoop = 0
                        set z = GetUnitFlyHeight(udg_DES_Unit[Node])
                        
                        loop
                            set iLoop = iLoop + 1
                            exitwhen iLoop >= udg_DES_Real10[Node]
                            
                            set TempReal = GetRandomReal(DES_PArmaMinAOE(), udg_DES_Real4[Node])
                            set Angle = GetRandomReal(-bj_PI, bj_PI)
                            set x2 = x + TempReal * Cos(Angle)
                            set y2 = y + TempReal * Sin(Angle)
                            set z2 = DES_GetZ(x2, y2)
                            
                            set TempNode = DES_CreateNode()
                            set udg_DES_Real2[TempNode] = DES_PArmaProjectileAOEBase() + (udg_DES_Real1[Node] * DES_PArmaProjectileAOEPerPowerLevel())
                            set udg_DES_Real3[TempNode] = DES_PArmaProjectileHealthDamageBase() + (udg_DES_Real3[Node] * DES_PArmaProjectileHealthDamagePerPowerLevel())
                            set udg_DES_Real4[TempNode] = DES_PArmaProjectileManaDamageBase() + (udg_DES_Real3[Node] * DES_PArmaProjectileManaDamagePerPowerLevel())
                        
                            if (DES_PArmaTrueOrIncomingSpeed()) then
                                set udg_DES_Real5[TempNode] = DES_PArmaTrueSpeedBase() + (udg_DES_Real1[Node] * DES_PArmaTrueSpeedPerPowerLevel())
                            else
                                set udg_DES_Real5[TempNode] = TempReal / ((DES_PArmaIncomingTimeBase() + (udg_DES_Real1[Node] * DES_PArmaIncomingTimePerPowerLevel())) / DES_TimerSpeed())
                            endif

                            set TempReal = TempReal / udg_DES_Real5[TempNode]
                            set udg_DES_Real6[TempNode] = udg_DES_Real5[TempNode] * Cos(Angle)
                            set udg_DES_Real7[TempNode] = udg_DES_Real5[TempNode] * Sin(Angle)
                            set udg_DES_Real5[TempNode] = ((z2 - z) + ((DES_Gravity() * (TempReal) * (TempReal)) / 2)) / TempReal
                            set udg_DES_Boolean1[TempNode] = false
                            set udg_DES_Boolean2[TempNode] = false
                            set udg_DES_Boolean3[TempNode] = false
                            set udg_DES_Boolean4[TempNode] = false
                            set udg_DES_StageID[TempNode] = DES_PProjectileStageID()
                            set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
                            set udg_DES_Core[TempNode] = udg_DES_Caster[Node]
                            set udg_DES_Player[TempNode] = GetOwningPlayer(udg_DES_Caster[TempNode])
                        
                            set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle * bj_RADTODEG)
                            set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_PArmaProjectileEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
                            set udg_DES_SecondaryEffect[TempNode] = AddSpecialEffectTarget(DES_PArmaProjectileMoveEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
                            call SetUnitScale(udg_DES_Unit[TempNode], DES_PArmaProjectileScale(), 0, 0)

                            if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
                            endif
                            
                            call SetUnitFlyHeight(udg_DES_Unit[TempNode], z, 0.)
                        endloop
                        
                    else
                        set udg_DES_Real11[Node] = udg_DES_Real11[Node] - DES_TimerSpeed()
                    endif
                    
                else
                    call DES_EndUltimate(Node)
                    set TempInt = TempInt - 1
                endif
                
            elseif (udg_DES_Integer1[Node] == DES_UltimateCountTypeID()) then
                set udg_DES_Real11[Node] = udg_DES_Real11[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real11[Node] > 0) then
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real4[Node], null)
                    
                    loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) or (DES_FriendlyTargetFilter(u, udg_DES_Player[Node])) then
                        
                            if (UnitAddAbility(u, DES_CountdownID())) then
                                set TempNode = DES_CreateNode()
                                set udg_DES_Unit[TempNode] = u
                                set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
                                set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_PCountEffect(), u, DES_AttachmentPoint())
                                set udg_DES_Integer1[TempNode] = Node
                                set udg_DES_Boolean1[TempNode] = false
                                set udg_DES_Boolean2[TempNode] = false
                                set udg_DES_Boolean3[TempNode] = true
                                set udg_DES_Boolean4[TempNode] = false
                                set udg_DES_StageID[TempNode] = DES_UnitStageID()
                            endif
                            
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                    
                else
                    set TempNode = 0
                    set TempInt2 = 0
                    
                    loop
                        set TempInt2 = TempInt2 + 1
                        exitwhen TempInt2 > udg_DES_AbilityCounter
                        set TempNode = udg_DES_NextNode[TempNode]
                        
                        if (udg_DES_Core[TempNode] == udg_DES_Unit[Node]) and (udg_DES_Boolean3[TempNode] == true) and (udg_DES_StageID[TempNode] == DES_UnitStageID()) then
                            call UnitRemoveAbility(udg_DES_Unit[TempNode], DES_CountdownID())
                            call DestroyEffect(udg_DES_CurrentEffect[TempNode])
                            
                            if (DES_EnemyTargetFilter(udg_DES_Unit[TempNode], udg_DES_Player[Node])) then
                                call DestroyEffect(AddSpecialEffectTarget(DES_PCountDamageEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint()))
                                call UnitDamageTarget(udg_DES_Caster[Node], udg_DES_Unit[TempNode], udg_DES_Real5[Node], false, false, DES_PAttackType(), DES_PDamageType(), DES_PWeaponType())
                                call SetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_MANA, GetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_MANA) - udg_DES_Real6[Node])
                            elseif (DES_FriendlyTargetFilter(udg_DES_Unit[TempNode], udg_DES_Player[Node])) then
                                call DestroyEffect(AddSpecialEffectTarget(DES_PCountHealEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint()))
                                call SetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_LIFE, GetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_LIFE) + udg_DES_Real7[Node])
                                call SetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_MANA, GetUnitState(udg_DES_Unit[TempNode], UNIT_STATE_MANA) + udg_DES_Real8[Node])
                            endif
                            
                            call DES_Recycle(TempNode)
                            set TempInt2 = TempInt2 - 1
                        endif
                        
                    endloop
                    
                    call DES_EndUltimate(Node)
                    set TempInt = TempInt - 1
                endif
                
            elseif (udg_DES_Integer1[Node] == DES_UltimateDivineStartTypeID()) then
                set udg_DES_Real2[Node] = udg_DES_Real2[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real2[Node] > 0) then
                    set udg_DES_Real5[Node] = udg_DES_Real5[Node] + udg_DES_Real3[Node]
                    set udg_DES_Real8[Node] = udg_DES_Real8[Node] + udg_DES_Real4[Node]
                    call SetUnitFlyHeight(udg_DES_Unit[Node], udg_DES_Real5[Node], 0.)
                else
                    set udg_DES_Integer1[Node] = DES_UltimateDivineStormTypeID()
                    set udg_DES_Real2[Node] = DES_PDivineStormAOEBase() + (udg_DES_Real1[Node] * DES_PDivineStormAOEPerPowerLevel())
                    set udg_DES_Real3[Node] = DES_PDivineStormAmountPerSecondBase() + (udg_DES_Real1[Node] * DES_PDivineStormAmountPerSecondPerPowerLevel())
                    set udg_DES_Real4[Node] = DES_PDivineStormDurationBase() + (udg_DES_Real1[Node] * DES_PDivineStormDurationPerPowerLevel())
                    set udg_DES_Real6[Node] = DES_PDivineStormHealthDamageBase() + (udg_DES_Real1[Node] * DES_PDivineStormHealthDamagePerPowerLevel())
                    set udg_DES_Real14[Node] = DES_PDivineStormManaDamageBase() + (udg_DES_Real1[Node] * DES_PDivineStormManaDamagePerPowerLevel())
                    set udg_DES_Real7[Node] = DES_PDivineStormHealthHealBase() + (udg_DES_Real1[Node] * DES_PDivineStormHealthHealPerPowerLevel())
                    set udg_DES_Real10[Node] = DES_PDivineStormManaHealBase() + (udg_DES_Real1[Node] * DES_PDivineStormManaHealPerPowerLevel())
                    set udg_DES_Real11[Node] = DES_PDivineStormDelayBase() + (udg_DES_Real1[Node] * DES_PDivineStormDelayPerPowerLevel())
                    set udg_DES_Real13[Node] = udg_DES_Real11[Node]
                    set udg_DES_Real15[Node] = DES_PDivineStormStrikeAOEBase() + (udg_DES_Real1[Node] * DES_PDivineStormStrikeAOEPerPowerLevel())
                    set udg_DES_Real16[Node] = DES_PDivineStormStrikeScaleBase() + (udg_DES_Real1[Node]* DES_PDivineStormStrikeScalePerPowerLevel())
                    set udg_DES_Real3[Node] = udg_DES_Real3[Node] * udg_DES_Real11[Node]
                endif
                
            elseif (udg_DES_Integer1[Node] == DES_UltimateDivineStormTypeID()) then
                set udg_DES_Real4[Node] = udg_DES_Real4[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real4[Node] > 0) then
                
                    if (udg_DES_Real13[Node] <= 0) then
                    
                        set udg_DES_Real13[Node] = udg_DES_Real11[Node]
                        set TempInt2 = 0
                    
                        loop
                            set TempInt2 = TempInt2 + 1
                            exitwhen TempInt2 > udg_DES_Real3[Node]
                            set Angle = GetRandomReal(-bj_PI, bj_PI)
                            set TempReal = GetRandomReal(0, udg_DES_Real2[Node])
                            set x2 = x + TempReal * Cos(Angle)
                            set y2 = y + TempReal * Sin(Angle)
                            set TempReal = GetRandomReal(0, DES_PDivineStormLightningOffset())
                            set z = x +  TempReal * Cos(Angle)
                            set z2 = y + TempReal * Sin(Angle)
                            
                            set TempNode = DES_CreateNode()
                            set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x2, y2, Angle * bj_RADTODEG)
                            call SetUnitScale(udg_DES_Unit[TempNode], udg_DES_Real16[Node],0, 0)
                            set udg_DES_Lightning[TempNode] = AddLightningEx(DES_LightningID(), true, z, z2, udg_DES_Real5[Node] + DES_GetZ(z, z2), x2, y2, 0)
                            call SetLightningColor(udg_DES_Lightning[TempNode], DES_LightningRed(), DES_LightningGreen(), DES_LightningBlue(), DES_LightningAlpha())
                            call DestroyEffect(AddSpecialEffectTarget(DES_PDivineStormStrikeEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint()))
                            call UnitApplyTimedLife(udg_DES_Unit[TempNode], DES_TimedLifeID(), DES_EffectExpirationTimer())
                            set udg_DES_Real1[TempNode] = udg_DES_Real11[Node] + DES_TimerSpeed()
                            set udg_DES_StageID[TempNode] = DES_UltimateStageID()
                            set udg_DES_Integer1[TempNode] = DES_UltimateDivineLightningTypeID()
                            
                            call GroupEnumUnitsInRange(udg_DES_TempGroup, x2, y2, udg_DES_Real15[Node], null)
                            
                            loop
                                set u = FirstOfGroup(udg_DES_TempGroup)
                                exitwhen u == null
                                
                                if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                                    call DestroyEffect(AddSpecialEffectTarget(DES_PDivineStormDamageEffect(), u, DES_AttachmentPoint()))
                                    call UnitDamageTarget(udg_DES_Unit[Node], u, udg_DES_Real6[Node], false, false, DES_PAttackType(), DES_PDamageType(), DES_PWeaponType())
                                    call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real14[Node])
                                elseif (DES_FriendlyTargetFilter(u, udg_DES_Player[Node])) then
                                    call DestroyEffect(AddSpecialEffectTarget(DES_PDivineStormHealEffect(), u, DES_AttachmentPoint()))
                                    call SetUnitState(u, UNIT_STATE_LIFE, GetUnitState(u, UNIT_STATE_LIFE) + udg_DES_Real7[Node])
                                    call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) + udg_DES_Real10[Node])
                                endif
                                
                                call GroupRemoveUnit(udg_DES_TempGroup, u)
                            endloop
                            
                        endloop
                        
                    else
                        set udg_DES_Real13[Node] = udg_DES_Real13[Node] - DES_TimerSpeed()
                    endif
                else
                    set TempNode = DES_CreateNode()
                    set udg_DES_Real1[TempNode] = DES_PDivineLaserAOEToScaleRatioBase() + (udg_DES_Real1[Node] * DES_PDivineLaserAOEToScaleRatioPerPowerLevel())
                    set udg_DES_Real2[TempNode] = DES_PDivineLaserStartScaleBase() + (udg_DES_Real1[Node] * DES_PDivineLaserStartScalePerPowerLevel())
                    set udg_DES_Real3[TempNode] = DES_PDivineLaserEndScaleBase() + (udg_DES_Real1[Node] * DES_PDivineLaserEndScalePerPowerLevel())
                    set udg_DES_Real4[TempNode] = DES_PDivineLaserHealthDamageBase() + (udg_DES_Real1[Node] * DES_PDivineLaserHealthDamagePerPowerLevel())
                    set udg_DES_Real5[TempNode] = DES_PDivineLaserManaDamageBase() + (udg_DES_Real1[Node] * DES_PDivineLaserManaDamagePerPowerLevel())
                    set udg_DES_Real6[TempNode] = DES_PDivineLaserHealthHealBase() + (udg_DES_Real1[Node] * DES_PDivineLaserHealthHealPerPowerLevel())
                    set udg_DES_Real7[TempNode] = DES_PDivineLaserManaHealBase() + (udg_DES_Real1[Node] * DES_PDivineLaserManaHealPerPowerLevel())
                    set udg_DES_Real8[TempNode] = DES_PDivineLaserKnockbackPowerBase() + (udg_DES_Real1[Node] * DES_PDivineLaserKnockbackPowerPerPowerLevel())
                    set udg_DES_Real9[TempNode] = DES_PDivineLaserKnockbackPowerCapBase() + (udg_DES_Real1[Node] * DES_PDivineLaserKnockbackPowerCapPerPowerLevel())
                    set udg_DES_Real10[TempNode] = (udg_DES_Real3[TempNode] - udg_DES_Real2[TempNode]) / ((DES_PDivineLaserTimerBase() + (udg_DES_Real1[Node] * DES_PDivineLaserTimerPerPowerLevel())) / DES_TimerSpeed())
                    set udg_DES_Boolean1[TempNode] = false
                    set udg_DES_Boolean2[TempNode] = false
                    set udg_DES_Boolean3[TempNode] = false
                    set udg_DES_Boolean4[TempNode] = true
                    set udg_DES_Integer1[TempNode] = DES_UltimateDivineLaserTypeID()
                    set udg_DES_Integer2[TempNode] = Node
                    set udg_DES_Integer3[TempNode] = 0
                    
                    set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, 0.)
                    set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
                    set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
                    set udg_DES_Player[TempNode] = udg_DES_Player[Node]
                    set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_PDivineLaserEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
                    
                    if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
                    endif
                            
                    call SetUnitFlyHeight(udg_DES_Unit[TempNode], udg_DES_Real5[Node], 0.)
                    call SetUnitScale(udg_DES_Unit[TempNode], -udg_DES_Real2[TempNode], 0., 0.)
                    
                    set udg_DES_StageID[TempNode] = DES_UltimateStageID()
                    set udg_DES_Integer1[Node] = DES_UltimateWaitingTypeID()
                endif
                
            elseif (udg_DES_Integer1[Node] == DES_UltimateDivineLaserTypeID()) then
                set udg_DES_Real2[Node] = udg_DES_Real2[Node] + udg_DES_Real10[Node]
                
                if (udg_DES_Real2[Node] < udg_DES_Real3[Node]) then
                    call SetUnitScale(udg_DES_Unit[Node], -udg_DES_Real2[Node], 0., 0.)
                    set x = GetUnitX(udg_DES_Unit[Node])
                    set y = GetUnitY(udg_DES_Unit[Node])
                    
                    call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node] * udg_DES_Real1[Node], null)
                    
                    loop
                        set u = FirstOfGroup(udg_DES_TempGroup)
                        exitwhen u == null
                        
                        if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                            call DestroyEffect(AddSpecialEffectTarget(DES_PDivineLaserDamageEffect(), u, DES_AttachmentPoint()))
                            call UnitDamageTarget(udg_DES_Unit[Node], u, udg_DES_Real4[Node], false, false, DES_PAttackType(), DES_PDamageType(), DES_PWeaponType())
                            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real5[Node])
                            
                            set x2 = GetUnitX(u)
                            set y2 = GetUnitY(u)
                            set Angle = Atan2((y2 - y), (x2 - x))
                            set TempReal = SquareRoot((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y))
                            
                            if (TempReal <= 0) then
                                set TempReal = udg_DES_Real9[Node]
                            else
                                set TempReal = udg_DES_Real8[Node] / TempReal
                                
                                if (TempReal >  udg_DES_Real9[Node]) then
                                    set TempReal = udg_DES_Real9[Node]
                                endif
                                
                            endif
                             
                            set TempNode = DES_CreateNode()
                            set udg_DES_Unit[TempNode] = u
                            set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_KnockbackEffect(), u, DES_AttachmentPoint())
                            
                            set udg_DES_Real5[TempNode] = TempReal * Sin(DES_PDivineLaserKnockbackAngle())
                            set udg_DES_Real6[TempNode] = TempReal * Cos(DES_PDivineLaserKnockbackAngle()) * Cos(Angle)
                            set udg_DES_Real7[TempNode] = TempReal * Cos(DES_PDivineLaserKnockbackAngle()) * Sin(Angle)
                            set udg_DES_Boolean1[TempNode] = false
                            set udg_DES_Boolean2[TempNode] = false
                            set udg_DES_Boolean3[TempNode] = false
                            set udg_DES_Boolean4[TempNode] = true
                            set udg_DES_StageID[TempNode] = DES_UnitStageID()
                            set udg_DES_Caster[TempNode] = udg_DES_Caster[Node]
                            set udg_DES_Core[TempNode] = udg_DES_Unit[TempNode]
                            
                            if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[Node], 'Amrf') then
                            endif
                            
                        elseif (DES_FriendlyTargetFilter(u, udg_DES_Player[Node])) then
                            call DestroyEffect(AddSpecialEffectTarget(DES_PDivineLaserHealEffect(), u, DES_AttachmentPoint()))
                            call SetUnitState(u, UNIT_STATE_LIFE, GetUnitState(u, UNIT_STATE_LIFE) + udg_DES_Real6[Node])
                            call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) + udg_DES_Real7[Node])
                        endif
                        
                        call GroupRemoveUnit(udg_DES_TempGroup, u)
                    endloop
                            
                else
                    set udg_DES_StageID[Node] = DES_RecycleStageID()
                    call DES_EndUltimate(udg_DES_Integer2[Node])
                    set TempInt = TempInt - 1
                endif
                
            else
                set udg_DES_Real1[Node] = udg_DES_Real1[Node] - DES_TimerSpeed()
                
                if (udg_DES_Real1[Node] <= 0) then
                    call DestroyLightning(udg_DES_Lightning[Node])
                    call DES_Recycle(Node)
                    set TempInt = TempInt - 1
                endif
                
            endif
            
        elseif (udg_DES_StageID[Node] == DES_PProjectileStageID()) then
            if (DES_ProjectileHandler(Node)) then
                set x = GetUnitX(udg_DES_Unit[Node])
                set y = GetUnitY(udg_DES_Unit[Node])
                call GroupEnumUnitsInRange(udg_DES_TempGroup, x, y, udg_DES_Real2[Node], null)
                
                loop
                    set u = FirstOfGroup(udg_DES_TempGroup)
                    exitwhen u == null
                    
                    if (DES_EnemyTargetFilter(u, udg_DES_Player[Node])) then
                        call DestroyEffect(AddSpecialEffectTarget(DES_PArmaDamageEffect(), u, DES_AttachmentPoint()))
                        call UnitDamageTarget(udg_DES_Caster[Node], u, udg_DES_Real3[Node], false, false, DES_PAttackType(), DES_PDamageType(), DES_PWeaponType())
                        call SetUnitState(u, UNIT_STATE_MANA, GetUnitState(u, UNIT_STATE_MANA) - udg_DES_Real4[Node])
                    endif
                    
                    call GroupRemoveUnit(udg_DES_TempGroup, u)
                endloop
                
                call DestroyEffect(udg_DES_CurrentEffect[Node])
                call DestroyEffect(udg_DES_SecondaryEffect[Node])
                
                call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_EffectExpirationTimer())
                
                call DES_Recycle(Node)
                set TempInt = TempInt - 1
            endif
        endif
        
    endloop
    
endfunction

////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////
function DES_OnCast takes nothing returns boolean

    //Sets up locals
    local unit u
    local integer Node
    local integer TempNode
    local integer iLevel
    local integer TempInt
    local integer TempInt2 = 0
    local real rLevel
    local real x
    local real x2
    local real x3
    local real y
    local real y2
    local real y3
    local real z
    local real z2
    local real AOE
    local real Angle = 0
    local real Angle2
    local real Divider
    local real TempReal = 0
    
    //Checks if the spell cast is the correct spell
    if (GetSpellAbilityId() == DES_CreationID()) then
        set u = GetTriggerUnit()
        set x = GetUnitX(u)
        set x2 = GetSpellTargetX()
        set y = GetUnitY(u)
        set y2 = GetSpellTargetY()
        set z = DES_GetZ(x, y) + GetUnitFlyHeight(u)
        set rLevel = I2R(GetUnitAbilityLevel(u, DES_CreationID()))
        set AOE = DES_CSpreadAOEBase() + (rLevel * DES_CSpreadAOEPerLevel())
        set Divider = (360 / (DES_COrbCountBase() + (rLevel * DES_COrbCountPerLevel())))
        
        loop
            set Angle = Angle + Divider
            exitwhen Angle > 360
            set Angle2 = Angle * bj_DEGTORAD
            set x3 = x2 + AOE * Cos(Angle2)
            set y3 = y2 + AOE * Sin(Angle2)
            set z2 = DES_GetZ(x3, y3) + DES_GroundHeightLet()
            set TempReal = SquareRoot(((x3 - x) * (x3 - x)) + ((y3 - y) * (y3 - y)))
            set Angle2 = Atan2(y3 - y, x3 - x)
            set Node = DES_CreateNode()
            set udg_DES_Real1[Node] = DES_CPowerLevelBase() + (rLevel * DES_CPowerLevelPerLevel())
            set udg_DES_Real2[Node] = DES_CImpactAOEBase() + (udg_DES_Real1[Node] * DES_CImpactAOEPerPowerLevel())
            set udg_DES_Real3[Node] = DES_CImpactHealHealthBase() + (udg_DES_Real1[Node] * DES_CImpactHealHealthPerPowerLevel())
            set udg_DES_Real4[Node] = DES_CImpactHealManaBase() + (udg_DES_Real1[Node] * DES_CImpactHealManaPerPowerLevel())
            
            if (DES_CTrueOrIncomingSpeed()) then
                set udg_DES_Real5[Node] = DES_CTrueSpeedBase() + (udg_DES_Real1[Node] * DES_CTrueSpeedPerPowerLevel())
            else
                set udg_DES_Real5[Node] = TempReal / ((DES_CIncomingTimeBase() + (udg_DES_Real1[Node] * DES_CIncomingTimePerPowerLevel())) / DES_TimerSpeed())
            endif
            
            set udg_DES_Unit[Node] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle2 * bj_RADTODEG)
            
            if (TempReal == 0.) then
                set udg_DES_Boolean1[Node] = true
                call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_CTimedLifeBase() * (udg_DES_Real1[Node] * DES_CTimedLifePerPowerLevel()))
            else
                set TempReal = TempReal / udg_DES_Real5[Node]
                set udg_DES_Real6[Node] = udg_DES_Real5[Node] * Cos(Angle2)
                set udg_DES_Real7[Node] = udg_DES_Real5[Node] * Sin(Angle2)
                set udg_DES_Real5[Node] = ((z2 - z) + ((DES_Gravity() * (TempReal) * (TempReal)) / 2)) / TempReal
                set udg_DES_Boolean1[Node] = false
                set udg_DES_SecondaryEffect[Node] = AddSpecialEffectTarget(DES_CMoveEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
            endif
            
            set udg_DES_Boolean2[Node] = false
            set udg_DES_Boolean3[Node] = false
            set udg_DES_Boolean4[Node] = false
            set udg_DES_StageID[Node] = DES_CStageID()
            set udg_DES_Caster[Node] = u
            set udg_DES_Core[Node] = udg_DES_Unit[Node]
            set udg_DES_Player[Node] = GetOwningPlayer(u)
            
            set udg_DES_CurrentEffect[Node] = AddSpecialEffectTarget(DES_COrbEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
            call SetUnitScale(udg_DES_Unit[Node], DES_COrbScaleBase() + (udg_DES_Real1[Node] * DES_COrbScalePerPowerLevel()), 0, 0)
            
            if UnitAddAbility(udg_DES_Unit[Node], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[Node], 'Amrf') then
            endif

            if (udg_DES_AbilityCounter == 1) then
                call TimerStart(udg_DES_Timer, DES_TimerSpeed(), true, function DES_Loop)
            endif

        endloop

        set u = null
    elseif (GetSpellAbilityId() == DES_DestructionID()) then
        set u = GetTriggerUnit()
        set x = GetUnitX(u)
        set x2 = GetSpellTargetX()
        set y = GetUnitY(u)
        set y2 = GetSpellTargetY()   
        set z = DES_GetZ(x, y) + GetUnitFlyHeight(u)
        set z2 = DES_GetZ(x2, y2) + DES_GroundHeightLet()
        set iLevel = GetUnitAbilityLevel(u, DES_DestructionID())
        set rLevel = I2R(iLevel)
        set TempReal = SquareRoot(((x2 - x) * (x2 - x)) + ((y2 - y) * (y2 - y)))
        set Angle = Atan2(y2 - y, x2 - x)
        
        set Node = DES_CreateNode()
        set udg_DES_Real8[Node] = DES_DPowerLevelBase() + (rLevel * DES_DPowerLevelPerLevel())
        set udg_DES_Real1[Node] = (udg_DES_Real8[Node]) * (DES_LargeDPowerLevelMultiplyerBase() + (rLevel * DES_LargeDPowerLevelMultiplyerPerLevel()))
        set udg_DES_Real2[Node] = DES_DImpactAOEBase() + (udg_DES_Real1[Node] * DES_DImpactAOEPerPowerLevel())
        set udg_DES_Real3[Node] = DES_DImpactDamageHealthBase() + (udg_DES_Real1[Node] * DES_DImpactDamageHealthPerPowerLevel())
        set udg_DES_Real4[Node] = DES_DImpactDamageManaBase() + (udg_DES_Real1[Node] * DES_DImpactDamageManaPerPowerLevel())
        
        if (DES_DTrueOrIncomingSpeed()) then
            set udg_DES_Real5[Node] = DES_DTrueSpeedBase() + (udg_DES_Real1[Node] * DES_DTrueSpeedPerPowerLevel())
        else
            set udg_DES_Real5[Node] = TempReal / ((DES_DIncomingTimeBase() + (udg_DES_Real1[Node] * DES_DIncomingTimePerPowerLevel())) / DES_TimerSpeed())
        endif
        
        set TempReal = TempReal / udg_DES_Real5[Node]
        set udg_DES_Real6[Node] = udg_DES_Real5[Node] * Cos(Angle)
        set udg_DES_Real7[Node] = udg_DES_Real5[Node] * Sin(Angle)
        
        if (TempReal == 0.) then
            set udg_DES_Real5[Node] = 0
        else
            set udg_DES_Real5[Node] = ((z2 - z) + ((DES_Gravity() * (TempReal) * (TempReal)) / 2)) / TempReal
        endif
        
        set udg_DES_Integer1[Node] = DES_DOrbCountBase() + (iLevel * DES_DOrbCountPerLevel())
        set udg_DES_Boolean1[Node] = false
        set udg_DES_Boolean2[Node] = false
        set udg_DES_Boolean3[Node] = false
        set udg_DES_Boolean4[Node] = false
        set udg_DES_StageID[Node] = DES_LargeDStageID()
        set udg_DES_Caster[Node] = u
        set udg_DES_Player[Node] = GetOwningPlayer(u)
    
        set udg_DES_Unit[Node] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle * bj_RADTODEG)
        set udg_DES_Core[Node] = udg_DES_Unit[Node]
        set udg_DES_CurrentEffect[Node] = AddSpecialEffectTarget(DES_DOrbEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
        set udg_DES_SecondaryEffect[Node] = AddSpecialEffectTarget(DES_DMoveEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
        call SetUnitScale(udg_DES_Unit[Node], DES_DOrbScaleBase() + (udg_DES_Real1[Node] * DES_DOrbScalePerPowerLevel()), 0, 0)
        
        if UnitAddAbility(udg_DES_Unit[Node], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[Node], 'Amrf') then
        endif

        if (udg_DES_AbilityCounter == 1) then
            call TimerStart(udg_DES_Timer, DES_TimerSpeed(), true, function DES_Loop)
        endif
        
        set u = null
    elseif (GetSpellAbilityId() == DES_JusticeID()) then
        set u = GetTriggerUnit()
        set x = GetUnitX(u)
        set x2 = GetSpellTargetX()
        set y = GetUnitY(u)
        set y2 = GetSpellTargetY()  
        set iLevel = GetUnitAbilityLevel(u, DES_JusticeID())
        set rLevel = I2R(iLevel)
        
        set TempReal = (DES_JAngleAreaBase() + (rLevel * DES_JAngleAreaPerLevel()))
        set Angle = Atan2((y2 - y) , (x2 - x)) * bj_RADTODEG - (TempReal / 2)
        set Divider = TempReal / (DES_JOrbCountBase() + (rLevel * DES_JOrbCountPerLevel()))
        set TempReal = Angle + TempReal
        
        loop
            set Angle = Angle + Divider
            exitwhen Angle > TempReal
            set Angle2 = Angle * bj_DEGTORAD
            set Node = DES_CreateNode()
            set udg_DES_Real1[Node] = DES_JPowerLevelBase() + (rLevel * DES_JPowerLevelPerLevel())
            set udg_DES_Real2[Node] = DES_JDamageAOEBase() + (udg_DES_Real1[Node] * DES_JDamageAOEPerPowerLevel())
            set udg_DES_Real3[Node] = DES_JDamageHealthBase() + (udg_DES_Real1[Node] * DES_JDamageHealthPerPowerLevel())
            set udg_DES_Real4[Node] = DES_JDamageManaBase() + (udg_DES_Real1[Node] * DES_JDamageManaPerPowerLevel())
            set udg_DES_Real5[Node] = SquareRoot(((x2 - x) * (x2 - x)) + ((y2 - y) * (y2 - y)))
            
            if (DES_JTrueOrIncomingSpeed()) then
                set udg_DES_Real8[Node] = DES_JTrueSpeedBase() + (udg_DES_Real1[Node] * DES_JTrueSpeedPerPowerLevel())
            else
                set udg_DES_Real8[Node] = udg_DES_Real5[Node] / ((DES_JIncomingTimeBase() + (udg_DES_Real1[Node] * DES_JIncomingTimePerPowerLevel())) / DES_TimerSpeed())
            endif
            
            set udg_DES_Unit[Node] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle)
            
            if (udg_DES_Real5[Node] == 0.) then
                set udg_DES_Boolean3[Node] = false
                call UnitApplyTimedLife(udg_DES_Unit[Node], DES_TimedLifeID(), DES_JTimedLifeBase() * (udg_DES_Real1[Node] * DES_JTimedLifePerPowerLevel()))
            else
                set udg_DES_Real6[Node] = udg_DES_Real8[Node] * Cos(Angle2)
                set udg_DES_Real7[Node] = udg_DES_Real8[Node] * Sin(Angle2)
                set udg_DES_Real9[Node] = DES_JDamageManaburnRatioBase() + (udg_DES_Real1[Node] * DES_JDamageManaburnRatioPerPowerLevel())
                set udg_DES_Real10[Node] = DES_JDamageDelayBase() + (udg_DES_Real1[Node] * DES_JDamageDelayPerPowerLevel())
                set udg_DES_Real11[Node] = udg_DES_Real10[Node]
                set udg_DES_Boolean3[Node] = true
                set udg_DES_SecondaryEffect[Node] = AddSpecialEffectTarget(DES_JMoveEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
            endif
            
            set udg_DES_Boolean1[Node] = true
            set udg_DES_Boolean2[Node] = false
            set udg_DES_Boolean4[Node] = false
            set udg_DES_Integer2[Node] = iLevel
            set udg_DES_StageID[Node] = DES_JStageID()
            set udg_DES_Caster[Node] = u
            set udg_DES_Core[Node] = udg_DES_Unit[Node]
            set udg_DES_Player[Node] = GetOwningPlayer(u)
            set udg_DES_CurrentEffect[Node] = AddSpecialEffectTarget(DES_JOrbEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
            call SetUnitScale(udg_DES_Unit[Node], DES_JOrbScaleBase() + (udg_DES_Real1[Node] * DES_JOrbScalePerPowerLevel()), 0, 0)
            
            if UnitAddAbility(udg_DES_Unit[Node], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[Node], 'Amrf') then
            endif

            if (udg_DES_AbilityCounter == 1) then
                call TimerStart(udg_DES_Timer, DES_TimerSpeed(), true, function DES_Loop)
            endif
            
        endloop
        
        set u = null
    elseif (GetSpellAbilityId() == DES_PillarID()) then
        set u = GetTriggerUnit()
        set x = GetSpellTargetX()
        set y = GetSpellTargetY()   
        set iLevel = GetUnitAbilityLevel(u, DES_PillarID())
        set rLevel = I2R(iLevel)
        
        set Node = DES_CreateNode()
        set udg_DES_Real1[Node] = DES_PPullAOEBase() + (rLevel * DES_PPullAOEPerLevel())
        set udg_DES_Real2[Node] = DES_PPullDurationBase() + (rLevel * DES_PPullDurationPerLevel())
        set udg_DES_Real3[Node] = DES_PPowerForOrbBase() + (rLevel * DES_PPowerForOrbPerLevel())
        set udg_DES_Real4[Node] = DES_PCreationStartingPowerBase() + (rLevel * DES_PCreationStartingPowerPerLevel())
        set udg_DES_Real5[Node] = DES_PDestructionStartingPowerBase() + (rLevel * DES_PDestructionStartingPowerPerLevel())
        set udg_DES_Real6[Node] = DES_PJusticeStartingPowerBase() + (rLevel * DES_PJusticeStartingPowerPerLevel())
        set udg_DES_Real7[Node] = (DES_PPullStrengthBase() + (rLevel * DES_PPullStrengthPerLevel())) * DES_TimerSpeed()
        set udg_DES_Real8[Node] = DES_PSmallOrbOffsetBase() + (rLevel * DES_PSmallOrbOffsetPerLevel())
        
        if (DES_PSpinTrueOrIncomingSpeed()) then
            set udg_DES_Real9[Node] = DES_POrbTrueSpinSpeedBase() + (rLevel * DES_POrbTrueSpinSpeedPerLevel())
        else
            set udg_DES_Real9[Node] = 360. / ((DES_POrbSpinIncomingTimeBase() + (rLevel * DES_POrbSpinIncomingTimePerLevel())) / DES_TimerSpeed())
        endif
        
        set udg_DES_Real10[Node] = DES_PPullEffectDelayBase() + (rLevel * DES_PPullEffectDelayPerLevel())
        set udg_DES_Real11[Node] = udg_DES_Real10[Node]
        set udg_DES_Real12[Node] = 0.
        set udg_DES_Real13[Node] = DES_PSmallOrbsHeightOffsetBase() + (udg_DES_Real3[Node] * DES_PSmallOrbsHeightOffsetPerPowerLevel())
        set udg_DES_Boolean1[Node] = false
        set udg_DES_Boolean2[Node] = false
        set udg_DES_Boolean3[Node] = false
        set udg_DES_Boolean4[Node] = true
        
        set udg_DES_StageID[Node] = DES_UltimateStageID()
        set udg_DES_Integer1[Node] = DES_UltimatePullingTypeID()
        set udg_DES_Caster[Node] = u
        set udg_DES_Player[Node] = GetOwningPlayer(u)
        set z = DES_POrbHeightOffsetBase() + (rLevel * DES_POrbHeightOffsetPerLevel()) + DES_PBoarderHeightOffsetAlter()
        
        set udg_DES_Unit[Node] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle)
        set udg_DES_Core[Node] = udg_DES_Unit[Node]
        set udg_DES_CurrentEffect[Node] = AddSpecialEffectTarget(DES_POrbEffect(), udg_DES_Unit[Node], DES_AttachmentPoint())
        call SetUnitScale(udg_DES_Unit[Node], DES_POrbScaleBase() + (rLevel * DES_POrbScalePerLevel()), 0, 0)
        
        if UnitAddAbility(udg_DES_Unit[Node], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[Node], 'Amrf') then
        endif
        
        call SetUnitFlyHeight(udg_DES_Unit[Node], z - DES_PBoarderHeightOffsetAlter(), 0.)
        call DestroyEffect(AddSpecialEffectTarget(DES_PSpawnEffect(), udg_DES_Unit[Node], DES_AttachmentPoint()))
        
        if (udg_DES_AbilityCounter == 1) then
            call TimerStart(udg_DES_Timer, DES_TimerSpeed(), true, function DES_Loop)
        endif
        
        set AOE = DES_PBoarderOffsetBase() + (rLevel * DES_PBoarderOffsetPerLevel())
        set Divider = (360. / (DES_PBoarderCountBase() + (rLevel * DES_PBoarderCountPerLevel())))
        loop
            set Angle = Angle + Divider
            exitwhen Angle > 360.
            set Angle2 = Angle * bj_DEGTORAD
            
            set TempNode = DES_CreateNode()
            set udg_DES_Boolean1[TempNode] = false
            set udg_DES_Boolean2[TempNode] = false
            set udg_DES_Boolean3[TempNode] = true
            set udg_DES_Boolean4[TempNode] = true
            set udg_DES_StageID[TempNode] = DES_RecycleStageID()
            set udg_DES_Caster[TempNode] = u
            set udg_DES_Core[TempNode] = udg_DES_Unit[Node]
            set udg_DES_Unit[TempNode] = CreateUnit(DES_DummyPlayer(), DES_DummyID(), x, y, Angle)
            set udg_DES_CurrentEffect[TempNode] = AddSpecialEffectTarget(DES_PBoarderEffect(), udg_DES_Unit[TempNode], DES_AttachmentPoint())
            call SetUnitScale(udg_DES_Unit[TempNode], DES_PBoarderScaleBase() + (rLevel * DES_PBoarderScalePerLevel()), 0, 0)
            
            if UnitAddAbility(udg_DES_Unit[TempNode], 'Amrf') and UnitRemoveAbility(udg_DES_Unit[TempNode], 'Amrf') then
            endif
            
            call SetUnitFlyHeight(udg_DES_Unit[TempNode], z, 0.)    
        endloop
        
        set z2 = 0
        set udg_DES_Integer2[Node] = R2I(udg_DES_Real4[Node] / udg_DES_Real3[Node])
        set Divider = DES_PSmallOrbAngleOffset()
        set Angle = Divider
        set Angle2 = Angle * bj_DEGTORAD
        
        loop
            set TempInt2 = TempInt2 + 1
            exitwhen TempInt2 > udg_DES_Integer2[Node]
            set TempReal = TempReal + z
            
            call DES_AddOrb(Node, DES_CStageID(), x, y, z2, Angle2)
            
            set z2 = z2 + udg_DES_Real13[Node]
        endloop
        
        set z2 = 0
        set TempInt2 = 0
        set udg_DES_Integer3[Node] = R2I(udg_DES_Real5[Node] / udg_DES_Real3[Node])
        set Angle = Angle + Divider
        set Angle2 = Angle * bj_DEGTORAD
        loop
            set TempInt2 = TempInt2 + 1
            exitwhen TempInt2 > udg_DES_Integer3[Node]
            set TempReal = TempReal + z
            
            call DES_AddOrb(Node, DES_DStageID(), x, y, z2, Angle2)
            
            set z2 = z2 + udg_DES_Real13[Node]
        endloop
        
        set z2 = 0
        set TempInt2 = 0 
        set udg_DES_Integer4[Node] = R2I(udg_DES_Real6[Node] / udg_DES_Real3[Node])
        set Angle = (Angle + Divider) * bj_DEGTORAD
        
        loop
            set TempInt2 = TempInt2 + 1
            exitwhen TempInt2 > udg_DES_Integer4[Node]
            set TempReal = TempReal + z
            
            call DES_AddOrb(Node, DES_JStageID(), x, y, z2, Angle)
            
            set z2 = z2 + udg_DES_Real13[Node]
        endloop
        
        set udg_DES_Real4[Node] = 0.
        set udg_DES_Real5[Node] = 0.
        set udg_DES_Real6[Node] = 0.
        
        set u = null
    endif
    
    return false
endfunction

////////////////////////////////////////////////////////////////////
//  Initialisation trigger, applies the conditions to triggers    //
//  and sets up the global location used to get location Z's      //
////////////////////////////////////////////////////////////////////
function InitTrig_Divine_Envoy_Spellset takes nothing returns nothing
    //Set up locals
    local trigger DE = CreateTrigger()
    local integer index = 0

    //Set up hero casting triggers
    loop
        //Applies the even to each player in turn
        call TriggerRegisterPlayerUnitEvent(DE, Player(index), EVENT_PLAYER_UNIT_SPELL_EFFECT, null)
        set index = index + 1
        exitwhen index == bj_MAX_PLAYER_SLOTS
    endloop

    //Applies the function to check for each spell to the trigger
    call TriggerAddCondition(DE, Condition(function DES_OnCast))

    //Set up the location used to find Z heights
    set udg_DES_Loc = Location(0,0)
    set udg_DES_Timer = CreateTimer()
    
    set udg_DES_TreeChecker = CreateUnit(DES_DummyPlayer(), DES_TreeCheckerID(), 0, 0 , 0)
    set udg_DES_MapMaxX = GetRectMaxX(bj_mapInitialPlayableArea)
    set udg_DES_MapMinX = GetRectMinX(bj_mapInitialPlayableArea)
    set udg_DES_MapMaxY = GetRectMaxY(bj_mapInitialPlayableArea)
    set udg_DES_MapMinY = GetRectMinY(bj_mapInitialPlayableArea)

endfunction
////////////////////////////////////////////////////////////////////
// End of the spellset                                            //
////////////////////////////////////////////////////////////////////

*Code isn't necessarily fully optimised

 

[Cokemonkey11]

I give you an F for using plain JASS. God damn that's fugly.

 

[Tank-Commander]

Haha yeah, it's certainly not easy on the eyes - though I like being able to have it in Vanilla WE, even if it costs my sanity with navigating it XD

 

[Cokemonkey11]

You honestly didn't use a script to generate any of it? I count 384 constant functions

 

[Almia]

WIP dee doo

 

[Tank-Commander]

You honestly didn't use a script to generate any of it? I count 384 constant functions

I can assure you I wrote it all manually - spent many hours scrolling up and down to add configurables (hence why their arrangement is very messy). the only thing I didn't do was manually count them - just used the lines (1563 - 23) / 4 = 385

but yeah, I've done nothing in my spare time since monday (and sunday night) except work on the code
Wake up -> School -> Code -> Sleep -> Repeat
hence why I've managed to get it done at this point

 

[Kyrbi0]

I can assure you I wrote it all manually - ...
but yeah, I've done nothing in my spare time since monday (and sunday night) except work on the code
Wake up -> School -> Code -> Sleep -> Repeat

...

 

[Tank-Commander]

Entry Post

[TD]Divine Envoy Spellset[/TD]

Combo Explanation (Not part of the set)

When two Divine Orbs come into contact their stored power is released and combined resulting in an extra effect based on which types of Orb collided. The strength of the effect is increased the more power released

Creation + Destruction: Cycle of Life - Nearby enemies are damaged, a percentage of the total damage dealt is then restored to allies
Creation + Justice: Equaliser - All units in the nearby area have their mana drained, then their hitpoints are added up and divided equally among them
Destruction + Justice: Trial by Fire - Nearby enemy units are set on fire taking damage over time. If a unit dies when on fire additional damage is dealt to nearby enemies

Orbs of Creation

Q Orbs of Creation
Launches Orbs of Creation with stored power at the target area, healing allies upon landing and continuing to passively heal every 2 seconds

Level 1 - 3 Orbs, 2.00 Stored power, 20.00 Active heal, 6.00 Passive heal, lasts 6 seconds
Level 2 - 6 Orbs, 2.50 Stored power, 22.50 Active heal, 7.00 Passive heal, lasts 7 seconds
Level 3 - 9 Orbs, 3.00 Stored power, 25.00 Active heal, 8.00 Passive heal, lasts 8 seconds

Orbs of Destruction

W Orbs of Destruction
Launches Orbs of Destruction with stored power at the target area, damaging enemies upon landing and continuing to passively damage every 2 seconds

Level 1 - 5 Orbs, 2.00 Stored power, 20.00 Active damage, 9.00 Passive damage, lasts 6 seconds
Level 2 - 7 Orbs, 2.50 Stored power, 22.50 Active damage, 10.00 Passive damage, lasts 7 seconds
Level 3 - 9 Orbs, 3.00 Stored power, 25.00 Active damage, 11.00 Passive damage, lasts 8 seconds

Orbs of Justice

E Orbs of Justice
Launches Orbs of Justice with stored power at the target area in a cone, damaging and mana burning enemies they pass through and continuing to passively slow enemy units after they stop. a percentage of the mana destroyed is converted to health damage

Level 1 - 3 Orbs, 2.00 Stored power, 40% Slow, 24.00 Health damage, 24.00 Mana damage, 90% Convertion rate, lasts 6 seconds
Level 2 - 6 Orbs, 2.50 Stored power, 60% Slow, 25.00 Health damage, 25.00 Mana damage, 100% Convertion rate, lasts 7 seconds
Level 3 - 9 Orbs, 3.00 Stored power, 80% Slow, 26.00 Health damage, 26.00 Mana damage, 110% Convertion rate, lasts 8 seconds

Pillars of Judgement

R Pillars of Judgement
Calls down from the heavens Pillars of Judgement which pull nearby Orbs and enemies into them, collecting the power stored within. 10 seconds later a new effect activates based on which pillar collected the most power.

Creation: Wild Growth - Treants spawn rapidly around the pillars spreading across a large area, each treant lasting for a short duration
Destruction: Armageddon - Flames decimate the area around the pillars dealing heavy damage to enemies caught within the flames
Justice: Countdown - Nearby units are marked, after a short delay all marked enemies take damage and all marked allies are healed
Equilibrium: Divine Envoy - The pillars rise before striking the ground repeadetly with lightning dealing huge damage to enemies and healing allies. Judgement is then delivered as a beam of light dealing massive damage and blasting enemies back

Show

Different amounts of each Orb in the Pillar affects the attributes of whichever Ultimate is running (except Divine Envoy as all pillars are equal anyway when that runs, and thus all things are affected by the one attribute), this information is not included in the tooltip in order to prevent it becoming oversized and can also be considered a "hidden" feature for players to figure out or told externally (in example: a training level of a campaign)

Wild Growth:
- Effect of Orbs of Creation: Increases the amount of treants spawned
- Effect of Orbs of Destruction: Increases the total AOE of the ring spreading
- Effect of Orbs of Justice: Increases the duration of the timed lives

Armageddon:
- Effect of Orbs of Creation: Increases the AOE of each projectile
- Effect of Orbs of Destruction: Increases the amount of Projectiles launched by the pillar (attempts to entirely cover the area)
- Effects of Orbs of Justice: Increases the amount of damage each projectile deals

Countdown:
- Effect of Orbs of Creation: Decreases the Timer until the effect goes off
- Effect of Orbs of Destruction: Increases the Damage/Healing dealt by the ability
- Effect of Orbs of Justice: Increases the AOE of the ability

Click to view

Too big for this post

- 4601 Lines of pure JASS
- Has an extensive Readme
- Can be imported into the vanilla WE
- None of the abilities interfere with the game scorescreens (increasing player's "units created" values)
- 11 Abilities included in the set (the initial stage of the ultimate is an ability)
- 387 configurables (that's a hell of a lot)
- Very High synergy
- Difficult to master, easy to learn
- Correctly arcs over uneven terrain
- Functions for ground and flying heros
- Most aspects of the abilities can be removed or added due to the configuration making them highly adaptable spells
- Designed to be attractive yet functional
- Correctly ignores magic immunes
- Easy-to-reach target filters for players who want to change what is and is not acceptable as a target
- 3D knockback
- Optional Tree destruction
- Only 48 variables to import for all 11 abilities
- Efficiently designed to reuse array variables whenever possible
- Serves as an entire hero set
- Can have the abilities distributed across many units and still functions (Orbs interact so long as they're owned by the same player)
- Abilities of different levels interact differently (different power levels) than two abilities of the same level
- Buffs for all status conditions (slows, burns, coundown)
- All buffs can serve as slows (based off slow aura)
- Mr Fluffy the flying test Hero is back

Basic Abilities

- If the ability is using Incoming Time, Orbs of Justice does increased damage to singular enemies the shorter the range of the entire ability while not being cast at the point of the caster, where as if not the damage density is consistent, and thus most benefit is in using it at longer range
- If both Orbs of Creation and Destruction are using Incoming Time, then with a bit of luck, you can combo Orbs of Justice at the moment of impact for Orbs of Destruction giving your opponents less time to react, this is also a way of comboing even when the ultimate is pulling in Orbs (the same applies to Orbs of Creation, except that it is more predictable and does not require luck)
- It is technically possible to Combo Orbs of Creation and Destruction at their moment of impact, but this requires precise timing of launching and a bit of luck
- In a battle, try to get Orbs of creation to line up against the battle line or slightly into the enemies side, this means the counteract the effect the enemies will need to move further back to get out of the range of healing giving you more free hits
- In a battle due to Orbs of Destruction's unpredictability the only garunteed hit during battle is the initial big Orb, as such it makes sense to launch it at the priority Target
- Orbs of Destruction's damage has a higher density around the intiial casting point (due to the nature of how they spread out)
- The effects of Orbs of Destruction and Orbs of Creation Stack, while the effect of Orbs of Justice does not, making them generally more useful in extended combat (except for combo abilities)
- In individual conflicts, it typically makes sense to use only two of the three abilities if you lack the skill to properly control the combos, as you can easily get an unhelpful combo effect (Equaliser in particular when you're winning is very unhelpful)
- The most efficient method of using all 3 abilities while avoiding using equaliser during combat while utilising the other effects, is to use Orbs of Creation furthest away, Orbs of Desutruction on the boarder of Orbs of Creation and Orbs of Justice just shy of Orbs of Creation (so that they do not combo). This should be positioned on the battleline for most efficient usage, however is still one of the most inefficient ways of using each of the abilities independantly, conversely: If you flank the enemy units with the Hero first and then do this, it is one of the most efficient ways of using each of the abilities independantly but is unsafe for that Hero.

Combo Abilities

- Orbs of Judgement are by far easiest to set up combination attacks due to their sweeping nature, Orbs of Creation are second easiest, and Orbs of Destruction are hardest, it's recommended to use the abilities in the order of easiest to set up for the combination effects (i.e. always use Orbs of Destruction first if it is in the combination) Additionally, the slowing effect of Orbs of Judgement are helpful for keeping enemies within the target AOE for Equaliser and Trial by fire.
- Equaliser is hugely effective against low amounts of enemies with high HP when you are using large amounts of low HP units as it will heal them and take a higher chunk of the enemies health away, the more they have.
- Equaliser is also useful against full HP enemy armies without affecting your units if the enemy army has a couple of high HP units as it will pull them down before the battle even begins.
- Trial by Fire is hugely effective against high amounts of enemies with low HP as they are more likely to die when on fire and cause a chain reaction killing all enemies affected by it.
- Setting up an Equaliser to be quickly followed up by a Cycle of life can quickly turn around a situation - when losing a battle equaliser will heal your units putting you on an even plain and Cycle of life will push you ahead, be careful not to get this the wrong way around though as you may remove your advantage. This is also a great way to start a battle, if your army was already damaged.
- When low on Mana focussing usage on Cycle of Life is more effecient as Orbs of Judgement are less effective for damaging purposes (unless at melee range) and are more situational
- Leading a conflict with Trial by Fire is typically the best move as it does the highest amount of damage with Orbs of Justice aimed far back to move them out of the way as well as containing the enemy units, creating a space closer to the Hero which can be used to set up Cycle of Life (naturally if you want Orbs of Justice based combos, pulling them into the combo area is going to be a better idea)

Ultimate

- When using the ultimate always consider what effect you want/need in the situation as well as how many orbs of each type you will have available and their respective power levels, getting it wrong can result in a waste of the ultimate
- Using Orbs of Judgement on enemy units while the Ultimate is pulling them in is helpful as it makes it more difficult for them to escape the AOE (once they are within the effect area the pillar's own Orbs of Justice will slow them)
- Countdown is helpful in and out of combat as in pressing situations it is more difficult/risky to stay within the radius for the healing effect, using it during a peaceful moment can heal up an entire army (using only Orbs of Justice to increase AOE and Orbs of Destruction to increase the amount healed)
- During Countdown, using Orbs of Judgement to slow enemies helps you keep them within the radius to take the damage. (as opposed to before, as the pillar will potentially have pulled those orbs in and only effect those closest to the pillar) By the same merit, it is also helpful for setting up Wild Growth and Armaggedon depending on the type of usage of them you are attempting to achieve
- Consider the desired AOE when using Wild Growth, a small AOE gives a very high concentration of Treants which can be very helpful at the immediate area, and a high AOE puts them over a much wider area, more useful for surrounding and body blocking bigger groups of enemies
- Armageddon's effectiveness depends largely on the size of the enemy army - a large army scattered across the area will take more damage from a higher AOE, lower Damage Armageddon while a small army, close to the ultimate takes much more damage from a High damage, low AOE armageddon as the AOE effects how far the projectiles spread out and thus their damage distribution.
- Divine Envoy is by far the strongest form of the ultimate with higher reward for each unit of power placed into it, but requires a large amount of mana generally to use it effectively and can cause accidental combos when trying to set up which can result in the player failing to set it up correctly and getting one of the other effects.
- If you're trying to set up the ultimate, you should avoid creating combination abilities - attempt to keep things efficient but the order of casting should be reversed, with Orbs of judgement being cast first in order to minimise combos. It is also suggested to potentially waste an ability just to put more orbs on the battlefield before using the ultimate
- Launching abilities directly into the centre of the ultimate can quickly add the orbs to the stacks, this is particularly helpful when there is not much time left for gathering with the ultimate.

- Variable Creator: Copy and paste into your map, you now have all the variables needed for the spell to run

Variable Creator

• Variable Creator
  • Events
  • Conditions
  • Actions
    • Set DES_AbilityCounter = 0
    • Set DES_Boolean1[0] = False
    • Set DES_Boolean2[0] = False
    • Set DES_Boolean3[0] = False
    • Set DES_Boolean4[0] = False
    • Set DES_Caster[0] = DES_Caster[0]
    • Set DES_Core[0] = DES_Core[0]
    • Set DES_CurrentEffect[0] = DES_CurrentEffect[0]
    • Set DES_Integer1[0] = 0
    • Set DES_Integer2[0] = 0
    • Set DES_Integer3[0] = 0
    • Set DES_Integer4[0] = 0
    • Set DES_LastNode = 0
    • Set DES_Lightning[0] = DES_Lightning[0]
    • Set DES_Loc = DES_Loc
    • Set DES_MapMaxX = 0.00
    • Set DES_MapMaxY = 0.00
    • Set DES_MapMinX = 0.00
    • Set DES_MapMinY = 0.00
    • Set DES_NextNode[0] = 0
    • Set DES_NodeNumber = 0
    • Set DES_Player[0] = DES_Player[0]
    • Set DES_PrevNode[0] = 0
    • Set DES_Real1[0] = 0.00
    • Set DES_Real10[0] = 0.00
    • Set DES_Real11[0] = 0.00
    • Set DES_Real12[0] = 0.00
    • Set DES_Real13[0] = 0.00
    • Set DES_Real14[0] = 0.00
    • Set DES_Real15[0] = 0.00
    • Set DES_Real16[0] = 0.00
    • Set DES_Real2[0] = 0.00
    • Set DES_Real3[0] = 0.00
    • Set DES_Real4[0] = 0.00
    • Set DES_Real5[0] = 0.00
    • Set DES_Real6[0] = 0.00
    • Set DES_Real7[0] = 0.00
    • Set DES_Real8[0] = 0.00
    • Set DES_Real9[0] = 0.00
    • Set DES_RecyclableNodes = 0
    • Set DES_RecycleNodes[0] = 0
    • Set DES_SecondaryEffect[0] = DES_SecondaryEffect[0]
    • Set DES_StageID[0] = 0
    • Set DES_TempGroup = DES_TempGroup
    • Set DES_TempGroup2 = DES_TempGroup2
    • Set DES_Timer = DES_Timer
    • Set DES_TreeChecker = DES_TreeChecker
    • Set DES_Unit[0] = DES_Unit[0]

http://www.hiveworkshop.com/forums/2641647-post62.html
http://www.hiveworkshop.com/forums/2642095-post71.html
http://www.hiveworkshop.com/forums/2642506-post74.html
http://www.hiveworkshop.com/forums/2642914-post77.html
http://www.hiveworkshop.com/forums/2643240-post80.html
http://www.hiveworkshop.com/forums/2643526-post84.html
http://www.hiveworkshop.com/forums/2643992-post87.html

Orbs of Creation

Orbs of Destruction

Orbs of Justice

Cycle of Life

Equiliser

Trial by Fire

Pillars of Judgement

Wild Growth

Armageddon

Countdown

Divine Envoy

Other

Tooltip

GIF

Cast

Active Heal

Passive Heal

Tooltip

GIF

Cast

Mid

End

Active Damage

Passive Damage

Tooltip

GIF

Cast

Damage

Slow

GIF

Image

GIF

Image

GIF

Activate

Burning & Explode

Tooltip

Start

Gather

Absorb

GIF

Effect

GIF

Start

Running

GIF

Start

End

GIF

Storm

Laser

Combo Explanations Tooltip

Terrain Demonstration Cliff

Terrain Demonstration Hill

Flying Terrain Demonstration

Combo Command Card

[tr]

 

[Empirean]

hey guys i cant join the contest. good luck with all contestants.

 

[Kazeon]

I think I will judge this instead. Currently I'm intrigued to work on something else.

 

[Tank-Commander]

Just a notice: I'll be moving my Code to another post (or possibly pastebin) when I've finished documenting it as I exceed the post character limit if I try to put it in the entry post

 

[Zeatherann]

This is a contest for second place, also; good job on not using vJASS! I would join but I don't have any idea on what to do that would even have a chance of placing hehe. I guess this allows me to work on MineralZ more. Hey Tank-Commander; I'm assuming that you created your own orbiting projectile library as you seem very fond of using them for everything! I wonder what my fps would be if I ran twelve copies of those spells at once.

 

[Tank-Commander]

Well, 12 Divine Envoys would probably tank your PC without changing its config to be more "Normal ability" and less "ultimate", 12 countdowns would run with very little framerate loss in any, Armageddon would be like Divine Envoy and Wild Growth would be like Countdown so I'd say not too bad for a designed-to-be-ultimate. Though don't go saying I've won yet: we all know what happened last time when people got in that mindset XD

Note to Dal: I can't make my map name fit the criteria for naming because my username is too long, can I leave it as-is or turn it into a very weird acronym?

 

[Kazeon]

You could shorten your name to Ta-Co