Spell [vJASS]Rupture [v1.2f] by baassee

[baassee]

First of all I have to say why it uses xedamage. It was a test for me, I learned to use it, that's it. Yes I'll probably make a version with J4L's Damage just because of the site Probably one without any required libraries too but that's the future.

And yes I use a spell test map made by -Berz- at THW and yes I got permission to use it as long as I gave credit for it (I call him -BZK-, we all did)

*Requirements For The Spell*
*xebasic by Vexorian
*xedamage by Vexorian
*T32 by Jesus4Lyf
*JASSHelper version 0.A.2.B or later by Vexorian
*Optional*
if the NOSTACK constant is set to true, this will be needed, else not.
*SimError by Vexorian

Links:
xe 0.8
T32
JASSHelper
SimError


Rupture, bloodseekers ultimate from DOTA. I have no idea if it works as the DOTA one but my version is how I thought it worked. I wont change it in anyway.

Description:

Deals a mighty blow to the enemy causing any movement to result in bleeding and loss of life.

Level 1 - 150 initial damage. Deals 20% of the distance moved as damage.
Level 2 - 250 initial damage. Deals 40% of the distance moved as damage.
Level 3 - 350 initial damage. Deals 60% of the distance moved as damage.

Oh yeah complain about the DOTA originality baby!

Lots of more information inside the JASStag, did anyone read that? How to import and changelog included inside the documentation.

scope Rupture // requires xebasic, xedamage, T32 optional SimError
//
//
//      *Rupture*
//          by baassee
//
//      *Requirements*
//          *xebasic by Vexorian
//          *xedamage by Vexorian
//          *T32 by Jesus4Lyf
//          *JASSHelper version 0.A.2.B or later by Vexorian
//      *Optional*
//          if the NOSTACK constant is set to true, this will be needed, else not.
//          *SimError by Vexorian
//
//          <a href="http://www.wc3c.net/showthread.php?t=101150" target="_blank" class="link link--external" rel="nofollow ugc noopener">http://www.wc3c.net/showthread.php?t=101150</a> - xe 0.8
//          <a href="http://www.thehelper.net/forums/showthread.php/132538-Timer32" class="link link--internal">http://www.thehelper.net/forums/showthread.php/132538-Timer32</a> - T32
//          <a href="http://www.wc3c.net/showthread.php?t=88142" target="_blank" class="link link--external" rel="nofollow ugc noopener">http://www.wc3c.net/showthread.php?t=88142</a>  - JASSHelper
//          <a href="http://www.wc3c.net/showthread.php?t=101260" target="_blank" class="link link--external" rel="nofollow ugc noopener">http://www.wc3c.net/showthread.php?t=101260</a> - SimError
//
//          *WARNING AND NOTICE!*
//              This map uses a renamed dummy model by Vexorian
//              please download the proper one or just export this
//              one, if you already have xe implented then you
//              wont have to worry about this.
//
//              Also the spell uses the dummy id of the xedummy so
//              remember to correct it!
//
//      *Changelog*
//          v1.0 - Released
//          v1.1 - -Fixed spelling errors Rupture instead of Rapture.
//                 -Fixed preloading.
//                 -Added a struct member lvl to the struct.
//                 -Fixed bug with adding unit to group when nostack == false.
//                 -Changed ApplyLife with RemoveUnit
//                 -.count is initially 0.
//                 -Removed creating effect and added it on damage with the xe.
//          v1.2 - -Removed the showunit command
//                 -Now the trigger doesn&#039;t initialize 2 triggers but creates one more with NOSTACK
//                 -Added another check to check if the unit is dead according to TH
//                 -Added locals to the conditions according to TH
//          v1.2b  -Fixed nulling -.-
//                 -Removed a action.
//          v1.2c  -Fixed an unnecessary function call
//                 -Fixed Error message.
//                 -Now when error message shows up the caster can choose a new target.
//          v1.2d  -Removed a static if.
//          v1.2e  -Fixed another static if with the globals. nostack is now set at the init.
//          v1.2f  -Made the spell run with T32. Fixed a few lines.
//
//
//      *Standard Information*
//          This spell was totally inspired by the spell Rupture in DOTA.
//          It probably dont function the same way as in DOTA but this is
//          my own version of it. I made it as the tooltip says at
//          <a href="http://www.playdota.com/heroes/bloodseeker/" target="_blank" class="link link--external" rel="nofollow ugc noopener">http://www.playdota.com/heroes/bloodseeker/</a>
//          
//          Please don&#039;t beg me to do other DOTA spells and don&#039;t complain
//          about its not-originality. I didn&#039;t find any Rapture at THW when
//          searching so I thought it might have been useful to someone.
//
//          Implent it as the how to import tutorial says and enjoy the spell!
//          Please give proper credit to Vexorian for the libraries and me for
//          this spell.
//
//          Yes I use GetWidgetLife() instead of the JASSHelper native UnitAlive
//          because UnitAlive bugs the optimizer by the same author so to prevent
//          that bug I use GetWidgetLife(), also it&#039;s faster.
//
//
//      *How to import*
//
//          1. Copy the dummy unit or just copy the one from the xe with the model included!
//
//          2. Copy the abilities, Rupture and Rupture Buff.
//
//          3. Copy the buff Rupture. Remember to set the buff of the spell Rupture Buff to
//             this one.
//
//          4. Make sure you have xebasic and damage in your map with proper dummy
//             and dummy model. Also import T32 or just copy the T32 Trigger.
//
//          5. Copy over this trigger called Rupture.
//
//          6. Follow the setup part which will explain all values and correct the ability
//             ids and the buff id.
//     
//          7. Add the spell to a unit, credit proper authors and enjoy!
//
//
//      *SETUP PART*
//
//

    globals
//
//      The ability ID of the main spell. Select it in the object editor, press
//      ctrl + d and you can see the ID.
//
        private constant integer ABILID         = &#039;A000&#039;
//
//      The ability id of the buff adding spell. How to get the id, check above.
//
        private constant integer DUMMYID        = &#039;A001&#039;
//
//      The buff id. Do as with the main ABILID but in the buff section.
//
        private constant integer BUFFID         = &#039;B000&#039;
//
//      The blood effect when a unit takes damage.
//
        private constant string BLOODFX         = &quot;Objects\\Spawnmodels\\Human\\HumanBlood\\HumanBloodPeasant.mdl&quot;
//
//      The attachment point where the blood fx will be attached too.
//      I would recommend chest, hands or head. Leave it as it is, no
//      need to change.
//
        private constant string ATTACH          = &quot;chest&quot;
//
//      If you want to preload the blood fx and the ability to remove
//      first cast lagg set this to true. You might suffer a longer
//      loading time if you do but it will prevent first cast lagg as
//      said. I would recommend it set to true.
//
        private constant boolean PRELOAD        = true
//
//      The error message that shows up with NOSTACK (below) is true
//
        private constant string MESSAGE         = &quot;Target Unit has already Rupture&quot;
//
//      The hotkey of the spell
//
        private constant string HOTKEY          = &quot;R&quot;
//      
//      If the damage should be 100% pure then set this to true
//      else if you want to make your own damage stuff, set it to false.
//
        
        private constant boolean PURE           = true
//
//      Do you want the ability to stack at the same unit?
//      This can bug the spell if set to false. Use at your own risk
//      The bug it can make is that the buff wont show but it will damage
//      proper.
//
        
        private constant boolean NOSTACK        = true
        
    endglobals
//
//      *FUNCTIONS* (Part of the setup part)
//
//
//      The duration function, takes the level of the spell.
//      The buff will last as long as the duration. Also
//      the movement damage.
//
    private function dur takes integer lvl returns real
        return 3. + 2. * lvl
    endfunction
//
//      The initial hit damage. Set as you want.
//
    
    private function fdmg takes integer lvl returns real
        return 50. + 100. * lvl
    endfunction
//
//      The movement damage in percent. As it is now it will
//      damage 20% * the level of the ability * the movement
//      during the period in damage.
//
    
    private function mdmg takes integer lvl returns real
        return 0.2 * lvl
    endfunction
//
//      The max damage function. Functions with the interval
//      function below the max damage function.
//
    
    private function maxdmg takes integer lvl returns real
        return 200. + 0 * lvl
    endfunction
//
//      The interval for the maximum damage. It will only
//      be possible to make above damage during the interval.
//      If the unit moves so much that it will take more damage,
//      this will prevent it. Refreshes every set amount.
//
    
    private function maxdmginterval takes integer lvl returns real
        return 0.25 + 0 * lvl
    endfunction
//
//      The damage options, they&#039;re explained inside the function.
//      This function is useless if you have set the PURE constant
//      to true. Use the function below this one for the PURE constant
//      true stuff.
//

    private function xeoptions takes xedamage d returns nothing
        // the damage type of the spell
        // this wont be affected if forcedamage
        // is set to true.
        set d.dtype         = DAMAGE_TYPE_UNIVERSAL
        // the attack type of the spell
        // this wont be affected if forcedamage
        // is set to true.
        set d.atype         = ATTACK_TYPE_CHAOS
        //
        // the weapon type the spell will use, affilcts the
        // sound when damaged, in this case, no sound
        // when damaged but I made it configurable anyway
        set d.wtype         = WEAPON_TYPE_WHOKNOWS
        // if the damage should be ranged,
        // works different when AI&#039;s hit,
        // usally makes the unit move as
        // it got attacked. Perfect for
        // Rapture.
        set d.ranged        = true
        // if the spell should damage enemies
        // quite obvious
        set d.damageEnemies = true
        // if the spell should damage neutrals if
        // they are targeted.
        set d.damageNeutral = true
        // this one below is quite special
        // I use the feature of xedamage to
        // try to make the pure damage as close
        // as possible to the amount.
        // if set to true, it will be pure
        // damage, if false then the damage
        // type and attack type will matter
        // if this is set to false and
        // damage type to universal and
        // attack type to chaos, it will act
        // as pure damage, if you havent mixed
        // with the gameplay constants.
        set d.forceDamage   = true
        
        call d.useSpecialEffect(BLOODFX, ATTACH)
    endfunction
//
//      The second xedamage options, just basic the same as above so
//      wont explain them further but these are used when the PURE
//      constant is set to true.
//
    private function xepureoptions takes xedamage d returns nothing
        set d.wtype         = WEAPON_TYPE_WHOKNOWS
        set d.ranged        = true
        set d.damageEnemies = true
        set d.damageNeutral = true
        call d.useSpecialEffect(BLOODFX, ATTACH)
    endfunction
    
//
//      *END OF SETUP*
//
    
    globals
        private xedamage xed // the xedamage instance
        private group nostack //nostack group, only declared
    endglobals

    private struct Rupture // the struct
        
        unit    c //casting unit
        unit    u //target unit
        integer lvl
        real    dmg//the movement percent
        real    maxdmg//the max damage per interval
        real    check//the interval check
        real    count = 0.//counter to count the interval
        real    X//current x of the target
        real    Y//current y of the target
        real    dur//duration of the spell
        //
        // creation method takes unit caster, unit target, real x of target, real y of target
        //
        static method create takes unit c, unit u, real x, real y returns Rupture
            local Rupture this = Rupture.allocate()
            set .c = c
            set .u = u
            set .lvl = GetUnitAbilityLevel(c, ABILID)
            set .dmg = mdmg(.lvl)
            set .maxdmg = maxdmg(.lvl)
            set .check = maxdmginterval(.lvl)
            set .X = x
            set .Y = y
            set .dur = dur(.lvl)
            static if PURE then
                call xed.damageTargetForceValue(c, u, fdmg(.lvl))
            else
                call xed.damageTarget(c, u, fdmg(.lvl))
            endif
            call UnitAddAbility(u, DUMMYID)//adds the buff spell
            call UnitMakeAbilityPermanent(u, true, DUMMYID)
            static if NOSTACK then
                call GroupAddUnit(nostack, u)
            endif
            call .startPeriodic()
            return this
        endmethod
        //
        // the method loop
        //
        private method periodic takes nothing returns nothing
            local real dx = GetUnitX(.u) - .X //these are distance stuff
            local real dy = GetUnitY(.u) - .Y //to see if the unit has moved
            local real sq = SquareRoot(dx * dx + dy * dy) //distance function
            if .dur &gt; 0. and GetWidgetLife(.u) &gt; 0.405 and not IsUnitType(.u, UNIT_TYPE_DEAD)then //check if the spell has ended
            //or the target is already dead
                set .dur = .dur - T32_PERIOD //reduce the duration
                if sq &gt; 0. then //check if the unit has moved any distance
                    //next if is to check if the interval has been reached and
                    //the max damage hasn&#039;t been reached and also that the
                    //damage that is about to happen isn&#039;t greater than the maxdmg
                    if .count &lt; .check and .maxdmg &gt; 0. and (sq * .dmg) &lt;= .maxdmg then
                        // we do the damage
                        static if PURE then
                            call xed.damageTargetForceValue(.c, .u, (sq * .dmg))
                        else
                            call xed.damageTarget(.c, .u, (sq * .dmg))
                        endif
                        set .maxdmg = .maxdmg - (sq * .dmg)
                        set .count = .count + T32_PERIOD
                        set .X = GetUnitX(.u)//set the new coordinates of the unit
                        set .Y = GetUnitY(.u)//same as above
                        if .count &gt;= .check then
                            set .count = 0.
                            set .maxdmg = maxdmg(.lvl)
                        endif
                    endif
                endif
            else
                //instance have ended then we clear leaks and removes the ability and also the buff
                call .stopPeriodic()
                call UnitMakeAbilityPermanent(.u, false, DUMMYID)
                call UnitRemoveAbility(.u, DUMMYID)
                call UnitRemoveAbility(.u, BUFFID)
                static if NOSTACK then
                    call GroupRemoveUnit(nostack, .u)
                endif
                call .destroy()
            endif
        endmethod
    
        static method Conditions takes nothing returns boolean
            local real x
            local real y
            local unit c
            local unit u
            if GetSpellAbilityId() == ABILID then
                set c = GetTriggerUnit()
                set u = GetSpellTargetUnit()
                set x = GetUnitX(u)
                set y = GetUnitY(u)
                call Rupture.create(c, u, x, y)
            endif
            set c = null
            set u = null
            return false
        endmethod
        
        static method Conditions2 takes nothing returns boolean
            local unit c
            local unit u
            if GetSpellAbilityId() == ABILID then
                set c = GetTriggerUnit()
                set u = GetSpellTargetUnit()
                if IsUnitInGroup(u, nostack) == true then
                    call IssueImmediateOrder(c, &quot;stop&quot;)
                    call SimError(GetTriggerPlayer(), MESSAGE)
                    if GetLocalPlayer() == GetTriggerPlayer() then
                        call ForceUIKey(HOTKEY)
                    endif
                endif
            endif
            set c = null
            set u = null
            return false
        endmethod
        
        static method onInit takes nothing returns nothing
            //start of the trigger
            local trigger t = CreateTrigger()
            local trigger trg
            call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_SPELL_EFFECT)
            // to prevent mana and cooldown loss if the constant NOSTACK is on
            static if NOSTACK then
                set trg = CreateTrigger()
                set nostack = CreateGroup()
                call TriggerRegisterAnyUnitEventBJ(trg, EVENT_PLAYER_UNIT_SPELL_CAST)
                call TriggerAddCondition(trg, Condition(function Rupture.Conditions2))
            endif
            //conditions are faster than actions? so I&#039;ve heard
            call TriggerAddCondition(t, Condition(function Rupture.Conditions))
            //xe damage stuff
            set xed = xedamage.create()
            static if PURE then //checks the pure constant
                call xepureoptions(xed)
            else
                call xeoptions(xed)
            endif
            //preload
            static if PRELOAD then
                call Preload(BLOODFX)
                set bj_lastCreatedUnit = CreateUnit(Player(15), XE_DUMMY_UNITID, 0., 0., 0.)
                call UnitAddAbility(bj_lastCreatedUnit, DUMMYID)
                call RemoveUnit(bj_lastCreatedUnit)
            endif
        endmethod
        implement T32x
    endstruct
endscope

Credits goes to:

Vexorian for required stuff
Jesus4Lyf for T32

-BZK- for the test map.

Credit me,vexorian and Jesus4Lyf if used.

Enjoy the spell!

 

[Komaqtion]

Just a small grammar error here:
"Target Unit has already Rupture"
Should be:
"Target unit has already been Ruptured"
or:
"Target unit already have Rupture"

And there is a new method now for checking whether a unit is alive or not, and it can be used with the help of Jasshelper.
The new native is called [ljass]UnitAlive[/ljass] and you need to declare this by putting this line somewhere in any trigger of yours:

native UnitAlive takes unit u returns boolean

Then replace this:

GetWidgetLife(.u) > 0.405

With this:

UnitAlive( u )

Haven't checked the code or actual spell yet but perhaps I will soon

 

[baassee]

Yes I know what UnitAlive is and I think it sucks (not the boolean returned ofc, most accurate) but when optimized with Vex's own optimizer the "compress names" fucks up that native so I did it like this instead.

EDIT:

Right the grammar, is it enough to just leave it or update the code and not the map?

EDIT2:

Fixed the message with "Target unit has already been Ruptured". Thanks!

 

[Laiev]

why the thread tittle is Rapture and in the trigger Rupture?

EDIT: static ifs with globals block always return true, no? o.o

 

[kingkingyyk3]

Use GT on it!
It helps cleaning the code and more efficient.

 

[BlackRose]

As I previously said, it's rather pointless to have both t and trg variables in the initialisation method.

By the way, it's DotA, not DOTA. Bleh. Your entire thread could be presented a more clean fashion as well x3 Look at the other resources for examples ;3

 

[Laiev]

static if NOSTACK then
                    if IsUnitInGroup(u, nostack) == true then
                        call IssueImmediateOrder(c, "stop")
                        call SimError(GetOwningPlayer(c), MESSAGE)
                        if GetLocalPlayer() == GetOwningPlayer(c) then
                            call ForceUIKey(HOTKEY)
                        endif
                    endif
                endif

you can remove that static if, since this function will only be used if you create the event, which check the same if...

IMO you don't need xedamage, you're importing 2 other systems just to deals damage to 1 unit, don't worth.. (my opinion... ><')

PS: Welcome to TheHelper Baassee

 

[baassee]

The first sentence in the description pointed out why i used xedamage i know it's alot of text but please atleast read the first few sentences

Yeah blackrose isn't a fan of this hehe

I'll fix some stuff and can someone rename rupture. I just copied v1.0 and changed version number and forgot to change the title

No i wont use gt but hey thanks anyway

EDIT:

Thanks Laiev!

 

[DioD]

and there is dota's one....

function Trig_Rupture_Conditions takes nothing returns boolean
	return GetSpellAbilityId()=='A0LH'
endfunction

function r6 takes nothing returns nothing
	local timer t=GetExpiredTimer()
	local string f5=H2Tx(t)
	local unit r7=GetUnit(f5,"RuptureCaster")
	local unit r8=GetUnit(f5,"RuptureTarget")
	local location r9=GetLocation(f5,"RuptureOldLoc")
	local location Ra=GetUnitLoc(r8)
	local real Qr=.2*GetUnitAbilityLevel(r7,'A0LH')*DistanceBetweenPoints(r9,Ra)
	if(Qr>200)then
		set Qr=0
	endif
	if(Qr>5)then
		call DestroyEffect(AddSpecialEffectTarget("Objects\\Spawnmodels\\Human\\HumanBlood\\BloodElfSpellThiefBlood.mdl",r8,"origin"))
	endif
	if(Qr>0)then
		call UnitDamageTargetBJ(r7,r8,Qr,ATTACK_TYPE_HERO,DAMAGE_TYPE_MAGIC)
	endif
	call RemoveLocation(r9)
	call SetHandle(f5,"RuptureOldLoc",Ra)
endfunction

function Trig_Rupture_Actions takes nothing returns nothing
	local unit r7=GetTriggerUnit()
	local unit r8=GetSpellTargetUnit()
	local location Rb=GetUnitLoc(r8)
	local integer mZ=GetUnitAbilityLevel(r7,'A0LH')
	local timer t=CreateTimer()
	local string f5=H2Tx(t)
	local unit qE
	call UnitDamageTargetBJ(r7,r8,50+100*mZ,ATTACK_TYPE_HERO,DAMAGE_TYPE_MAGIC)
	call SetHandle(f5,"RuptureCaster",r7)
	call SetHandle(f5,"RuptureTarget",r8)
	call SetHandle(f5,"RuptureOldLoc",Rb)
	call TimerStart(t,.25,true,function r6)
	set qE=CreateUnit(GetOwningPlayer(r8),'e01R',0,0,bj_UNIT_FACING)
	call UnitAddAbility(qE,'A0NH')
	call PolledWait(3+(2*mZ))
	call RemoveUnit(qE)
	call UnitRemoveAbility(r8,'B067')
	call PauseTimer(t)
	call PolledWait(1)
	call FastFlush(f5)
	call DestroyTimer(t)
endfunction

function StartTrigger_Rupture takes nothing returns nothing
	set gg_trg_Rupture=CreateTrigger()
	call TriggerRegisterAnyUnitEventBJ(gg_trg_Rupture,EVENT_PLAYER_UNIT_SPELL_EFFECT)
	call TriggerAddCondition(gg_trg_Rupture,Condition(function Trig_Rupture_Conditions))
	call TriggerAddAction(gg_trg_Rupture,function Trig_Rupture_Actions)
endfunction

handle vars not included, cos they does not work anyway.


as you may see, original code is 3 times small and dont need any other system (lets count all other systems and we will have 11 times size)

 

[baassee]

First of all I have to say why it uses xedamage. It was a test for me, I learned to use it, that's it.

Rupture, bloodseekers ultimate from DOTA. I have no idea if it works as the DOTA one but my version is how I thought it worked. I wont change it in anyway.

I hope that's not what they use now :O emiljr's or? (sry for misspelled)

Well let's face it, it's not the same and I never intended to (just based it on my own thoughts how it worked).

 

[Deaod]

as you may see, original code is 3 times small and dont need any other system (lets count all other systems and we will have 11 times size)

As you can see, the original code also sucked and is in no way comparable to the version posted here.

I hope you dont seriously expect me to dissect code riddled with gamecache and locations?

I wont change it in anyway.

If you dont want to change your code, this should go straight to the graveyard, since you wont update anyway if a problem arises.

you're importing 2 other systems just to deals damage to 1 unit, don't worth.. (my opinion... ><')

What the hell is wrong with importing two libraries other spells are likely to use as well? Dependencies hardly ever are a problem.

 

[Laiev]

nothing, but at least make it optional... some person don't want to import xe just because they don't like it

EDIT:

about the original one, lets leak local like crazy and use waits is sooooo efficient

 

[baassee]

As you can see, the original code also sucked and is in no way comparable to the version posted here.

I hope you dont seriously expect me to dissect code riddled with gamecache and locations?

If you dont want to change your code, this should go straight to the graveyard, since you wont update anyway if a problem arises.

What the hell is wrong with importing two libraries other spells are likely to use as well? Dependencies hardly ever are a problem.

Thanks alot! The

I have no idea if it works as the DOTA one but my version is how I thought it worked.

That's why I wont change the way it "works" because this is as said how I thought it worked but I can surely update it, I will with Laiev's suggestion today hopefully with some time.

EDIT:

I'll probably make xe optional as said and damage too. But how about if you have both libraries? I guess I'll use damage then

 

[Laiev]

Yes

and what Deod mean I think is if you don't will update your code with the suggestion to improve it, not to make it exactly like dota

 

[baassee]

But I don't want it exactly like dota I just "tried" to make it

 

[baassee]

Updated. Will make and upload seperate versions for Damage and for no xe/damage.

 

[Laiev]

private constant boolean NOSTACK        = true

    static if STACK then
        globals
            private group nostack               = CreateGroup() //nostack group
        endglobals
    endif

Oo'

also globals always return true inside static if

 

[baassee]

yeah I saw that too, maybe I should make a static group inside the struct instead? will that work with a static if?

OR I only declare it and create it if stack is on in the init

 

[Laiev]

second one is better i think

 

[baassee]

update in a second