- Joined
- Oct 12, 2011
- Messages
- 3,449
Let's use GMT time. 
Documentation includes:What exactly is spell documentation? Trigger comments? Text file? The description box above every trigger? Explaining each variable, loop and spell logic?
For single unit only.Or I can design 4 spells that will be used by 4 different units?
You want to make ability for tower defense, eh? But for melee or AoS, it's up to you, doesn't affect your score.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.
No, just a simple demo map with any elements needed for testing (vary terrains, units, heroes, destructables, etc.)Do I also have to make the map? Or just add random enemy units getting killed/damaged/healed/what not?
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)...Dalvengyr said: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.
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.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
Review the updated main post (You'll see it's been expanded to include other forms as well)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.
Isn't that however, intentionally perverting the objectivity we /do/ have by increasing the sway subjectivity holds on the resultsKybri0 said: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.
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.Kybri0 said:For two, it's only 5 points; nothing major.
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)Kybri0 said: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?
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?
Meh, here's mine
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.
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
And there goes again for Tank,the guy who loves eyegasms
Nice visual doesn't mean bloated special effects. Overloading your spell with effects will decrease your points.
Added ^^ Thanks for reminding.Which brings me to the next point, the poll:judges ratio isn't stated anywhere.
I haven't made any progress since the last 3 days.At this rate I'll be done before somebody posts a WIP
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
////////////////////////////////////////////////////////////////////
// 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 //
////////////////////////////////////////////////////////////////////
constant function
sYou honestly didn't use a script to generate any of it? I count 384constant function
s
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
Tooltips
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
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
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
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
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
Ultimate Dependencies
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
Spellset Information
- 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
Tips and Tricks
- 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.
- 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)
- 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.
Helpful Files
- Variable Creator: Copy and paste into your map, you now have all the variables needed for the spell to run
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]
WIP Links
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
Images
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
![]()
![]()
![]()
![]()
![]()