/*************************************
*
* AtomicBomb
* v3.1.0.1
* By Magtheridon96
*
* - Creates a bombing plane behind the caster
* that will drop an atomic bomb dealing damage
* to enemy units in an area of effect. Deals
* bonus damage to closer units.
*
* Requires:
* ---------
*
* - CTL by Nestharus
* - hiveworkshop.com/forums/jass-resources-412/snippet-constant-timer-loop-32-a-201381/
* - SpellEffectEvent by Bribe
* - hiveworkshop.com/forums/jass-resources-412/snippet-spelleffectevent-187193/
* - Particle by Nestharus
* - hiveworkshop.com/forums/submissions-414/snippet-needs-work-particle-206279/
*
* Optional:
* ---------
*
* - TimerUtils by Vexorian (This also caters to my version of TimerUtils in the Hive Jass section Graveyard)
* - wc3c.net/showthread.php?t=101322
*
* Importing:
* ----------
*
* - Copy this code to a new trigger.
* - Make sure you have all the requirements implemented too.
* - Go the object editor and copy/paste the objects to your map (1 ability, 2 dummy units).
* - There is also an object called Particle that you need which is part of the Particle library.
* - Import the special effect and dummy.mdl to your map.
* - Configure the data in the globals to your liking.
* - Done!
*
* Credits:
* --------
*
* - WILL THE ALMIGHTY (Explosion Effect)
* - Bribe (SpellEffectEvent, Table)
* - Nestharus (CTL, Particle)
* - Vexorian (TimerUtils)
*
*************************************/
library AtomicBomb requires CTL, SpellEffectEvent, Particle, optional TimerUtils
// Configuration
globals
// The ability raw code
private constant integer ABIL_CODE = 'A000'
// The plane dummy unit raw code
private constant integer PLANE_CODE = 'h003'
// The bomb dummy unit raw code
private constant integer BOMB_CODE = 'h001'
// Explosion Effect
private constant string EXPLOSION_EFFECT = "war3mapImported\\NuclearExplosion.mdx"
// The effect that is created when the plane is created.
private constant string PLANE_IN_EFFECT = "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
// The effect that is created when the plane is destroyed.
private constant string PLANE_OUT_EFFECT = "Abilities\\Spells\\Items\\TomeOfRetraining\\TomeOfRetrainingCaster.mdl"
// How much time should we wait before destroying the explosion effect?
private constant real DESTROY_EXPLOSION_AFTER = 15.
// How much time should we wait before destroying the effect created when the plane is created?
private constant real DESTROY_IN_EFFECT_PARTICLE_AFTER = 1.4
// How much time should we wait before destroying the effect created when the plane is destroyed?
private constant real DESTROY_OUT_EFFECT_PARTICLE_AFTER = 1.4
// Bomb and Plane height
private constant real BOMB_HEIGHT = 700.
// Bomb Drop Speed Base (It will accelerate starting from this base-speed)
private constant real BOMB_DROP_SPEED = 1.
// Bomb Drop Acceleration
private constant real BOMB_DROP_ACCEL = 1.
// The dummy owning player
private constant player DUMMY_OWNER = Player(13)
// Destroy trees around the explosion?
private constant boolean DESTROY_TREES = true
// The offset from the point from the target point for plane creation
private constant real PLANE_DISTANCE = 800.
// How long does the plane stay after it drops the bomb?
private constant real PLANE_AFTER_DROP = 2.
// Attack type
private constant attacktype ATTACK_TYPE = ATTACK_TYPE_NORMAL
// Damage type
private constant damagetype DAMAGE_TYPE = DAMAGE_TYPE_MAGIC
// The largest collision a unit has in your map
private constant real MAX_COLLISION = 197.
endglobals
// End Configuration
// The speed of the plane per 1/32th of a second
private function GetPlaneSpeedFactor takes integer level returns real
return 9.
endfunction
// The damage dealed to each unit
private function GetDamage takes integer level returns real
return 150 + level * 75.
endfunction
// The damage radius
private function GetDamageRadius takes integer level returns real
return 275 + level * 75.
endfunction
// How close do units have to be for the spell to deal bonus damage?
private function GetBonusDamageRadius takes integer level returns real
return 125 + level * 50.
endfunction
// I want the spell to deal double the damage to units closer than the bonus damage radius.
private function GetBonusDamageFactor takes integer level returns real
return 1.3
endfunction
// This function will filter out some targets (Allied, dead, magic immune and structures)
private function TargetFilter takes player owner, unit caster, unit target returns boolean
return IsUnitEnemy(target, owner) and not (IsUnitType(target, UNIT_TYPE_MAGIC_IMMUNE) or IsUnitType(target, UNIT_TYPE_STRUCTURE) or IsUnitType(target, UNIT_TYPE_DEAD) or GetUnitTypeId(target) == 0)
endfunction
private struct Spell extends array
private static group enumGroup = CreateGroup()
private static unit array caster
private static unit array plane
private static unit array bomb
private static real array xDis
private static real array yDis
private static real array planeX
private static real array planeY
private static real array dropX
private static real array dropY
private static real array damage
private static real array radius
private static real array bonusDamage
private static real array bonusRadius
private static real array speed
private static real array height
private static integer array counter
private static integer array level
private static boolean array dropped
private static boolean array exploded
private static player array owner
static if DESTROY_TREES then
private static rect treeRect = null
private static unit treeDetector = null
private static real treesRadius = 0
private static real treesX = 0
private static real treesY = 0
private static method isTree takes destructable d returns boolean
return IssueTargetOrderById(treeDetector, 852018, d) and IssueImmediateOrderById(treeDetector, 851972)
endmethod
private static method destroyTree takes nothing returns nothing
local destructable d = GetEnumDestructable()
local real x = GetWidgetX(d) - treesX
local real y = GetWidgetY(d) - treesY
// If the destructable is a tree and it is in the circle, kill it
if x*x+y*y <= treesRadius and isTree(d) then
call KillDestructable(d)
endif
set d = null
endmethod
endif
// You don't need a Table or a hashtable if you have TimerUtils
static if not LIBRARY_TimerUtils then
private static Table timerData
endif
// I want to murder this function
private static method destroyParticle takes nothing returns nothing
static if LIBRARY_TimerUtilsEx then
call Particle(ReleaseTimer(GetExpiredTimer())).destroy()
elseif LIBRARY_TimerUtils then
call Particle(GetTimerData(GetExpiredTimer())).destroy()
call ReleaseTimer(GetExpiredTimer())
else
call Particle(timerData[GetHandleId(GetExpiredTimer())]).destroy()
call DestroyTimer(GetExpiredTimer())
endif
endmethod
implement CTL
local timer t
local unit u
local real x
local real y
implement CTLExpire
// Set the planeX and planeY coordinates
set planeX[this] = planeX[this] + xDis[this]
set planeY[this] = planeY[this] + yDis[this]
// Moving the plane out of the map bounds would crash the game, so we should make sure the coordinates are sound.
if planeX[this] <= WorldBounds.maxX or planeX[this] >= WorldBounds.minX or planeY[this] <= WorldBounds.maxY or planeY[this] >= WorldBounds.minY then
// Move the plane
call SetUnitX(plane[this], planeX[this])
call SetUnitY(plane[this], planeY[this])
endif
// If the bomb has been dropped
if dropped[this] then
// If the bomb exploded
if exploded[this] then
// Counter-based checking
set counter[this] = counter[this] - 1
if counter[this] == 0 then
// Destroy the current instance of the spell
call this.destroy()
// Remove the plane
call RemoveUnit(plane[this])
// Timer Utils is optional :3
// This is a pretty ugly way of creating a special effect with a Z-coordinate.
static if LIBRARY_TimerUtils then
call TimerStart(NewTimerEx(Particle.createEx(Player(13), planeX[this], planeY[this], BOMB_HEIGHT, 0, 0, 1, 255, 255, 255, 255, PLANE_OUT_EFFECT, 0)), DESTROY_OUT_EFFECT_PARTICLE_AFTER, false, function thistype.destroyParticle)
else
set t = CreateTimer()
set timerData[GetHandleId(t)] = Particle.createEx(Player(13), planeX[this], planeY[this], BOMB_HEIGHT, 0, 0, 1, 255, 255, 255, 255, PLANE_OUT_EFFECT, 0)
call TimerStart(t, DESTROY_OUT_EFFECT_PARTICLE_AFTER, false, function thistype.destroyParticle)
set t = null
endif
// Null variables
set caster[this] = null
set plane[this] = null
set bomb[this] = null
set owner[this] = null
endif
else
// If the height of the bomb is close to 0
if height[this] <= 5 then
// Destroy the bomb and create the explosion
call RemoveUnit(bomb[this])
static if LIBRARY_TimerUtils then
call TimerStart(NewTimerEx(Particle.createEx(Player(13), dropX[this], dropY[this], 0, 0, 0, 1, 255, 255, 255, 255, EXPLOSION_EFFECT, 0)), DESTROY_EXPLOSION_AFTER, false, function thistype.destroyParticle)
else
set t = CreateTimer()
set timerData[GetHandleId(t)] = Particle.createEx(Player(13), dropX[this], dropY[this], 0, 0, 0, 1, 255, 255, 255, 255, EXPLOSION_EFFECT, 0)
call TimerStart(t, DESTROY_EXPLOSION_AFTER, false, function thistype.destroyParticle)
set t = null
endif
// Loop through all units in the area
call GroupEnumUnitsInRange(enumGroup, dropX[this], dropY[this], radius[this] + MAX_COLLISION, null)
loop
set u = FirstOfGroup(enumGroup)
exitwhen u == null
call GroupRemoveUnit(enumGroup, u)
// Check if the target unit passes the filter and make sure he's in the blast radius.
if TargetFilter(owner[this], caster[this], u) and IsUnitInRangeXY(u, dropX[this], dropY[this], radius[this]) then
set x = GetUnitX(u) - dropX[this]
set y = GetUnitY(u) - dropY[this]
// If the unit is closer than the bonusRange
if x*x+y*y <= bonusRadius[this] then
// We deal the bonus damage
call UnitDamageTarget(caster[this], u, bonusDamage[this], false, false, ATTACK_TYPE, DAMAGE_TYPE, null)
else
// Else, we deal the normal damage
call UnitDamageTarget(caster[this], u, damage[this], false, false, ATTACK_TYPE, DAMAGE_TYPE, null)
endif
endif
endloop
static if DESTROY_TREES then
call SetRect(treeRect, dropX[this] - radius[this], dropY[this] - radius[this], dropX[this] + radius[this], dropY[this] + radius[this])
// Cache tree destroy data
set treesRadius = radius[this]*radius[this]
set treesX = dropX[this]
set treesY = dropY[this]
// Enumerate through all destructables in the rect
call EnumDestructablesInRect(treeRect, null, function thistype.destroyTree)
endif
// The counter is now going to be used to determine
// the number of iterations before the spell ends.
set counter[this] = R2I(PLANE_AFTER_DROP * 32)
set exploded[this] = true
else
// Decrease the bomb's height a bit
set height[this] = height[this] - speed[this]
call SetUnitFlyHeight(bomb[this], height[this], 0)
// Accelerate drop speed
set speed[this] = speed[this] + BOMB_DROP_ACCEL
endif
endif
else
// Decrease the counter by 1
set counter[this] = counter[this] - 1
// When the counter is 0, the plane has reached it's destination.
if counter[this] == 0 then
// Store the dropX and dropY coordinates
set dropX[this] = planeX[this]
set dropY[this] = planeY[this]
// Create the bomb under the plane
set bomb[this] = CreateUnit(DUMMY_OWNER, BOMB_CODE, dropX[this], dropY[this], 0)
// Set the bomb's height
call UnitAddAbility(bomb[this], 'Amrf')
call UnitRemoveAbility(bomb[this], 'Amrf')
call SetUnitFlyHeight(bomb[this], BOMB_HEIGHT, 0)
// We have dropped the bomb
set dropped[this] = true
// Set the bomb height and the bomb drop speed
set height[this] = BOMB_HEIGHT
set speed[this] = BOMB_DROP_SPEED
endif
endif
implement CTLNull
set u = null
implement CTLEnd
private static method run takes nothing returns nothing
local thistype this = create()
local real x = GetSpellTargetX()
local real y = GetSpellTargetY()
local real a
local real s
local real cos
local real sin
local timer t
// Set the caster and the owner and the level of the ability
set caster[this] = GetTriggerUnit()
set owner[this] = GetTriggerPlayer()
set level[this] = GetUnitAbilityLevel(caster[this], ABIL_CODE)
// Cache angle data
set a = Atan2(y - GetUnitY(caster[this]), x - GetUnitX(caster[this]))
set cos = Cos(a)
set sin = Sin(a)
// Set the plane coordinates
set planeX[this] = x - PLANE_DISTANCE * cos
set planeY[this] = y - PLANE_DISTANCE * sin
// Create the plane
set plane[this] = CreateUnit(DUMMY_OWNER, PLANE_CODE, planeX[this], planeY[this], a * bj_RADTODEG)
// Set the speed and x/yOffsets per timeout
set s = GetPlaneSpeedFactor(level[this])
set xDis[this] = cos * s
set yDis[this] = sin * s
// We haven't dropped or exploded the bomb
set dropped[this] = false
set exploded[this] = false
// Number of iterations before the bomb drops
set counter[this] = R2I(PLANE_DISTANCE / s)
// Set the plane's height
call UnitAddAbility(plane[this], 'Amrf')
call UnitRemoveAbility(plane[this], 'Amrf')
call SetUnitFlyHeight(plane[this], BOMB_HEIGHT, 0)
// TimerUtils is optional
// This is an ugly way of creating a special effect with Z
static if LIBRARY_TimerUtils then
call TimerStart(NewTimerEx(Particle.createEx(Player(13), planeX[this], planeY[this], BOMB_HEIGHT, 0, 0, 1, 255, 255, 255, 255, PLANE_IN_EFFECT, 0)), DESTROY_IN_EFFECT_PARTICLE_AFTER, false, function thistype.destroyParticle)
else
set t = CreateTimer()
set timerData[GetHandleId(t)] = Particle.createEx(Player(13), planeX[this], planeY[this], BOMB_HEIGHT, 0, 0, 1, 255, 255, 255, 255, PLANE_IN_EFFECT, 0)
call TimerStart(t, DESTROY_IN_EFFECT_PARTICLE_AFTER, false, function thistype.destroyParticle)
set t = null
endif
// Set the damage and the radius
set damage[this] = GetDamage(level[this])
set radius[this] = GetDamageRadius(level[this])
// Set the bonus damage and the bonus radius
set a = GetBonusDamageRadius(level[this])
set bonusRadius[this] = a*a
set bonusDamage[this] = GetBonusDamageFactor(level[this])*damage[this]
endmethod
private static method onInit takes nothing returns nothing
// Register the spell to SpellEffectEvent
call RegisterSpellEffectEvent(ABIL_CODE, function thistype.run)
static if DESTROY_TREES then
set treeDetector = CreateUnit(Player(15), 'hfoo', 0, 0, 0)
call UnitAddAbility(treeDetector, 'Ahrl')
call UnitAddAbility(treeDetector, 'Aloc')
call ShowUnit(treeDetector, false)
set treeRect = Rect(0,0,0,0)
endif
// If you don't have TimerUtils, you need a Table
static if not LIBRARY_TimerUtils then
set timerData = Table.create()
endif
endmethod
endstruct
endlibrary
Approved
