[System] GetUnitRegeneration

[Magtheridon96]

The title explains it all.

/********************************************************
*
*   GetUnitRegeneration
*   v2.0.0.0
*   By Magtheridon96
*
*   - Gets unit regeneration values
*
*   Requirements:
*   -------------
*
*       - UnitIndexer by Nestharus
*           - hiveworkshop.com/forums/jass-resources-412/system-unit-indexer-172090/
*       - DamageEvent by Nestharus
*           - hiveworkshop.com/forums/jass-resources-412/snippet-damageevent-186829/
*       - Heal by Magtheridon96
*           - hiveworkshop.com/forums/jass-resources-412/system-heal-203662/
*       - CTL by Nestharus
*           - hiveworkshop.com/forums/jass-resources-412/snippet-constant-timer-loop-32-a-201381/
*
*       Optional:
*       ---------
*
*       - DamageControl by PurgeandFire111
*           - hiveworkshop.com/forums/jass-resources-412/system-damage-control-204672/
*
*   API:
*   ----
*
*       - function IsUnitRegenerating takes unit u returns boolean
*           - Tells whether a unit is regenerating or not.
*       - function IsUnitRegeneratingById takes integer i returns boolean
*           - Tells whether a unit is regenerating or not given the Id.
*       - function GetUnitRegeneration takes unit u returns real
*           - Gets the amount of regeneration for a given unit.
*       - function GetUnitRegenerationById takes integer i returns real
*           - Gets the amount of regeneration for a given unit given the Id.
*       - function IsRegenerationPositive takes unit u returns boolean
*           - Tells whether the regeneration is positive.
*       - function IsRegenerationPositiveById takes integer i returns boolean
*           - Tells whether the regeneration is positive given the Id.
*
********************************************************/
library GetUnitRegeneration requires UnitIndexer, DamageEvent, Heal, CTL, optional DamageControl
    
    private struct UnitRegen extends array
        
        static thistype array next
        static thistype array prev
        
        static real array life
        static real array max
        static real array damaged
        static real array amount
        
        static boolean array regenerating
        
        static method damage takes nothing returns nothing
            static if LIBRARY_DamageControl then
                set damaged[DamageEvent.targetId] = damaged[DamageEvent.targetId] + DamageControl.result
            else
                set damaged[DamageEvent.targetId] = damaged[DamageEvent.targetId] + DamageEvent.amount
            endif
        endmethod
        
        static method heal takes nothing returns nothing
            set damaged[Heal.targetId] = damaged[Heal.targetId] - Heal.effective
        endmethod
        
        static method index takes nothing returns nothing
            // Add index to list
            set next[GetIndexedUnitId()] = 0
            set prev[GetIndexedUnitId()] = prev[0]
            set next[prev[0]] = GetIndexedUnitId()
            set prev[0] = GetIndexedUnitId()
            
            // Setting current life and max life
            set life[GetIndexedUnitId()] = GetWidgetLife(GetIndexedUnit())
            set max[GetIndexedUnitId()] = GetUnitState(GetIndexedUnit(), UNIT_STATE_MAX_LIFE)
        endmethod
        
        static method deindex takes nothing returns nothing
            set regenerating[GetIndexedUnitId()] = false
            
            // Remove from list
            set next[prev[GetIndexedUnitId()]] = next[GetIndexedUnitId()]
            set prev[next[GetIndexedUnitId()]] = prev[GetIndexedUnitId()]
            
            // Resetting Data
            set amount[GetIndexedUnitId()] = 0
            set damaged[GetIndexedUnitId()] = 0
            
            set regenerating[GetIndexedUnitId()] = false
        endmethod
        
        implement CT32
        
            local thistype this = next[0]
            local real hp = 0
            local real ml = 0
            
            loop
                exitwhen 0 == this
                
                set ml = GetUnitState(GetUnitById(this), UNIT_STATE_MAX_LIFE)
                
                if max[this] != ml then
                    set life[this] = life[this] * (ml / max[this])
                endif
                
                set hp = GetWidgetLife(GetUnitById(this)) + damaged[this]
                
                if hp != life[this] then
                    set amount[this] = (hp - life[this]) / 0.03125
                    set regenerating[this] = true
                    set life[this] = hp - damaged[this]
                else
                    set regenerating[this] = false
                    set amount[this] = 0
                endif
                
                set damaged[this] = 0
                set max[this] = ml
                
                set this = next[this]
            endloop
            
        implement CT32End
        
        private static code indexCode
        private static code deindexCode
        private static code damageCode
        private static code healCode
        
        private static method onInit takes nothing returns nothing
        
            set indexCode = function thistype.index
            set deindexCode = function thistype.deindex
            set damageCode = function thistype.damage
            set healCode = function thistype.heal
            
            static if LIBRARY_DamageControl then
                call DamageControl.FINAL.register(Filter(damageCode))
            else
                call DamageEvent.ANY.register(Filter(damageCode))
            endif
            
            call RegisterAnyHealEvent(healCode)
            call UnitIndexer.INDEX.register(Filter(indexCode))
            call UnitIndexer.DEINDEX.register(Filter(deindexCode))
        endmethod
        
    endstruct
    
    function IsUnitRegenerating takes unit u returns boolean
        return UnitRegen.regenerating[GetUnitUserData(u)]
    endfunction
    
    function IsUnitRegeneratingById takes integer i returns boolean
        return UnitRegen.regenerating[i]
    endfunction
    
    function GetUnitRegeneration takes unit u returns real
        return UnitRegen.amount[GetUnitUserData(u)]
    endfunction
    
    function GetUnitRegenerationById takes integer i returns real
        return UnitRegen.amount[i]
    endfunction
    
    function IsRegenerationPositive takes unit u returns boolean
        return UnitRegen.amount[GetUnitUserData(u)] >= 0
    endfunction
    
    function IsRegenerationPositiveById takes integer i returns boolean
        return UnitRegen.amount[i] >= 0
    endfunction
    
endlibrary

library IsUnitRegenerating requires GetUnitRegeneration
endlibrary

Feel free to comment..

 

[Deuterium]

okay this code is a bit too advanced for me...

however, as i understood it just checks for a fluctuation in hp & thus determines whether the unit is regenerating or not? regardless of whether it's regening just over time by doing nothing or regening thru a spell or item?

 

[Magtheridon96]

It only compares the HP that the unit had 0.03125 seconds ago with the HP that it has now
Actually, I found a bug in this and I just fixed it
It will now return 100% accurate values even while the unit is taking damage (I didn't update yet but I will)

edit
Update.

I tested this thing A LOT.
I even learned something about regeneration..
I created a peasant and when I displayed the regeneration 32x a second, it went from 0.240 to 0.280 to 0.240 all the time..

 

[baassee]

The amount of GetIndexedUnitId() calls

 

[Bribe]

"UnitIndexStruct" needs to be implemented below the "index" method.

@baassee, that function inlines to a single global variable.

 

[Magtheridon96]

Yeah, but GetIndexedUnitId() gets inlined into nothing but a variable ;p

edit
lol Bribe you beat me to it
Oh and I fixed that ^_^

 

[baassee]

It does? Always thought counterwise.

 

[Magtheridon96]

So Bribe, what do you think?

 

[Ceday]

User may change a unit's life with triggers for a spell, or triggered damage block etc.(bad user )

Unit may pick up - drop an item that increases his max hp or get a hp bonus skill directly or upgrades.

Unit may gain - lose a level or str.

Dead or removed units.

I suppose skills like heal, regen aura with positive or negative value will count as regeneration so okay

 

[Magtheridon96]

I made this so that even when you take damage, the regeneration would still be accurate.
Yes, a unit may pickup items and ruin it, but this is accurate enough most of the time so ..

 

[Bribe]

Does unit regeneration really happen so quickly? Last I checked it happened less frequently.

I recommend checking if the unit's life has increased/decreased by the exact same amount as the time before.

I also don't know what this is useful for. Why would I want to know if a unit is regenerating?

 

[baassee]

I also don't know what this is useful for. Why would I want to know if a unit is regenerating?

I can only think of one possible situation. Mini-game.

 

[Magtheridon96]

Why would I want to know if a unit is regenerating?

>_<
There are tons of scenarios where this could be useful. Example:
- A spell that depends on a unit's regeneration

I recommend checking if the unit's life has increased/decreased by the exact same amount as the time before.

That wouldn't work :/
I tried it with a peasant:
His regen:
0.240
0.280
0.240
0.280
0.240
0.280
0.240
....

 

[Bribe]

Well try it with four sweeps to see if the pattern fits?

I'd rather have this show as "not regenerating" the first 0.1 seconds than having it bug with random hit point fluxuations.

 

[Magtheridon96]

Sure, why not

 

[Nestharus]

What I really want is a library that enables -regen auras. I made one once and it killed the map ;o.

 

[Bribe]

Just trigger the negative regen aura.

 

[Magtheridon96]

Here's a fix for my iteration method:

private static method iterate takes nothing returns nothing
            local thistype this = next[0]
            local real hp = 0
            local real ml = 0
            loop
                exitwhen 0 == this
                set ml = GetUnitState(.unit,UNIT_STATE_MAX_LIFE)
                if .maxlife != ml then
                    set .life = .life * (ml/.maxlife)
                endif
                set hp = GetWidgetLife(.unit) + .damaged
                if hp != .life then
                    set .amount = (hp-.life)/PERIOD
                    set .regenerating = true
                    set .positive = (hp > .life)
                    set .life = hp - .damaged
                else
                    set .regenerating = false
                    set .positive = true
                    set .amount = 0.0
                endif
                set .damaged = 0.0
                set .maxlife = ml
                set this = next[this]
            endloop
        endmethod

This won't bug with any HP fluctuations (item pickups, leveling down, leveling up, losing an attribute, etc..).. EXCEPT:
SetWidgetLife(unit,xxxx)

That can't be fixed without hooking SetWidgetLife...
Do you think it would be worth it? :/

 

[baassee]

You can use a constant choosing with or without hooking and static if but that's a bit overkill (Not even sure if you can static if out the hook line). I would keep it without though but dunno all heal libraries use SetWidgetLife :/

 

[Magtheridon96]

Maybe I should create my own Heal library then
I could create a heal library that sets the units life and fires an Event that runs a function that modifies the life value ^_^

 

[Bribe]

I still recommend checking to see if the regeneration follows that pattern
of low, high, low, and on that third iteration it's classifiable as regenerating.

Maybe I should create my own Heal library then
I could create a heal library that sets the units life and fires an Event that runs a function that modifies the life value ^_^

There is already something like this on wc3c.net. And it sucks of course.

 

[baassee]

There is already something like this on wc3c.net. And it sucks of course.

And at TH, a bit better but I changed it to use Nest's Event instead and some other minor stuff.

 

[Magtheridon96]

Good idea Bribe

Oh and you guys inspired me to actually write my own Heal library

edit
Actually Bribe, I don't think I'm going to do that :/

edit

Updated.
The only times you're going to use SetWidgetLife:
- Healing a unit
- Setting life to 100%

I made this require "Heal" (which I just posted) so that the only time this system could bug is when you wanna set the unit's life for some unknown reason.
I could fix this by hooking SetWidgetLife, but that would slow the system down.. alot.

 

[Deuterium]

honestly... since i have already done this in a spell, i dont see the need of a system to check for whether the unit is regenerating cause it would take in a spell or wherever it is being used is 2 variables and a condition (& definetly the timer being used for the spell itself)

 

[Magtheridon96]

You don't see how a system that checks if a unit is regenerating and returns the value of the unit's regeneration is useful?
I'm already using this to display unit stats on a Multiboard.

 

[Troll-Brain]

Yes it's specific but it's useful in few cases.
And i suppose making it as an addon of heal library instead of merging it, is fine coz of its specific usage.

 

[Switch33]

Would http://www.hiveworkshop.com/forums/submissions-414/system-damage-control-204672/ interfere with the accuracy of this?

 

[PurgeandFire]

Would http://www.hiveworkshop.com/forums/submissions-414/system-damage-control-204672/ interfere with the accuracy of this?

You can just switch the event from DamageEvent.ANY to DamageControl.FINAL and then instead of DamageEvent.amount, use DamageEvent.result. Then it should work fine.

 

[Switch33]

then instead of DamageEvent.amount, use DamageEvent.result.

Should be-- then instead of DamageEvent.amount, use DamageControl.result.

But yeah, that works for now. This script should be updated though to incorporate the option of using DamageControl.

 

[Magtheridon96]

Fascinating =o

I'll do those changes

edit
Updated:
- Increased accuracy by adding support for DamageControl
- Now uses CTL

 

[baassee]

Aaaahh soon I will be forced to switch from T32 into CTL...

This is so unnecessary but you can remove the requires UnitIndexer as it already requires DamageEvent which requires UnitIndexer

 

[Magtheridon96]

But overwhelming people with requirements before they even implement the library is my thang ^^

 

[Bribe]

IsUnitRegenerating is pretty much going to return positive in 99% of the cases. The only times I couldn't think of are for undead on blight or elves at night.

Is this seriously worth a library to detect that?

Edit: Well, it works and it does what it's supposed to. The user can decide if it's useful for him/her. Approved.

 

[Magtheridon96]

How about I change it to GetUnitRegeneration?
The name would make it sound more useful ^_^

 

[Laiev]

GetUnitRegeneration -> regeneration itself (real)
IsUnitRegenerating -> regenerating? (boolean)

 

[Magtheridon96]

The whole point of this library is to detect unit regeneration and retrieve the amount.
I think the 'GetRegeneration' functionality is way better than the 'IsRegenerating' one
I think a title change and a small update to reduce code length is needed here

 

[Laiev]

function IsUnitRegenerating takes unit u returns boolean
    return GetUnitRegeneration(u) > 0.
endfunction

At least make it compatible with the current version

 

[Magtheridon96]

Actually, regeneration can be negative, so I'm using a boolean for that
I'm using the function you posted to detect positive regeneration in the new version ;P (Got rid of that useless global)

edit
Updated.

edit
Bribe, can you change the name of the thread to GetUnitRegeneration? :>

 

[baassee]

Regeneration should always be positive? That's the point with it that you "regenerates" healthpoints?

 

[Magtheridon96]

A unit can degenerate life (Hold shift in the object editor and modify his regeneration)

 

[baassee]

Yeah that's "degenerate" and not "regenerate". And don't say negative regeneration because it's sounds so stupid.

 

[RiotApe]

sorry but I suck when it comes to jass, but I need this system for a spell of mine in my map. how do i implement this?

 

[Magtheridon96]

First, you need to install JNGP: http://www.hiveworkshop.com/forums/...456/how-download-install-confige-jngp-160547/

After that, just create a new trigger, paste the code in it, and these are the functions you'll be able to use these functions:

- IsUnitRegenerating(unit) -> boolean
- IsUnitRegeneratingById(integer) -> boolean
- GetUnitRegeneration(unit u) -> real
- GetUnitRegenerationById(integer) -> real
- IsRegenerationPositive(unit) -> boolean
- IsRegenerationPositiveById(integer) -> boolean

To the functions that end with ById, you have to use the custom value as the integer.
The other functions take a unit variable.

Example:

• Custom script: set udg_TempReal = GetUnitRegeneration(udg_TempUnit)

 

[Nestharus]

This should be updated to use AdvDamageEvent with a low priority (0 priority).

This should also use DamageType that way you can check, for example, if the damage type is regen =). You should include the type to check for and it should extend off of a DAMAGE_TYPE_HEAL ; ). From there, people can extend off of your type. From here, you'll be able to determine whether to add or subtract the damage resulting from DamageEvent ;p. After all, this should return true if the unit is current under the effect of a healing spell, shouldn't it? : ).


Otherwise it looks quite good, gj.


Do I see any particular uses for this? No, but I see no other problems with the design and it can definitely be used in a map, even if I don't know what that possible use if =P.

I'd totally +rep you if I could ;o.

 

[Bribe]

It could be useful to give a regeneration % bonus.

 

[Magtheridon96]

Well, I'll get to this.

/inserts GetUnitRegeneration in Work Queue, position: 15
o-o

edit
I found a way to optimize the loop a bit.

Also, I'm going to update this to use a different Timeout so that I can get the values to stop switching after each iteration o-o

 

[Almia]

uhh, what is IsUnitRegenerating lib for?

 

[Magtheridon96]

Backwards compatibility.