Efficient way to trigger unit regeneration?

[Tom_Kazansky]

My map is having some fps drops, well actually, it's not "smooth" so I think this has something to do with periodic trigger and I suspect the unit regeneration trigger.

Here is my code:

globals
    constant real tj_REGENERATION_FRAMES = 10.
    constant integer tj_InCombatTime = 30 //3 seconds
endglobals

struct myUnit

    static trigger Trig

    implement LinkedList // Kenny's
    
    static method UnitRegeneration takes nothing returns boolean
        local thistype this = UnitDataList.head
        local real st
        local real stm
        loop
            exitwhen 0==this
            if this.inCombat > 0 then
                set this.inCombat = this.inCombat-1
            endif
            
            if this.lifeRegenTick>0. then
                if this.lifeReserved>0. then
                    set st = GetUnitState(this.SELF,UNIT_STATE_LIFE) + this.lifeRegenTick
                    if st>this.lifeCurReserved then
                        set st=this.lifeCurReserved
                    endif
                    call SetUnitState(this.SELF, UNIT_STATE_LIFE, st)
                else
                    call SetUnitState(this.SELF, UNIT_STATE_LIFE, GetUnitState(this.SELF,UNIT_STATE_LIFE) + this.lifeRegenTick)
                endif
            endif
            if this.manaRegenTick>0. then
                if this.manaReserved>0. then
                    set st = GetUnitState(this.SELF,UNIT_STATE_MANA) + this.manaRegenTick
                    if st>this.manaCurReserved then
                        set st=this.manaCurReserved
                    endif
                    call SetUnitState(this.SELF, UNIT_STATE_MANA, st)
                else
                    call SetUnitState(this.SELF, UNIT_STATE_MANA, GetUnitState(this.SELF,UNIT_STATE_MANA) + this.manaRegenTick)
                endif
            endif
            set this = this.next
        endloop
        return false
    endmethod
    
    static method TimerEx takes nothing returns nothing
        call TriggerEvaluate( thistype.Trig )
    endmethod
    

    //... other members
endstruct

function MapInit takes nothing returns nothing
    set tjunit.Trig = CreateTrigger()
    call TriggerAddCondition( tjunit.Trig, Condition( function myUnit.UnitRegeneration ))
    call TimerStart( CreateTimer(), 1 / tj_REGENERATION_FRAMES , true, function myUnit.TimerEx )
    //...
endfunction

note on members:

• lifeRegenTick/manaRegenTick: life/mana regenerated every interval (currently: 0.1)
• lifeReserved/manaReserved: as the name implied, this will reserve life/mana.
  e.g: you have 500 max life and 100 reserved life, normally you can have 500/500 life but now you can only have 400/500 life
• lifeCurReserved/manaCurReserved: this is the max life/mana that have subtracted the reserved amount (lifeReserved/manaReserved)
• inCombat: determine whether or not a unit is in-combat
• SELF: the unit that this struct is attached to

the size of this linked list is about 60 at map start and later 100 (and it increases as the number of creeps increases)

when a unit dies, it will be removed from this list immediately.

so erm... is this efficient enough? is there anyways to improve this?

---
I also have other period trigger to check unit buffs which run every 0.05s but when there is no buffs, I doubt it would affect anything.

 

[Dirac]

Instead of trigger evaluations use the same interface T32 does

EDIT: i'm sorry if i wasn't more clear, use this:

struct A

private unit unit
private thistype next
private thistype prev

static method create takes unit whichUnit returns nothing
local thistype this=thistype.allocate()
//set all your vars in this area
set this.unit=whichUnit
//linked list configuration
set thistype(0).next.prev=this
set this.next=thistype(0).next
set thistype(0).next=this
set this.prev=thistype(0)
endmethod

private static method periodic takes nothing returns nothing
local thistype this=thistype(0).next
loop
extiwhen this==0
//do regeneration stuff here
endloop
endmethod

private static method onInit takes nothing returns nothing
call TimerStart(CreateTimer(),PERIOD,true,function thistype.periodic)
endmethod

endstruct

This works exactly as T32 works and is optimized for even more speed

 

[WaterKnight]

Not sure why you need the evaluation and return false.
Instead of

call SetUnitState(<unit>, UNIT_STATE_LIFE, <value>)

you can use

native SetWidgetLife takes widget whichWidget, real newLife returns nothing

to save on parameter.
Rather than reading out the same value 3 times from struct, you may consider setting a local variable.
You may split it up and kick out units that do not meet the conditions beforehand. Why do you need to set inCombat here?
If you monitor life/mana completely, you can replace GetUnitState and store the value yourself.
Is applying the regeneration 10 times per second really necessary?

 

[Tom_Kazansky]

@Dirac, thanks, I'm gonna use it.

>Not sure why you need the evaluation and return false.

I'm just imitating Timer32

>Rather than reading out the same value 3 times from struct, you may consider setting a local variable.

hmmm... ok

>You may split it up and kick out units that do not meet the conditions beforehand. Why do you need to set inCombat here?

so you mean: units with both lifeRegenTick and manaRegenTick equal to zero will be kicked out?
I have some stuffs that involve inCombat so I think it's best to put the inCombat check here. Should I set this seperately?
maybe I should set inCombat for heroes only.

>If you monitor life/mana completely, you can replace GetUnitState and store the value yourself.

hmm... yea, why didn't I think of this, I did monitor life/mana completely :banghead:

>Is applying the regeneration 10 times per second really necessary?

I don't think I get your point but 10 times per second is okay, right?

 

[WaterKnight]

I do not know if it is faster and it also depends on your exact situation but these are possibilities. Maybe SetState/GetState is faster than this.life=/SetState/this.life after all. Well, decreasing the frequency would of course help greatly. Regeneration is mostly a slow process in gameplay and it does not come down to a split second. Is it not okay to do it every 0.25-0.5 seconds?

 

[Tom_Kazansky]

>I do not know if it is faster and it also depends on your exact situation but these are possibilities. Maybe SetState/GetState is faster than this.life=/SetState/this.life after all.

hmm... I don't know either, can any experienced jass-ers verify this?

>Is it not okay to do it every 0.25-0.5 seconds?

I think 0.25-0.5 would be too slow, I will stick with 0.1

 

[Dirac]

Array lookup is as fast as it gets, its always better to store values inside arrays if possible instead of using a function to get to them