Is this indexing system efficient?

[bOb666777]

It seems like it could lag if I put a few spells using this system:

globals
    Movespell array m
    integer movespellcount = 0
endglobals

struct Movespell
    unit target
    unit caster
    integer level
endstruct

function Trig_MoveSpell_Conditions takes nothing returns boolean
    return GetSpellAbilityId() == SpellId()
endfunction

function callback takes nothing returns nothing
    local Movespell data
    local integer structloop = 0
    loop
        exitwhen structloop == 8191
        if (m[structloop] != 0) then
            set data = m[structloop]
            //Actions here
        endif
        set structloop = structloop + 1
    endloop
endfunction
    
    

function Trig_MoveSpell_Actions takes nothing returns nothing
    local Movespell data = Movespell.create()
    local unit u = GetTriggerUnit()
    local unit target = GetSpellTargetUnit()
    set data.level = GetUnitAbilityLevel(u, SpellId())
    set data.caster = u 
    set data.target = target
    if (movespellcount < 8191) then
        set m[movespellcount] = data
        set movespellcount = movespellcount + 1
    else
        set movespellcount = 0
        loop 
            exitwhen m[movespellcount] != 0 or movespellcount == 8191
            set movespellcount = movespellcount + 1
        endloop
        if (movespellcount == 8191) then
            call BJDebugMsg("Too many instances running, try again later.")
        else 
            set m[movespellcount] = data
        endif
    endif
    set u = null
    set target = null
endfunction

//===========================================================================
function InitTrig_MoveSpell takes nothing returns nothing
    local trigger t = CreateTrigger(  )
    local timer time = CreateTimer()
    call TimerStart(time, 0.02, true, function callback)
    call TriggerRegisterAnyUnitEventBJ( t, EVENT_PLAYER_UNIT_SPELL_EFFECT )
    call TriggerAddCondition( t, Condition( function Trig_MoveSpell_Conditions ) )
    call TriggerAddAction( t, function Trig_MoveSpell_Actions )
endfunction

In case you don't get it, what it does is whenever a unit casts the spell, it sets a global integer + 1 and stores the struct in an array, then the timer loops between all 8191 indexes of that array, running the ones that have a value. Can that be laggy?

 

[Sooda]

Key is recycling. Examine Vexorian tutorial on wc3c.net -- Moving from handle variables to structs.

To make it short initialization trigger increases index, loop handle all instances (action part) and when instance ends last instance data will replace that instance data and once more is same loop ran. Example is best:

Init Trig

set index = index (plus) 1 // on keyboard my plus key does not function
set data[index] = TriggerUnit()
set duration[index] = 10.
// Maybe timer check here, pause and restart if needed wait is less than current timer wait.
if Timer time remaining greater than duration[index] then
pause Timer
start Timer as one shot timer which will expire in duration[index] seconds
endif

Actions Trig
local instanceIndex = 0 // could be global variable
loop
set instanceIndex = instanceIndex (pluss) 1
set duration[instanceIndex] = duration[instanceIndex] - Timer Elapsed Time
if duration[instanceIndex] <= 0. then
set duration[instanceIndex] = duration[index] // index was global variable
set data[instanceIndex] = data[index]
// check once more because last instance was moved to end instance place
// Global index needs to be reduced by 1 (by last moved instance)
set instanceIndex = instanceIndex (pluss) 1
set index = index - 1
endloop InstanceIndex == index // was it endloop? Ends loop when all instances have been scanned.
else
// instance has still remaining time, do do something like periodic damage here
end
endloop


Free hand example but idea remains same, use debugging messages to spot errors in your future code which use Static Timer, your idea which is used much is called Static Timer.

 

[kingkingyyk3]

use 0.035 in your timer could reducing some performance issue.

 

[bOb666777]

So,
>Free hand example but idea remains same, use debugging messages to spot errors in your future code which use Static Timer, your idea which is used much is called Static Timer.
That means the method I currently use is fine?

> use 0.035 in your timer could reducing some performance issue.
I'll try...

 

[Sooda]

> That means...

No, this is correct way of making it: vJass for spell makers (Moving from handle vars to structs) by Vexorian.

 

[bOb666777]

Okay sorry for not answering for about a week, didn't actually notice you replied. So, after reading that page, it seems the only difference is pausing the timer when it's unused?

 

[Trollvottel]

You only loop n times (where n is the number of instances)
if some instance ends you simply put the struct at position n to your current position and reduce n by one. much better than looping 8000+ times

pseudo:

function ....
 local integer i = N
 loop
    exitwhen i == 0
    
    if Exitcondition(Struct<i>) then
        set Struct<i> = Struct[N]
        set N = N - 1
        if N == 0 then
            call PauseTimer(GetExpiredTimer())
        endif
   endif
   set i = i - 1

endfunction

</i></i>