[Solved] FirstOfGroup loops or ForGroup? And how to make a unit cast multiple spells instantly

[Alain.Mark]

looping through a group of units using the FirstOfGroup function or conventionaly enuming units?

 

[WaterKnight]

Have both their points.

function Start takes integer a, integer b returns nothing
    loop
        set u = FirstOfGroup(g)
        exitwhen (u == null)
        call GroupRemoveUnit(g, u)

        //actions
    endloop
endfunction

function Enum takes nothing returns nothing
    local integer a = A
    local integer b = B

    //actions
endfunction

function Start takes integer a, integer b, code c returns nothing
    set A = a
    set B = b

    call ForGroup(g, c)
endfunction

On first, you stay in the same function/thread, can therefore use local variables whereas with traditional enuming values would have to be transferred globally.

If you wanted to have dynamic code, meaning to deliver what to run as a parameter, the loop would require boolexpr/trigger/ExecuteFunc string, at least first retrieve them out of a code parameter, which you could directly use in second but there again, you can only use that unless you execute from the Enum-function.

ForGroup is protected against adding units in the Enum-loop, won't pick the same unit twice. However, you also cannot remove from the execution stack. ForGroup does not clear the group.

When units decay, they still leave a reference in the group. ForGroup does not run for these but FirstOfGroup-loop. FirstOfGroup will return a null then, which breaks the end mark.

 

[HuanAk]

look like ForGroup() is faster, and can keep your unit inside group after action.

FirstOfGroup is slower and it will remove all units at the end.

 

[Bribe]

Depending on the circumstances you use ForGroup or FirstOfGroup loops.

If it's once-off enumerating then you should just use a null filter and a FirstOfGroup loop. Anyone who says a filter is faster than a FirstOfGroup loop needs to prove me wrong by posting a 1.24 or later benchmark, because no logic says opening a new thread for each iteration is going to be faster. I think the original benchmarks were when we needed to have a "return true" dummy filter.

If you need to store the units then you use FirstOfGroup and maybe a non-null filter.

 

[Alain.Mark]

So does that mean FirstOfGroup is better if i just want to make a dummy caster cast a single target spell on multiple units?

 

[Bribe]

If it's just for instant useage then yes, the code is very clean and it doesn't have that bug that was mentioned earlier.

Also, when enumerating for a FirstOfGroup loop you should just use bj_lastCreatedGroup because it always exists, meaning that you don't have to create or destroy it.

 

[Alain.Mark]

loop
    set target=FirstOfGroup(affected)
    exitwhen target==null
    call GroupRemoveUnit(affected,target)
    if(IsUnitEnemy(target,pl))then
        call SetUnitX(caster,GetUnitX(target))
        call SetUnitY(caster,GetUnitY(target))
        call IssueTargetOrder(caster,orderstr,target)
    endif
endloop

Any comments would be appreciated provided that they are constructive.

 

[Bribe]

Well the caster shouldn't be issuing the order there, because the
order won't execute in sufficient time to deal it out to every single
picked.

 

[Alain.Mark]

Well the caster shouldn't be issuing the order there, because the
order won't execute in sufficient time to deal it out to every single
picked.

that caster is just the dummy caster and not the original casting unit.

 

[Bribe]

Have you tested it?

The dummy caster would have to be created for each cast of the spell.

 

[Alain.Mark]

Fixed some stuff and now it works. Here's the code again.

loop
    set target=FirstOfGroup(affected)
    exitwhen target==null
    call GroupRemoveUnit(affected,target)
    if(IsUnitEnemy(target,pl))then
        call UnitAddAbility(caster,spellid)
        call SetUnitX(caster,GetUnitX(target))
        call SetUnitY(caster,GetUnitY(target))
        call IssueTargetOrder(caster,orderstr,target)
        call UnitRemoveAbility(caster,spellid)
    endif
endloop

Now i can dummy cast spells on multiple units w/ only one dummy caster

 

[Bribe]

So adding and removing the ability instantly lets the spell fire instantly - great!

This should revolutionize dummy casting, because now we don't have to use dummy recycling either except if we use them for attaching special effects or have them channeling spells.

 

[Alain.Mark]

WTF! is this a new discovery or something oh my after a few months i actually contributed something useful here

Might as well call this solved.

 

[Magtheridon96]

I guess UnitRemoveAbility checks if the spell is being cast.
If that returns true, it fires the spell and removes it to avoid bugs.

 

[Switch33]

What ability was it? Did it have an spell cast duration? Maybe the ability is also part of the reason it was able to cast completely instantly?

Also i think Diablo Builder did as close as i've seen to this already sorta with item scrolls.

 

[Alain.Mark]

I tried it with three spells. Entangling Roots, Frost Nova and Frenzy (spells must be instant).

Results:

Unholy Frenzy and Frenzy: 16 out 16 units got affected
Entangling Roots: 12 out of 16 got affected.
Frost Nova:10 out 16 got affected.

i will try to find out later why this happens if i have free time.

 

[Bribe]

Make sure the dummy has 0 backswing and cast point, the spell has 0 channel time, the cast ranges are set to maximum and also you can remove the 'Amov' ability from the dummy unit.

 

[Pharaoh_]

Actually, I remember this "war" of loops against filtering and trust me, no one came off claiming that filtering is faster than loops.

 

[Alain.Mark]

Here's my theory on how the trick works, a single instance of ability (being cast) will only accept one order at a time... so we need to remove it and add it again in order to have a fresh instance of the ability that will accommodate the incoming order to cast.

btw... i haven't made a decent testmap yet.

 

[Alain.Mark]

*bump*
I only retried testing it again (applying Bribe's tip)
*significant for dummy casting

*Unholy Frenzy: 20 out of 20
Entangling Roots: 13 out of 20
Frost Nova: 13 out of 20
*Slow: 20 out of 20