WC3 Modding Information Center
For your WC3 needs...

Dalve · **on:** February 01, 2015, 06:12:25 PM

(Description)
Summons a dark matter at the targeted point. The dark matter has ability to absorb all enemy units within 400 range onto it's position while releasing smaller dark particles to attack those captured units. Each particle deals 90 damage on hit. Lasts for 15 seconds.

(Details)

Level(s): 1
Manacost: 270
Cooldown: 145 s
Cast range: 800
Area of Effect: 400

(Required)
- Stack
- CTL
- WorldBounds
(Optional)
- SpellEffectEvent
- AutoFly

Import all necessary datas (imports, objects, triggers, etc.) into your map.
Install all required dependencies correctly.
Configure the spell.
Done.

(Readme)

Code: jass

/*
 
    [General]
        Name: Dark Matter
        Version: 1.0
        Class: Ultimate
    
    [Details]
        Level(s): 1
        Manacost: 270
        Cooldown: 145 s
        Cast range: 800
        Area of Effect: 400
        
    [Description]
        Summons  a dark matter at the targeted point. The dark  matter
        has  ability to absorb all enemy units within 400  range  onto
        it's position while releasing smaller dark particles to attack
        those  captured units. Each particle deals 90 damage  on  hit.
        Lasts for 15 seconds.
 
    [External dependencies]
        (Required)
            - Stack
            - CTL
            - WorldBounds
        (Optional)
            - SpellEffectEvent
            - AutoFly
            
    [Credits]
        - Nestharus
            | Stack, CTL, WorldBounds, AutoFly
            
        - Bribe
            | SpellEffectEvent
            
        - JetFangInferno
            | Deathwave.mdx 
            
        - WILL THE ALMIGHTY
            | Blackhole.mdx
            
        - Hellx-Magnus
            | BTNEyeOfShadow
            
    [How to import]
        - Import all necessary datas (imports, objects, triggers, etc.)
            into your map.
        - Install all required dependencies correctly.
        - Configure the spell.
        - Done.
*/

(Spell)

Code: jass

scope DarkMatter
/*
 
            ~* Dark Matter *~
                    version 1.0
            
        Created by: Dalvengyr
        Copyright 2015
    
        This resource is copyright protected.
        Don't redistribute without permission.
        
        You are free to edit, use, remake, etc.
        but don't remove the copyright notes
        above.
    
*/
 
    /*                 *\
        Configuration
    \*                 */
    
    globals
    
    /*  I. General settings */
    
        // Dummy unit's raw code at Object Editor.
        private constant integer    DUMMY_OBJECT_ID       = 'h000'
        
        // Main spell's raw code at Object Editor.
        private constant integer    SPELL_OBJECT_ID       = 'A000'
        
        // General decay time for special effects.
        // Time for effects to finish their death animations
        // before removed completely.
        private constant real       SFX_DECAY_TIME        = 5.0
        
        // General units' hit z offset. Used for 3D collision.
        private constant real       UNITS_HIT_Z_OFFSET    = 50.0
        
    
    /*  II. Orb settings
                Orb is an object at the center of spell area.
    */
        
        // Orb model's file path.
        private constant string     ORB_SFX               = "war3mapImported\\BlackHole.mdx"
        
        // Orb's flying height.
        private constant real       ORB_HEIGHT_Z          = 0.0
        
        // Orb's scale/size.
        private constant real       ORB_SCALE             = 1.0
        
        // How bad range between victims and the orb can affect the absorb power.
        private constant real       ORB_POWER_FACTOR      = 0.375
        
        
    /*  III. Swirl settings
                Swirl is consisted by several "waves" (because I use wave model) which
                swirl around the main orb.
    */
        
        // Wave's raw code at Object Editor.
        private constant integer    SWIRL_WAVE_OBJECT_ID  = 'h001'
        
        // Wave's animation speed.
        private constant real       SWIRL_TIME_SCALE      = 0.1
        
        // Wave's flying height.
        private constant real       SWIRL_HEIGHT_Z        = 100.0
        
        // Wave's scale/size.
        private constant real       SWIRL_SCALE           = 1.25
        
        
    /*  IV. Particle settings
                Particles are missiles that are periodically released by the orb to attack
                captured units.
    */
    
        // Particle's model file path.
        private constant string     PARTICLE_SFX          = "Abilities\\Weapons\\AvengerMissile\\AvengerMissile.mdl"
    
        // Particle's starting fly height when launched.
        private constant real       PARTICLE_LAUNCH_Z     = 100.0
    
        // Particle's scale/size.
        private constant real       PARTICLE_SCALE        = 0.2
    
        // Particle's turn rate.
        private constant real       PARTICLE_TURN_SPEED   = 0.1
    
        // Max range between particle at target to hit the target.
        private constant real       PARTICLE_HIT_RADIUS   = 70.0
    
        // If false, each particle can only hits one target.
        private constant boolean    PARTICLE_PIERCING     = false
        
        // Dealt damage setting.
        private constant attacktype PARTICLE_ATTACK_TYPE  = ATTACK_TYPE_NORMAL
        private constant damagetype PARTICLE_DAMAGE_TYPE  = DAMAGE_TYPE_NORMAL
        
    endglobals
    
    // These settings allow you to assign different values for each level
    // in case the ability has more than one level.
    
    // Number of created wave to swirl around the orb.
    private constant function SwirlCount takes integer level returns integer
        return 9
    endfunction
    
    // Range/distance from the orb to the created waves.
    private constant function SwirlRadius takes integer level returns real
        return 125.0
    endfunction
    
    // Rotation speed of waves, in radians.
    private constant function SwirlRotation takes integer level returns real
        return 0.09
    endfunction
    
    // Dealt damage when particle hits a target.
    private constant function ParticleDamage takes integer level returns real
        return 90.0
    endfunction
    
    // Move speed of each particle.
    private constant function ParticleSpeed takes integer level returns real
        return 5.0
    endfunction
    
    // Maximum delay before the orb releases another particle.
    // Delay is randomized between zero and this value.
    private constant function ParticleSpawnDelayMax takes integer level returns real
        return 0.5
    endfunction
    
    // Maximum range between the orb and targets to absorb them.
    private constant function OrbAoE takes integer level returns real
        return 400.0
    endfunction
    
    // Duration of the spell.
    private constant function OrbDuration takes integer level returns real
        return 15.0
    endfunction
    
    // The absorbtion power.
    private constant function OrbPower takes integer level returns real
        return 15.0
    endfunction
    
    // Classifications of targets that can be affected by this spell.
    private constant function SpellTargets takes unit target, player caster returns boolean
        return IsUnitEnemy(target, caster) and not IsUnitType(target, UNIT_TYPE_STRUCTURE)
    endfunction
    
    // You can add any additional effect to the target here.
    // This function is executed right before the damage is dealt to
    // the target.
    // If you don't need this, you are free to remove this module
    // anytime.
    private module DarkMatterDamageEvent
        static method onDamage takes unit caster, unit target returns nothing
            
        endmethod
    endmodule
    
    // ~*~*~*~*~**~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~
    
    globals
        private constant real INTERVAL = 0.0312500
        private group Group = CreateGroup()
    endglobals
    
    
    // Native declaration.
    native UnitAlive takes unit id returns boolean
    
    
    // Stack used to contain/store waves.
    private struct Swirl extends array
        unit unit
        implement Stack
    endstruct
    
    
    // Create swirl at give coordinates.
    private struct Tornado extends array
        
        Swirl swirl
        integer count
        
        real distance
        real angle
        real rotation
        
        real space
        real x
        real y
        
        static constant real TAU = 2*bj_PI
        
        method terminate takes nothing returns nothing
            
            local Swirl node = .swirl.first
            
            // Kill all waves.
            loop
                exitwhen node == 0
                
                call KillUnit(node.unit)
                set node.unit = null
                
                set node = node.next
            endloop
            
            call .swirl.destroy()
            call destroy()
            
        endmethod
        
        
        implement CTL
        
            local real a
            local integer i
            local Swirl node
            
        implement CTLExpire
        
            set i = .count
            set node = .swirl.first
            set .angle = .angle + .rotation
            
            // Iterate through all nodes to update
            // their angles/rotations.
            loop
                exitwhen i <= 0
                
                set a = .angle+.space*i
                call SetUnitX(node.unit, .x + .distance * Cos(a))
                call SetUnitY(node.unit, .y + .distance * Sin(a))
                call SetUnitFacing(node.unit, a*bj_RADTODEG)
                
                set node = node.next
                set i = i - 1
            endloop
            
        implement CTLEnd
        
        
        static method spawn takes player p, integer count, real x, real y, real dist, real rot returns thistype
            
            local thistype this = create()
            local integer i = 0
            local real a
            local Swirl node
            
            // Number of waves.
            set .count = count
            // Angle difference between each wave (in radian).
            set .space = TAU/count
            // Initial angle (random).
            set .angle = GetRandomReal(-bj_PI, bj_PI)
            // Allocate stack for waves.
            set .swirl = Swirl.create()
            
            // Distance from center to waves.
            set .distance = dist
            // Rotation rate.
            set .rotation = rot
            set .x = x
            set .y = y
            
            // Create the waves and store into the stack.
            loop
                exitwhen i >= count
                
                // Allocate new node to the stack.
                set node = .swirl.push()
                set a = .angle+.space*i
                set node.unit = CreateUnit(p, SWIRL_WAVE_OBJECT_ID, x+dist*Cos(a), y+dist*Sin(a), a*bj_RADTODEG)
                
                call SetUnitScale(node.unit, SWIRL_SCALE, 1, 1)
                call SetUnitTimeScale(node.unit, SWIRL_TIME_SCALE)
                
                if SWIRL_HEIGHT_Z > 0 then
                
                    static if not LIBRARY_AutoFly then
                        if UnitAddAbility(node.unit, 'Amrf') and UnitRemoveAbility(node.unit, 'Amrf') then
                        endif
                    endif
                    
                    call SetUnitFlyHeight(node.unit, SWIRL_HEIGHT_Z, 0)
                endif
                
                set i = i + 1
            endloop
            
            return this
        endmethod
        
    endstruct
    
    
    private keyword DarkMatter
    
    
    // Launch 3D homing missile.
    private struct SimpleMissile extends array
        
        effect sfx
        player owner
        group targets
        
        unit caster
        unit target
        unit missile
        
        real x
        real y
        real z
        
        real dc
        real dx
        real damage
        
        real turn
        real angle
        real speed
        
        method terminate takes nothing returns nothing
        
            // Group is only created if piercing is true.
            static if PARTICLE_PIERCING then
                call DestroyGroup(.targets)
                set .targets = null
            endif
            
            call DestroyEffect(.sfx)
            call UnitApplyTimedLife(.missile, 'BTLF', SFX_DECAY_TIME)
            call destroy()
            
            // Remove leaks.
            set .missile = null
            set .target = null
            set .caster = null
            set .sfx = null
            
        endmethod
        
        implement optional DarkMatterDamageEvent
        
        implement CTL
        
            local real a
            local real v
            local real h
            
            local real d
            local real x
            local real y
            
            local unit u
            local unit t
            local integer rand
            
        implement CTLExpire
        
            set .dc = .dc + .speed
            set .x = .x + .speed * Cos(.angle)
            set .y = .y + .speed * Sin(.angle)
            
            // Parabola equation.
            set v = 4 * (.dx-.dc) * (.dc/.dx) + PARTICLE_LAUNCH_Z
            
            // If haven't touched the ground and still inside the map bounds.
            if v > 0 and .x < WorldBounds.maxX and .x > WorldBounds.minX and .y < WorldBounds.maxY and .y > WorldBounds.minY then
            
                call SetUnitX(.missile, .x)
                call SetUnitY(.missile, .y)
                call SetUnitFlyHeight(.missile, v, 0)
                
                // Adjust the angle to face the target.
                set a = Atan2(GetUnitY(.target)-.y, GetUnitX(.target)-.x)
                if Cos(.angle - a) < Cos(.turn) then
                    if Sin(a - .angle) >= 0 then
                        set .angle = .angle + .turn
                    else
                        set .angle = .angle - .turn
                    endif
                else
                    set .angle = a
                endif
                
                // Determine one random target from all possible targets.
                // if not piercing.
                static if not PARTICLE_PIERCING then
                    set t = null
                    set rand = 0
                endif
                
                // Iterates all units around the missile.
                call GroupEnumUnitsInRange(Group, .x, .y, PARTICLE_HIT_RADIUS, null)
                loop
                    set u = FirstOfGroup(Group)
                    exitwhen u == null
                    call GroupRemoveUnit(Group,  u)
                    
                    if UnitAlive(u) and SpellTargets(u, owner) then
                    
                        set x = GetUnitX(u)
                        set y = GetUnitY(u)
                        set h = GetUnitFlyHeight(u) + UNITS_HIT_Z_OFFSET - v
                        set d = SquareRoot((.x-x)*(.x-x)+(.y-y)*(.y-y))
                        
                        // 3D spherical collision.
                        if SquareRoot(d*d+h*h) <= PARTICLE_HIT_RADIUS then
                        
                            static if PARTICLE_PIERCING then
                            
                                if not IsUnitInGroup(u, .targets) then
                                
                                    static if thistype.onDamage.exists then
                                        call thistype.onDamage(.caster, u)
                                    endif
                                
                                    call UnitDamageTarget(.caster, u, .damage, false, false, PARTICLE_ATTACK_TYPE, PARTICLE_DAMAGE_TYPE, null)
                                    call GroupAddUnit(.targets, u)
                                    
                                endif
                                
                            else
                                
                                // Quite effective to obtain random unit from a group.
                                set rand = rand + 1
                                
                                if GetRandomInt(1, rand) == 1 then
                                    set t = u
                                endif
                                
                            endif
                        endif
                        
                    endif
                endloop
                
                static if not PARTICLE_PIERCING then
                    // If a target is found.
                    if t != null then
                        
                        static if thistype.onDamage.exists then
                            call thistype.onDamage(.caster, t)
                        endif
                    
                        call UnitDamageTarget(.caster, t, .damage, false, false, PARTICLE_ATTACK_TYPE, PARTICLE_DAMAGE_TYPE, null)
                        call terminate()
                        set t = null
                        
                    endif
                endif
                
            else
                call terminate()
            endif
            
        implement CTLEnd
        
        
        static method launch takes DarkMatter source, unit target returns thistype
            
            local thistype this = create()
            local real x = GetUnitX(target)
            local real y = GetUnitY(target)
            
            set .target = target
            set .caster = source.caster
            set .owner = source.owner
            
            // Launch from random location nearby the orb.
            set .x = source.x + GetRandomReal(-source.tornado.distance, source.tornado.distance)
            set .y = source.y + GetRandomReal(-source.tornado.distance, source.tornado.distance)
            set .angle = GetRandomReal(-bj_PI, bj_PI)
            
            set .missile = CreateUnit(.owner, DUMMY_OBJECT_ID, .x, .y, .angle*bj_RADTODEG)
            set .sfx = AddSpecialEffectTarget(PARTICLE_SFX, .missile, "origin")
            set .turn = PARTICLE_TURN_SPEED
            
            set .damage = source.damage
            set .speed = source.speed
            set .dx = source.aoe
            set .dc = 0
            
            // Create group if only piercing is true.
            static if PARTICLE_PIERCING then
                set .targets = CreateGroup()
            endif
            
            static if not LIBRARY_AutoFly then
                if UnitAddAbility(.missile, 'Amrf') and UnitRemoveAbility(.missile, 'Amrf') then
                endif
            endif
            
            call SetUnitFlyHeight(.missile, PARTICLE_LAUNCH_Z, 0)
            call SetUnitScale(.missile, PARTICLE_SCALE, 1, 1)
            
            return this
        endmethod
        
    endstruct
    
    
    // Main spell's struct.
    private struct DarkMatter extends array
    
        unit orb
        unit caster
        group targets
        
        Tornado tornado
        player owner
        effect sfx
        
        real aspd
        real aspdx
        real speed
        
        real damage
        real power
        real aoe
        
        real duration
        real x
        real y
        
        real delay
        real delayx
        real rotation
        real amount
        
        static constant real HP = bj_PI/2
        
        method terminate takes nothing returns nothing
        
            local unit u
        
            // Turn all remaining units' collision back to on.
            loop
                set u = FirstOfGroup(.targets)
                exitwhen u == null
                call GroupRemoveUnit(.targets, u)
                call SetUnitPathing(u, true)
            endloop
        
            call .tornado.terminate()
            call DestroyEffect(.sfx)
            call DestroyGroup(.targets)
            call UnitApplyTimedLife(.orb, 'BTLF', SFX_DECAY_TIME)
            
            call destroy()
            // Remove leaks.
            set .targets = null
            set .caster = null
            set .orb = null
            set .sfx = null
            
        endmethod
        
        
        implement CTL
            
            local group g
        
            local integer rand = 0
            local unit t = null
            local unit u
            
            local real d
            local real x
            local real y
            
            local real h
            local real a
            local real pow
            
        implement CTLExpire
        
            if .duration > INTERVAL then
            
                set .duration = .duration - INTERVAL
                
                // Iterate through all units around the orb (within aoe).
                call GroupEnumUnitsInRange(Group, .x, .y, .aoe, null)
                loop
                    set u = FirstOfGroup(Group)
                    exitwhen u == null
                    call GroupRemoveUnit(Group, u)
                    
                    if UnitAlive(u) and SpellTargets(u, owner) then
                        
                        set x = GetUnitX(u)
                        set y = GetUnitY(u)
                        set d = SquareRoot((.x-x)*(.x-x)+(.y-y)*(.y-y))
                        // Power is affected by distance between orb and the target.
                        set pow = .power - .power*(d/.aoe)*ORB_POWER_FACTOR
                        // Calculate target angle.
                        set a = Atan2(.y-y, .x-x) - (HP*(d/.aoe))*.rotation
                        
                        if not IsUnitInGroup(u, .targets) then
                            call GroupAddUnit(.targets, u)
                            call SetUnitPathing(u, false)
                        endif
                    
                        if .aspd <= INTERVAL then
                        
                            set rand = rand + 1
                            
                            if GetRandomInt(1, rand) == 1 then
                                set t = u
                            endif
                            
                        endif
                        
                        if d > pow then
                        
                            call SetUnitX(u, x + pow * Cos(a))
                            call SetUnitY(u, y + pow * Sin(a))
                            
                        else
                        
                            call SetUnitX(u, .x)
                            call SetUnitY(u, .y)
                            
                        endif
                        
                    endif
                endloop
                
                // Iterates all affected units which have
                // escaped the spell area and turn their
                // collision on.
                set g = .targets
                set .targets = CreateGroup()
                loop
                    set u = FirstOfGroup(g)
                    exitwhen u == null
                    call GroupRemoveUnit(g, u)
                    
                    set x = GetUnitX(u)
                    set y = GetUnitY(u)
                    if SquareRoot((.x-x)*(.x-x)+(.y-y)*(.y-y)) > .aoe then
                        call SetUnitPathing(u, true)
                    else
                        call GroupAddUnit(.targets, u)
                    endif
                endloop
                
                if .aspd > INTERVAL then
                    set .aspd = .aspd - INTERVAL
                elseif t != null then
                    // Launch missile if a random target is found.
                    set .aspd = GetRandomReal(0, .aspdx)
                    call SimpleMissile.launch(this, t)
                    set t = null
                endif
                
                // Remove leaks.
                call DestroyGroup(g)
                set g = null
            else
                call terminate()
            endif
            
        implement CTLEnd
        
        
        static method onCast takes nothing returns nothing
            
            local thistype this = create()
            local integer l
            
            set .caster = GetTriggerUnit()
            set .owner = GetTriggerPlayer()
            
            set .x = GetSpellTargetX()
            set .y = GetSpellTargetY()
            set .targets = CreateGroup()
            
            set .orb = CreateUnit(.owner, DUMMY_OBJECT_ID, .x, .y, 270)
            set .sfx = AddSpecialEffectTarget(ORB_SFX, .orb, "origin")
            set l = GetUnitAbilityLevel(.caster, SPELL_OBJECT_ID)
            
            set .aoe = OrbAoE(l)
            set .power = OrbPower(l)
            set .duration = OrbDuration(l)
            
            set .rotation = SwirlRotation(l)
            set .tornado = Tornado.spawn(.owner, SwirlCount(l), .x, .y, SwirlRadius(l), .rotation)
            // Get the rotation direction.
            set .rotation = .rotation/RAbsBJ(.rotation)
            
            set .speed = ParticleSpeed(l)
            set .damage = ParticleDamage(l)
            set .aspd = ParticleSpawnDelayMax(l)
            
            set .aspdx = .aspd
            call SetUnitScale(.orb, ORB_SCALE, 1, 1)
            
            if ORB_HEIGHT_Z > 0 then
                static if not LIBRARY_AutoFly then
                    if UnitAddAbility(.orb, 'Amrf') and UnitRemoveAbility(.orb, 'Amrf') then
                    endif
                endif
                call SetUnitFlyHeight(.orb, ORB_HEIGHT_Z, 0)
            endif
            
        endmethod
            
            
        static if not LIBRARY_SpellEffectEvent then
            private static method check takes nothing returns boolean
                if GetSpellAbilityId() == SPELL_OBJECT_ID then
                    call thistype.onCast()
                endif
                return false
            endmethod
        endif
        
        
        static method onInit takes nothing returns nothing
 
            local trigger t
            
            static if LIBRARY_SpellEffectEvent then
                call RegisterSpellEffectEvent(SPELL_OBJECT_ID, function thistype.onCast)
            else
                set t = CreateTrigger()
                call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
                call TriggerAddCondition(t, Condition(function thistype.check))
            endif
            
        endmethod
        
    endstruct
    
endscope

Nestharus

| Stack, CTL, WorldBounds, AutoFly

Bribe

| SpellEffectEvent

JetFangInferno

| Deathwave.mdx

WILL THE ALMIGHTY

| Blackhole.mdx

Hellx-Magnus

| BTNEyeOfShadow

[/list]

moyack · **Reply #1 on:** February 02, 2015, 08:12:27 AM

Great presentation in your spell.

Later the spell /system section will add some search features, this in order to stand out your resource.

Great work and thanks for contribute in Blizzmod

SonofJay · **Reply #2 on:** February 04, 2015, 12:13:53 AM

I love the effects and assuming you are dalvengyr from hive then there should be not much problem with the code either but I am not really a coder to say that.

Thanks for sharing it here, hope we can see more from you.